#pragma once

#include "ByteCommand.h"
#include "ByteCommandQueue.h"
#include "ReadCalibrationPointCommand.h"
#include "ComplexCommand.h"

namespace Incart::DeviceComplexCommands
{

class ReadExternAccCalibrationPointsCommand final : public Usb::ComplexCommand
{
    Q_OBJECT
private:
    const uint8_t m_accChannelType = 0x01;

    Usb::ByteCommandQueue* m_commandQueue;
    uint8_t m_currChannelNumber = 0;
    uint8_t m_currPointIndex = 0;
    std::vector<Usb::CalibrationPoint> m_calibrationPoints;

public:
    ReadExternAccCalibrationPointsCommand(uint32_t uid, Usb::ByteCommandQueue* commandQueue, QObject* _parent = nullptr) : Usb::ComplexCommand("ReadExternAccCalibrationPoints", uid, _parent),
        m_commandQueue(commandQueue), m_calibrationPoints(6)
    {
    }

signals:
    void answerIsReady(Usb::ComplexCommand* command, std::vector<Usb::CalibrationPoint> calibrationPoints, std::shared_ptr<Usb::DeviceCommandStatus> status);

public:
    std::shared_ptr<Usb::DeviceCommandStatus> execute() override
    {
        std::cout << __PRETTY_FUNCTION__ << std::endl;
        m_currPointIndex = 0;
        m_currChannelNumber = 0;
        return sendCommand();
    }

private slots:
    void handleCalibrationIsRead(Usb::ComplexCommand* command, Usb::CalibrationPoint calibrationPoint, std::shared_ptr<Usb::DeviceCommandStatus> status)
    {
        removeExecutedInnerCommand(command);
        if (status->status != Usb::DeviceCommand::EStatus::OK)
        {
          emit answerIsReady(this, std::vector<Usb::CalibrationPoint>(), status);
          return;
        }

        m_calibrationPoints[m_currChannelNumber * 2 + m_currPointIndex] = calibrationPoint;

        m_currPointIndex++;
        if (m_currPointIndex >= 2)
        {
            m_currPointIndex = 0;
            m_currChannelNumber++;
        }
        if (m_currChannelNumber >= 3)
        {
            std::vector<Usb::CalibrationPoint> calibrationInfo;
            for (int i = 0; i < 6; i++)
            {
                calibrationInfo.push_back(m_calibrationPoints[i]);
            }
            emit answerIsReady(this, calibrationInfo, std::make_shared<Usb::DeviceCommandStatus>(Usb::DeviceCommand::EStatus::OK));

            m_currPointIndex = 0;
            m_currChannelNumber = 0;
            return;
        }

        sendCommand();
    }

private:
    std::shared_ptr<Usb::DeviceCommandStatus> sendCommand()
    {
        //JTerminal() << __PRETTY_FUNCTION__;
        std::shared_ptr<ReadCalibrationPointCommand> command = std::make_shared<ReadCalibrationPointCommand>(m_commandQueue->generateUid(), m_currPointIndex, m_accChannelType, m_currChannelNumber, true, m_commandQueue);
        addExecutedInnerCommand(command);
        connect(command.get(), &ReadCalibrationPointCommand::answerIsReady, this, &ReadExternAccCalibrationPointsCommand::handleCalibrationIsRead);
        return executeCommand(command);
    }
};

} // namespace Incart::DeviceComplexCommands