#pragma once

#include "DeviceComplexJsonCommand.h"
#include "ReadInnerChannelsLsbCommand.h"
#include "UsbDeviceManager.h"
#include "AdcChannelsManager.h"
#include "ComplexCommandCreateMultidata.h"
#include "ReadInnerChannelsCalibrationCommand.h"

namespace Incart::DeviceWebApi
{

class ReadInnerChannelsCalibrationJsonCommand final : public DeviceComplexJsonCommand
{
private:
    Usb::ByteCommandQueue* const m_commandQueue;
    Usb::UsbDeviceCommandSet* const m_deviceCommands;
    Usb::AdcChannelsManager* const m_signalManager;

public:
    ReadInnerChannelsCalibrationJsonCommand(std::shared_ptr<Net::WebApi::JsonCommandDescription> description, Usb::UsbDeviceManager* const usbDeviceManager, Usb::AdcChannelsManager* const signalManager) : DeviceComplexJsonCommand(description)
      , m_commandQueue(usbDeviceManager->getCommandQueue())
      , m_deviceCommands(usbDeviceManager->getCommandSet())
      , m_signalManager(signalManager)
    {
    }

    ReadInnerChannelsCalibrationJsonCommand(Usb::UsbDeviceManager* const usbDeviceManager, Usb::AdcChannelsManager* const signalManager) : ReadInnerChannelsCalibrationJsonCommand(createCommandDescription(), usbDeviceManager, signalManager)
    {
    }

public:
    static std::shared_ptr<Net::WebApi::JsonCommandDescription> createCommandDescription()
    {
        return std::make_shared<Net::WebApi::JsonCommandDescription>("ReadInnerChannelsCalibration",
          std::make_shared<Net::WebApi::NamelessEmptyJsonCommandUnit>(),  std::make_shared<Net::WebApi::NamelessEmptyJsonCommandUnit>()
        );
    }

    std::shared_ptr<Net::WebApi::JsonCommandStatus> execute(std::shared_ptr<Net::WebApi::IJsonCommandInfo> launchedCommandInfo) override
    {
        uid = launchedCommandInfo->uid;
        std::shared_ptr<Usb::IComplexCommandCreateData> commandData = std::make_shared<Usb::ComplexCommandCreateData<uint32_t>>(m_commandQueue->generateUid());
        std::shared_ptr<DeviceComplexCommands::ReadInnerChannelsCalibrationCommand> command = std::dynamic_pointer_cast<DeviceComplexCommands::ReadInnerChannelsCalibrationCommand>(m_deviceCommands->createComplexCommand("ReadInnerChannelsCalibration", commandData));
        m_executedCommands[command.get()] = command;
        connect(command.get(), &DeviceComplexCommands::ReadInnerChannelsCalibrationCommand::answerIsReady, this, &ReadInnerChannelsCalibrationJsonCommand::handleCommandAnswerIsReady);
        return executeCommand(command);
    }

private slots:
    void handleCommandAnswerIsReady(Usb::ComplexCommand* command, std::vector<std::shared_ptr<DeviceComplexCommands::ChannelGroupCalibrationInfo>> calibrationInfo, std::shared_ptr<Usb::DeviceCommandStatus> status)
    {
        std::string commandName = command->getName();
        removeExecutedCommand(command);
        if (status->status != Usb::DeviceCommand::EStatus::OK)
        {
            emit answerIsReady(this, QJsonDocument(), DeviceWebApi::JsonCommandStatusCreator::create(status));
            return;
        }
        std::unordered_map<DevicesInfo::DeviceChannelTypeInfo, Usb::LsbChannelInfo> channelsLsbInfo = m_signalManager->getSignalsLsbInfo();
        /*
        int k = 0;
        for (auto it = channelsLsbInfo.begin(); it != channelsLsbInfo.end(); ++it,++k)
        {
            std::cout << "channelsLsbInfo[" << k << "] " << static_cast<int>(it->first.type) << " " << static_cast<int>(it->first.sourceType) << " | " << static_cast<int>(it->second.channelType) << std::endl;
        }
        */
        QJsonArray channelInfoArray;
        for (auto it = calibrationInfo.begin(); it != calibrationInfo.end(); ++it)
        {
            uint8_t channelType = (*it)->getChannelType();
            auto channelLsbInfo = getLsbInfo(channelType, channelsLsbInfo);
            if (channelLsbInfo.first.type != DevicesInfo::EDeviceChannelType::Unknown)
            {
                QJsonArray mapArray;
                QJsonArray clbKArray;
                QJsonArray clbBArray;
                auto calibrationInfoCreator = channelLsbInfo.second.calibrationInfoCreator;
                size_t signalCount = channelLsbInfo.second.signalCount;
                std::vector<Usb::CalibrationPoint>& calibrationPoints = (*it)->getCalibrationPoints();
                for (size_t signalIndex = 0; signalIndex < signalCount; ++signalIndex)
                {
                    Usb::CalibrationInfo calibrationInfo = calibrationInfoCreator->createCalibrationInfo(static_cast<uint8_t>(signalIndex), calibrationPoints);
                    mapArray.append(static_cast<int>(signalIndex));
                    clbKArray.append(static_cast<int>(calibrationInfo.k));
                    clbBArray.append(static_cast<int>(calibrationInfo.b));
                }
                std::string channelName = m_signalManager->getChannelName(channelLsbInfo.first);

                QJsonObject channelInfoObject({
                  {"Name", QString::fromStdString(channelName)},
                  {"Map", mapArray},
                  {"clbK", clbKArray},
                  {"clbB", clbBArray}
                });
                channelInfoArray.append(channelInfoObject);
            }
        }
        QJsonObject calibInfoObject({{"Channels", channelInfoArray}});
        emit answerIsReady(this, QJsonDocument(calibInfoObject), DeviceWebApi::JsonCommandStatusCreator::create(status));
    }

private:
    std::pair<DevicesInfo::DeviceChannelTypeInfo, Usb::LsbChannelInfo> getLsbInfo(uint8_t channelType_,  const std::unordered_map<DevicesInfo::DeviceChannelTypeInfo, Usb::LsbChannelInfo>& channelsLsbInfo)
    {
        for (auto it = channelsLsbInfo.begin(); it != 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::DeviceWebApi