#pragma once

#include "ReadExternAccLsbCommand.h"
#include "ReadExternAccCalibrationCommand.h"
#include "MicroMonCalibrationInfoCreators.h"

namespace Incart::DeviceComplexCommands
{

class MicroMonReadExternAccLsbCommand final : public Usb::ReadExternAccLsbCommand
{
private:
    Usb::ByteCommandQueue* const m_commandQueue;
    Usb::MicroMonExternAccCalibrationInfoCreator m_calibInfoCreator;

public:
    MicroMonReadExternAccLsbCommand(uint32_t uid, Usb::ByteCommandQueue* const commandQueue)
      : Usb::ReadExternAccLsbCommand(uid)
      , m_commandQueue(commandQueue)
    {
    }

public:
    std::shared_ptr<Usb::DeviceCommandStatus> execute() override
    {
        std::shared_ptr<ReadExternAccCalibrationCommand> command = std::make_shared<ReadExternAccCalibrationCommand>(m_commandQueue->generateUid(), m_commandQueue);
        addExecutedInnerCommand(command);
        connect(command.get(), &ReadExternAccCalibrationCommand::answerIsReady, this, &MicroMonReadExternAccLsbCommand::handleAnswerIsReady);
        return executeCommand(command);
    }

private slots:
    void handleAnswerIsReady(ComplexCommand* command, std::vector<Usb::CalibrationPoint> calibrationInfo, std::shared_ptr<Usb::DeviceCommandStatus> status)
    {
        removeExecutedInnerCommand(command);
        std::vector<Usb::CalibrationInfo> lsbList;
        if (status->status != Usb::DeviceCommand::EStatus::OK)
        {
            emit answerIsReady(this, lsbList, status);
            return;
        }
        for (int i = 0; i < 3; i++)
        {
            lsbList.push_back(m_calibInfoCreator.createCalibrationInfo(i, calibrationInfo));
        }
        emit answerIsReady(this, lsbList, status);
    }
};

} // namespace Incart::DeviceComplexCommands