// Copyright (2019-2022) Paul Scherrer Institute
// SPDX-License-Identifier: GPL-3.0-or-later

#include "JFJochWriterService.h"

#include <filesystem>

JFJochWriterService::JFJochWriterService(ZMQContext &in_context, Logger &in_logger) :
logger(in_logger), zmq_context(in_context) {}

grpc::Status JFJochWriterService::Start(grpc::ServerContext *context, const JFJochProtoBuf::WriterInput *request,
                                        JFJochProtoBuf::Empty *response) {
    std::unique_lock<std::shared_mutex> ul(m);
    try {
        if (writer)
            writer.reset();
        logger.Info("Starting writer");

        writer = std::make_unique<StreamWriter>(zmq_context, logger, request->zmq_receiver_address());
        writer_future = std::async(std::launch::async, &StreamWriter::Run, writer.get());

        logger.Info("   ... done.");
        return grpc::Status::OK;
    } catch (JFJochException &e) {
        logger.ErrorException(e);
        return {grpc::StatusCode::ABORTED, e.what()};
    }
}

grpc::Status JFJochWriterService::Stop(grpc::ServerContext *context, const JFJochProtoBuf::Empty *request,
                                       JFJochProtoBuf::WriterOutput *response) {
    try {
        {
            std::shared_lock<std::shared_mutex> ul(m);
            logger.Info("Stopping writer");
            if (writer_future.valid()) {
                auto ret = writer_future.get();
                response->set_nimages(ret.image_puller_stats.processed_images);
                response->set_performance_mbs(ret.image_puller_stats.performance_MBs);
                response->set_performance_hz(ret.image_puller_stats.performance_Hz);
                for (const auto &f: ret.data_file_stats) {
                    auto *tmp = response->add_file_statistics();
                    tmp->set_name(f.filename);
                    tmp->set_nimages(f.max_image_number + 1);
                }
            } else {
                response->set_nimages(0);
                response->set_performance_mbs(0);
                response->set_performance_hz(0);
            }
        }
        {
            std::unique_lock<std::shared_mutex> ul(m);
            if (writer)
                writer.reset();
        }
        logger.Info("Done");
        return grpc::Status::OK;
    } catch (JFJochException &e) {
        return {grpc::StatusCode::ABORTED, e.what()};
    }
}

grpc::Status JFJochWriterService::Abort(grpc::ServerContext *context, const JFJochProtoBuf::Empty *request,
                                        JFJochProtoBuf::Empty *response) {
    std::shared_lock<std::shared_mutex> ul(m);
    if (writer)
        writer->Abort();
    return grpc::Status::OK;
}


JFJochWriterService &JFJochWriterService::BaseDirectory(const std::string &input) {
    logger.Info("Setting base directory to " + input);
    try {
        std::filesystem::current_path(input);
    } catch (const std::filesystem::filesystem_error& err) {
        logger.Error("Cannot set base directory: " + std::string(err.what()));
        throw JFJochException(JFJochExceptionCategory::FileWriteError,
                              "Cannot set base directory " + std::string(err.what()));
    }
    return *this;
}