#pragma once

#include "UsbDeviceManager.h"
#include "ReadCalibrationPointCommand.h"
#include "DeviceComplexJsonCommand.h"
#include "ReadExternAccCalibrationPointsCommand.h"
#include "ComplexCommandCreateData.h"

namespace Incart::DeviceWebApi
{

class ReadExternAccCalibrationPointsJsonCommand final : public DeviceComplexJsonCommand
{
private:
    Usb::ByteCommandQueue* const m_commandQueue;
    Usb::UsbDeviceCommandSet* const m_usbDeviceCommands;

public:
    ReadExternAccCalibrationPointsJsonCommand(std::shared_ptr<Net::WebApi::JsonCommandDescription> description, Usb::UsbDeviceManager* const usbDeviceManager) : DeviceComplexJsonCommand(description)
      , m_commandQueue(usbDeviceManager->getCommandQueue())
      , m_usbDeviceCommands(usbDeviceManager->getCommandSet())
    {
    }

    ReadExternAccCalibrationPointsJsonCommand(Usb::UsbDeviceManager* const usbDeviceManager) : ReadExternAccCalibrationPointsJsonCommand(createCommandDescription(), usbDeviceManager)
    {
    }

public:
    static std::shared_ptr<Net::WebApi::JsonCommandDescription> createCommandDescription()
    {
        return std::make_shared<Net::WebApi::JsonCommandDescription>("ReadExternAccCalibrationPoints",
          std::make_shared<Net::WebApi::NamelessEmptyJsonCommandUnit>(), std::make_shared<Net::WebApi::NamelessJsonCommandObjectUnit>(std::vector<std::shared_ptr<Net::WebApi::JsonCommandUnit>>{
            std::make_shared<Net::WebApi::JsonCommandUnit>("PointIndex", Net::WebApi::EJsonCommandUnitType::String),
            std::make_shared<Net::WebApi::JsonCommandUnit>("ChannelType", Net::WebApi::EJsonCommandUnitType::String),
            std::make_shared<Net::WebApi::JsonCommandUnit>("ChannelNumber", Net::WebApi::EJsonCommandUnitType::String),
            std::make_shared<Net::WebApi::JsonCommandUnit>("AdcValue", Net::WebApi::EJsonCommandUnitType::String),
            std::make_shared<Net::WebApi::JsonCommandUnit>("PhysicalValue", Net::WebApi::EJsonCommandUnitType::String),
            std::make_shared<Net::WebApi::JsonCommandUnit>("Range", Net::WebApi::EJsonCommandUnitType::String),
            std::make_shared<Net::WebApi::JsonCommandUnit>("IsValid", Net::WebApi::EJsonCommandUnitType::String)
          })
        );
    }

    std::shared_ptr<Net::WebApi::JsonCommandStatus> execute(std::shared_ptr<Net::WebApi::IJsonCommandInfo> launchedCommandInfo) override
    {
        //Common::JTerminal() << __PRETTY_FUNCTION__;
        uid = launchedCommandInfo->uid;
        std::shared_ptr<Usb::IComplexCommandCreateData> commandData = std::make_shared<Usb::ComplexCommandCreateData<uint32_t>>(m_commandQueue->generateUid());
        std::shared_ptr<DeviceComplexCommands::ReadExternAccCalibrationPointsCommand> command = std::dynamic_pointer_cast<DeviceComplexCommands::ReadExternAccCalibrationPointsCommand>(m_usbDeviceCommands->createComplexCommand(launchedCommandInfo->name, commandData));
        m_executedCommands[command.get()] = command;
        connect(command.get(), &DeviceComplexCommands::ReadExternAccCalibrationPointsCommand::answerIsReady, this, &ReadExternAccCalibrationPointsJsonCommand::handleCommandAnswerIsReady);
        return executeCommand(command);
    }

private slots:
    void handleCommandAnswerIsReady(Usb::ComplexCommand* command, std::vector<Usb::CalibrationPoint> calibrationPoints, std::shared_ptr<Usb::DeviceCommandStatus> status)
    {
        removeExecutedCommand(command);
        emit answerIsReady(this, packCalibrationInfoToJson(calibrationPoints), DeviceWebApi::JsonCommandStatusCreator::create(status));
    }

private:
    QJsonDocument packCalibrationInfoToJson(const std::vector<Usb::CalibrationPoint>& calibrationPoints)
    {
        QJsonArray pntArray;
        for (auto it = calibrationPoints.begin(); it != calibrationPoints.end(); it++)
        {
            pntArray.append(packCalibrationPointInfoToJson(*it));
        }
        QJsonObject out({{"CalibrationPoints", pntArray}});
        return QJsonDocument(out);
    }

    QJsonObject packCalibrationPointInfoToJson(const Usb::CalibrationPoint& point)
    {
        QJsonObject out({
            {"PointIndex", QString::number(static_cast<int>(point.PointIndex))},
            {"ChannelType", QString::number(static_cast<int>(point.ChannelType))},
            {"ChannelNumber", QString::number(static_cast<int>(point.ChannelNumber))},
            {"AdcValue", QString::number(static_cast<uint>(point.AdcValue))},
            {"PhysicalValue", QString::number(static_cast<double>(point.PhysicalValue))},
            {"Range", QString::number(static_cast<int>(point.Range))},
            {"IsValid", (point.IsValid ? "true" : "false")}
        });
        return out;
    }
};

} // namespace Incart::DeviceWebApi