#pragma once

#include "WriteExternAccDefaultCalibrationCommand.h"
#include "ByteCommandQueue.h"
#include "WriteCalibrationPointCommandCreator.h"

namespace Incart::DeviceComplexCommands
{

class MicroMonWriteExternAccDefaultCalibrationCommand final : public WriteExternAccDefaultCalibrationCommand
{
    Q_OBJECT
private:
    const uint8_t m_accChannelType = 0x01;

    Usb::ByteCommandQueue* const m_commandQueue;
    uint8_t m_currChannelNumber = 0;
    uint8_t m_currPointIndex = 0;

public:
    MicroMonWriteExternAccDefaultCalibrationCommand(uint32_t uid, Usb::ByteCommandQueue* const commandQueue)
      : WriteExternAccDefaultCalibrationCommand(uid)
      , m_commandQueue(commandQueue)
    {
    }

    std::shared_ptr<Usb::DeviceCommandStatus> execute() override
    {
        m_currPointIndex = 0;
        m_currChannelNumber = 0;
        clearAllCalibrations();
        return std::make_shared<Usb::DeviceCommandStatus>(Usb::DeviceCommand::EStatus::OK);
    }

private slots:
    void handleClearAllCalibrationsAnswer(std::shared_ptr<Usb::ByteCommand> /*command*/, std::vector<uint8_t> answer, int32_t status)
    {
        if (status != Usb::DeviceCommand::EStatus::OK)
        {
            emit answerIsReady(this, Usb::DeviceCommandStatusCreator::create(answer, status));
            return;
        }
        writeCalibrationPoint();
    }

    void handleWriteCalibrationPointAnswerIsReady(std::shared_ptr<Usb::ByteCommand> /*command*/, const std::vector<uint8_t>& answer, int32_t status)
    {
        if (status != Usb::DeviceCommand::EStatus::OK)
        {
            emit answerIsReady(this, Usb::DeviceCommandStatusCreator::create(answer, status));
            return;
        }

        m_currPointIndex++;
        if (m_currPointIndex >= 2)
        {
            m_currPointIndex = 0;
            m_currChannelNumber++;
        }
        if (m_currChannelNumber >= 3)
        {
            saveCalibrationPoints();
            return;
        }
        writeCalibrationPoint();
    }

    void handleSaveCalibrationPointsAnswer(std::shared_ptr<Usb::ByteCommand> /*command*/, std::vector<uint8_t> answer, int32_t status)
    {
        if (status != Usb::DeviceCommand::EStatus::OK)
        {
            emit answerIsReady(this, Usb::DeviceCommandStatusCreator::create(answer, status));
            return;
        }
        emit answerIsReady(this, std::make_shared<Usb::DeviceCommandStatus>(Usb::DeviceCommand::EStatus::OK));
    }

private:
    // Стирание всей информации о калибровке
    void clearAllCalibrations()
    {
        std::shared_ptr<Usb::ByteCommand> command = std::make_shared<Usb::ByteCommand>("ClearAllCalibrations", m_commandQueue->generateUid(), std::vector<uint8_t>{ 0x7e, 0x01, 0x00, 0x22, 0x04, 0xff, 0xff, 0xbd}, 5000);
        connect(command.get(), &Usb::ByteCommand::answerIsReady, this, &MicroMonWriteExternAccDefaultCalibrationCommand::handleClearAllCalibrationsAnswer);
        m_commandQueue->enqueue(command);
    }

    // Запись информации о калибровке (одной точки)
    void writeCalibrationPoint()
    {
        uint32_t  adcValue = 0;
        int32_t physicValue = 0;
        if (m_currPointIndex == 1)
        {
            adcValue = 1000;
            physicValue = 1;
        }
        std::shared_ptr<Usb::ByteCommand> command = WriteCalibrationPointCommandCreator::create(m_commandQueue, true, m_accChannelType, m_currChannelNumber, m_currPointIndex,
            adcValue, physicValue, 0);
        connect(command.get(), &Usb::ByteCommand::answerIsReady, this, &MicroMonWriteExternAccDefaultCalibrationCommand::handleWriteCalibrationPointAnswerIsReady);
        m_commandQueue->enqueue(command);
    }

    // сохраняем калибровки в постоянную память
    void saveCalibrationPoints()
    {
        std::shared_ptr<Usb::ByteCommand> command = std::make_shared<Usb::ByteCommand>("SaveCalibrationPoints", m_commandQueue->generateUid(), std::vector<uint8_t>{ 0x7e, 0x01, 0x00, 0x22, 0x03, 0xff, 0xff, 0xbd}, 5000);
        connect(command.get(), &Usb::ByteCommand::answerIsReady, this, &MicroMonWriteExternAccDefaultCalibrationCommand::handleSaveCalibrationPointsAnswer);
        m_commandQueue->enqueue(command);
    }
};

} // namespace Incart::DeviceComplexCommands