// 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::HW_ReadActionRegister(ActionConfig *job) {
    memcpy(job, &cfg, sizeof(ActionConfig));
}

void MockAcquisitionDevice::HW_WriteActionRegister(const ActionConfig *job) {
    memcpy(&cfg, job,  sizeof(ActionConfig));
}

void MockAcquisitionDevice::HW_StartAction() {
    idle = false;
}

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

bool MockAcquisitionDevice::HW_IsIdle() const {
    return true;
}

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 = 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,
            .frame_number = current_handle * 128
    });
    idle = true;
}

uint64_t MockAcquisitionDevice::HW_GetMACAddress() const {
    return 0; // Doesn't matter
}

uint32_t MockAcquisitionDevice::HW_GetIPv4Address() const {
    return 0;
}

void MockAcquisitionDevice::HW_GetStatus(ActionStatus *status) const {
    memset(status, 0, sizeof(ActionStatus));
    status->max_modules = max_modules;
    status->modules_internal_packet_generator = 1;
}

void MockAcquisitionDevice::CopyInternalPacketGenFrameToDeviceBuffer() {}
void MockAcquisitionDevice::InitializeCalibration(const DiffractionExperiment &experiment, const JFCalibration &calib) {}