#pragma once

#include "LsbChannelInfo.h"
#include "ReadInnerChannelsLsbCommand.h"
#include "ReadInnerChannelsCalibrationCommand.h"
#include "MicroMonCalibrationInfoCreators.h"
#include "DeviceChannelTypeStringParser.h"

#include <iostream>

namespace Incart::DeviceComplexCommands
{

class MicroMonReadInnerChannelsLsbCommand final : public Usb::ReadInnerChannelsLsbCommand
{
private:
    Usb::ByteCommandQueue* const m_commandQueue;
    std::unordered_map<DevicesInfo::DeviceChannelTypeInfo, Usb::LsbChannelInfo> m_channelsLsbInfo;

public:
    MicroMonReadInnerChannelsLsbCommand(uint32_t uid, const std::unordered_map<DevicesInfo::DeviceChannelTypeInfo, Usb::LsbChannelInfo>& channelsLsbInfo, Usb::ByteCommandQueue* const commandQueue)
      : Usb::ReadInnerChannelsLsbCommand(uid)
      , m_commandQueue(commandQueue)
      , m_channelsLsbInfo(channelsLsbInfo)
    {
    }

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, &MicroMonReadInnerChannelsLsbCommand::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::unordered_map<DevicesInfo::DeviceChannelTypeInfo, std::vector<Usb::CalibrationInfo>> calibrationInfo;
        if (status->status != Usb::DeviceCommand::EStatus::OK)
        {
            emit answerIsReady(this, calibrationInfo, status);
            return;
        }
        /*
        int k = 0;
        for (auto it = m_channelsLsbInfo.begin(); it != m_channelsLsbInfo.end(); ++it,++k)
        {
            std::cout << "m_channelsLsbInfo[" << k << "] " << static_cast<int>(it->first.type) << " " << static_cast<int>(it->first.sourceType) << " | " << static_cast<int>(it->second.channelType) << std::endl;
        }
        */
        for (auto it = calibrationInfo_.begin(); it != calibrationInfo_.end(); ++it)
        {
            uint8_t channelType = (*it)->getChannelType();
            auto channelMappedInfo = getChannelMappedInfo(channelType);
            if (channelMappedInfo.first.type != DevicesInfo::EDeviceChannelType::Unknown)
            {
                std::shared_ptr<Usb::ICalibrationInfoCreator> calibInfoCreator = std::dynamic_pointer_cast<Usb::ICalibrationInfoCreator>(channelMappedInfo.second.calibrationInfoCreator);
                std::vector<Usb::CalibrationInfo> channelCalibrationInfo;
                size_t channelCount = channelMappedInfo.second.signalCount;
                std::vector<Usb::CalibrationPoint>& calibrationPoints = (*it)->getCalibrationPoints();
                for (size_t i = 0; i < channelCount; ++i)
                {
                    channelCalibrationInfo.push_back(calibInfoCreator->createCalibrationInfo(static_cast<uint8_t>(i), calibrationPoints));
                }
                calibrationInfo[channelMappedInfo.first] = channelCalibrationInfo;
            }
        }
        emit answerIsReady(this, calibrationInfo, std::make_shared<Usb::DeviceCommandStatus>(Usb::DeviceCommand::EStatus::OK));
    }

private:
    std::pair<DevicesInfo::DeviceChannelTypeInfo, Usb::LsbChannelInfo> getChannelMappedInfo(uint8_t channelType_)
    {
        for (auto it = m_channelsLsbInfo.begin(); it != m_channelsLsbInfo.end(); ++it)
        {
            if ((it->second.channelType == channelType_) && (it->first.source == DevicesInfo::EDeviceChannelSourceType::Device))
            {
                return std::pair<DevicesInfo::DeviceChannelTypeInfo, Usb::LsbChannelInfo>(it->first, it->second);
            }
        }
        return std::pair<DevicesInfo::DeviceChannelTypeInfo, Usb::LsbChannelInfo>({DevicesInfo::EDeviceChannelType::Unknown, DevicesInfo::EDeviceChannelSourceType::Unknown}, {});
    }
};

} // namespace Incart::DeviceComplexCommands