Jungfraujoch/reader/JFJochStartMessageReader.h

// SPDX-FileCopyrightText: 2026 Filip Leonarski, Paul Scherrer Institute <filip.leonarski@psi.ch>
// SPDX-License-Identifier: GPL-3.0-only

#pragma once

#include <condition_variable>
#include <mutex>
#include <stdexcept>
#include <string>
#include <vector>

#include "JFJochReader.h"
#include "HDF5ImageSource.h"

// The broker that reported a collection's data files can no longer be heard from, and an image this
// reader was asked for has not been reported: it will never be read.
class LiveCollectionLost : public std::runtime_error {
public:
    explicit LiveCollectionLost(const std::string &what) : std::runtime_error(what) {}
};

// The dataset as the start message describes it - the same quantities an HDF5 master states, taken
// from the message the writer wrote it from.
std::shared_ptr<JFJochReaderDataset> DatasetFromStartMessage(const StartMessage &start,
                                                             const DiffractionExperiment &defaults);

// Reads a collection while it is being written: the dataset comes from its start message, as the
// broker sends it, and the images straight from the data files - /entry/data/data in each - once the
// broker reports a file closed and renamed into place (FileClosed). A read of an image whose file has
// not been reported waits for it; after Ended it returns false for an image no file holds, and after
// Lost it throws. The master file is never read.
class JFJochStartMessageReader : public JFJochReader {
public:
    // master_path: where the collection's master file will be; the data files are next to it.
    void Open(const StartMessage &start, const std::string &master_path);

    void FileClosed(uint64_t file_number, uint64_t image_count);
    void Ended();
    void Lost(const std::string &why);

    [[nodiscard]] uint64_t GetNumberOfImages() const override;
    void Close() override;
    bool ReadRawImage(int64_t image_number, JFJochReaderRawImage &image) override;
    std::vector<SpotToSave> ReadSpots(int64_t image) const override { return {}; }

private:
    bool LoadImage_i(std::shared_ptr<JFJochReaderDataset> &dataset, DataMessage &message,
                     std::vector<uint8_t> &buffer, int64_t image_number, bool update_dataset) override;
    // Waits until the file of this image is reported; false when the collection ended without it.
    bool WaitForImage(int64_t image_number);

    HDF5ImageSource image_source_;
    uint64_t number_of_images_ = 0;
    uint64_t images_per_file_ = 1;

    std::mutex m_;
    std::condition_variable cv_;
    std::vector<int64_t> file_images_;   // per data file: images it holds, -1 while not reported
    bool ended_ = false;
    std::string lost_;
};