#pragma once

#include "ReadEcgLsbCommand.h"
#include "ReadInnerChannelsCalibrationCommand.h"
#include "MicroMonLsbCreators.h"

namespace Incart::DeviceComplexCommands
{

class MicroMonReadEcgLsbCommand final : public Usb::ReadEcgLsbCommand
{
private:
    Usb::ByteCommandQueue* const m_commandQueue;
    int32_t m_channelCount;
    Usb::MicroMonEcgLsbCreator m_lsbCreator;

public:
    MicroMonReadEcgLsbCommand(uint32_t uid, Usb::ByteCommandQueue* const commandQueue, int32_t channelCount)
      : Usb::ReadEcgLsbCommand(uid)
      , m_commandQueue(commandQueue)
      , m_channelCount(channelCount)
    {
    }

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

private slots:
    void handleAnswerIsReady(Usb::ComplexCommand* command, std::vector<std::shared_ptr<ChannelGroupCalibrationInfo>> calibrationInfo, std::shared_ptr<Usb::DeviceCommandStatus> status)
    {
        removeExecutedInnerCommand(command);
        std::vector<Usb::SignalLsbInfo> lsbList;
        if (status->status != Usb::DeviceCommand::EStatus::OK)
        {
            emit answerIsReady(this, lsbList, status);
            return;
        }
        std::shared_ptr<ChannelGroupCalibrationInfo> ecgCalibrationInfo = getCalibrations(calibrationInfo, 0);
        std::vector<Usb::CalibrationPoint> ecgCalibrationPoints = ecgCalibrationInfo->getCalibrationPoints();
        for (int i = 0; i < m_channelCount; i++)
        {
            lsbList.push_back(Usb::SignalLsbInfo{m_lsbCreator.createLsb(i, ecgCalibrationPoints), static_cast<int32_t>(ecgCalibrationPoints[i * 2].AdcValue)});
        }
        emit answerIsReady(this, lsbList, status);
    }

private:
    std::shared_ptr<ChannelGroupCalibrationInfo> getCalibrations(const std::vector<std::shared_ptr<ChannelGroupCalibrationInfo>>& _calibrationInfo, int _type)
    {
        for (auto it = _calibrationInfo.begin(); it != _calibrationInfo.end(); it++)
        {
            if ((*it)->getChannelType() == _type)
            {
                return *it;
            }
        }
        return nullptr;
    }
};

} // namespace Incart::DeviceComplexCommands