#pragma once

#include "DeviceComplexJsonCommand.h"
#include "SetExaminationInfoCommand.h"
#include "ExaminationInfo.h"
#include "UsbDeviceManager.h"
#include "ElectrodesInfoCreator.h"
#include "ComplexCommandCreateMultidata.h"

namespace Incart::DeviceWebApi
{

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

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

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

public:
    static std::shared_ptr<Net::WebApi::JsonCommandDescription> createCommandDescription()
    {
        return std::make_shared<Net::WebApi::JsonCommandDescription>("SetExaminationInfo",
          std::make_shared<Net::WebApi::NamelessJsonCommandObjectUnit>(std::vector<std::shared_ptr<Net::WebApi::JsonCommandUnit>>{
            std::make_shared<Net::WebApi::JsonCommandUnit>("PatientId", Net::WebApi::EJsonCommandUnitType::String),
            std::make_shared<Net::WebApi::JsonCommandUnit>("Name", Net::WebApi::EJsonCommandUnitType::String),
            std::make_shared<Net::WebApi::JsonCommandUnit>("Surname", Net::WebApi::EJsonCommandUnitType::String),
            std::make_shared<Net::WebApi::JsonCommandUnit>("Patronymic", Net::WebApi::EJsonCommandUnitType::String),
            std::make_shared<Net::WebApi::JsonCommandUnit>("BirthdayDate", Net::WebApi::EJsonCommandUnitType::String),
            std::make_shared<Net::WebApi::JsonCommandUnit>("Sex", Net::WebApi::EJsonCommandUnitType::String),
            std::make_shared<Net::WebApi::JsonCommandUnit>("StartTime", Net::WebApi::EJsonCommandUnitType::String),
            std::make_shared<Net::WebApi::JsonCommandUnit>("LeadType", Net::WebApi::EJsonCommandUnitType::Int),
            std::make_shared<Net::WebApi::JsonCommandUnit>("FileName", Net::WebApi::EJsonCommandUnitType::String),
            std::make_shared<Net::WebApi::JsonCommandObjectUnit>("CableInfo", std::vector<std::shared_ptr<Net::WebApi::JsonCommandUnit>>{
              std::make_shared<Net::WebApi::JsonCommandUnit>("Type", Net::WebApi::EJsonCommandUnitType::Int),
              std::make_shared<Net::WebApi::JsonCommandUnit>("Number", Net::WebApi::EJsonCommandUnitType::Int),
              std::make_shared<Net::WebApi::JsonCommandUnit>("SetupCounter", Net::WebApi::EJsonCommandUnitType::Int)
            })
          }), std::make_shared<Net::WebApi::NamelessEmptyJsonCommandUnit>()
        );
    }

    std::shared_ptr<Net::WebApi::JsonCommandStatus> execute(std::shared_ptr<Net::WebApi::IJsonCommandInfo> launchedCommandInfo_) override
    {
        std::shared_ptr<Net::WebApi::VariantJsonCommandInfo> launchedCommandInfo = std::dynamic_pointer_cast<Net::WebApi::VariantJsonCommandInfo>(launchedCommandInfo_);
        uid = launchedCommandInfo->uid;
        if (launchedCommandInfo->data.isNull())
        {
            std::cout << __PRETTY_FUNCTION__ << " json object interpretation error" << std::endl;
            return DeviceWebApi::JsonCommandStatusCreator::create(Usb::DeviceCommand::EStatus::BAD_DATA);
        }
        QVariantMap jsonMap = launchedCommandInfo->data.toMap();

        DeviceComplexCommands::ExaminationInfo examinationInfo;
        examinationInfo.patientId = jsonMap["PatientId"].toString().toStdString();
        examinationInfo.name = jsonMap["Name"].toString().toStdString();
        examinationInfo.surname = jsonMap["Surname"].toString().toStdString();
        examinationInfo.patronymic = jsonMap["Patronymic"].toString().toStdString();
        examinationInfo.birthdayDate = Common::DateObject::fromString(jsonMap["BirthdayDate"].toString().toStdString());
        examinationInfo.sex = DeviceComplexCommands::PatientSex{jsonMap["Sex"].toString().toStdString() };
        examinationInfo.startTime = Common::DateTimeObject::fromString(jsonMap["StartTime"].toString().toStdString());
        uint8_t leadType = static_cast<uint8_t>(jsonMap["LeadType"].toInt());
        examinationInfo.electrodes = DeviceComplexCommands::ElectrodesInfoCreator::create(leadType);
        examinationInfo.fileName = jsonMap["FileName"].toString().toStdString();
        QVariantMap cableInfoJson = jsonMap["CableInfo"].toMap();
        examinationInfo.cableInfo.CableType = static_cast<uint8_t>(cableInfoJson["Type"].toUInt());
        examinationInfo.cableInfo.CableNumber = static_cast<uint32_t>(cableInfoJson["Number"].toUInt());
        examinationInfo.cableInfo.SetupCounter = static_cast<uint32_t>(cableInfoJson["SetupCounter"].toUInt());

        std::shared_ptr<Usb::IComplexCommandCreateData> commandData = std::make_shared<Usb::ComplexCommandCreateMultidata<uint32_t, DeviceComplexCommands::ExaminationInfo>>(m_commandQueue->generateUid(), examinationInfo);
        std::shared_ptr<DeviceComplexCommands::SetExaminationInfoCommand> command = std::dynamic_pointer_cast<DeviceComplexCommands::SetExaminationInfoCommand>(m_usbDeviceCommands->createComplexCommand(launchedCommandInfo->name, commandData));
        m_executedCommands[command.get()] = command;
        connect(command.get(), &DeviceComplexCommands::SetExaminationInfoCommand::answerIsReady, this, &SetExaminationInfoJsonCommand::handleAnswerIsReady);
        return executeCommand(command);
    }

private slots:
    void handleAnswerIsReady(Usb::ComplexCommand* command, std::shared_ptr<Usb::DeviceCommandStatus> status)
    {
        removeExecutedCommand(command);
        emit answerIsReady(this, QJsonDocument(), DeviceWebApi::JsonCommandStatusCreator::create(status));
    }
};

} // namespace Incart::DeviceWebApi