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

#include "MockAcquisitionDevice.h"
#include "../common/JFJochException.h"
#include <bitset>

void MockAcquisitionDevice::Start(const DiffractionExperiment& experiment) {
    idle = false;
}

void MockAcquisitionDevice::Cancel() {
    if (!idle) {
        if (logger)
            logger->Info("MockAcquisitionDevice cancelling " + std::to_string(data_stream));
        Terminate();
    }
}

MockAcquisitionDevice::MockAcquisitionDevice(uint16_t data_stream, size_t in_frame_buffer_size_modules)
: AcquisitionDevice(data_stream) {
    max_modules = 16;
    MapBuffersStandard(in_frame_buffer_size_modules, 1, -1);
    max_handle = in_frame_buffer_size_modules;
    work_completion_queue.Put(Completion{.type = Completion::Type::Start});
}

void MockAcquisitionDevice::SendCompletion(uint32_t handle, uint16_t module_number, uint64_t frame_number) {
    Completion c;
    c.handle = handle;
    c.module_number = module_number;
    c.frame_number = frame_number - 1;
    c.type = Completion::Type::Image;
    c.packet_mask[0] = UINT64_MAX;
    c.packet_mask[1] = UINT64_MAX;
    c.packet_count = 128;
    work_completion_queue.Put(c);
}

void MockAcquisitionDevice::AddModule(uint64_t frame_number, uint16_t module_number, const uint16_t *data) {

    if (module_number >= max_modules)
        throw JFJochException(JFJochExceptionCategory::ArrayOutOfBounds,
                              "Module number exceeding limit");

    if (current_handle < max_handle) {
        memcpy(buffer_device.at(current_handle), data, RAW_MODULE_SIZE * sizeof(uint16_t));
        SendCompletion(current_handle, module_number, frame_number);
        current_handle++;
    } else {
        throw JFJochException(JFJochExceptionCategory::ArrayOutOfBounds, "No buffer handles left");
    }
}

void MockAcquisitionDevice::Terminate() {
    work_completion_queue.Put(Completion{
            .type = Completion::Type::End
    });
    idle = true;
}

std::string MockAcquisitionDevice::GetMACAddress() const {
    return "00:00:00:00:00:00";
}

std::string MockAcquisitionDevice::GetIPv4Address() const {
    return "127.0.0.1";
}