#pragma once

#include "DeviceComplexJsonCommand.h"
#include "GetDataFromEepromCommand.h"
#include <QJsonObject>
#include "UsbDeviceManager.h"
#include "ComplexCommandCreateMultidata.h"
#include "EEeramVersion9Address.h"
#include "ByteArrayProvider.h"
#include "InfoMap.h"

namespace Incart::DeviceWebApi
{

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

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

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

public:
    static std::shared_ptr<Net::WebApi::JsonCommandDescription> createCommandDescription()
    {
        return std::make_shared<Net::WebApi::JsonCommandDescription>("GetExamFileName",
          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>("FileName", Net::WebApi::EJsonCommandUnitType::String)
          })
        );
    }

    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::ComplexCommandCreateMultidata<uint32_t, uint16_t, uint16_t>>(m_commandQueue->generateUid(), static_cast<uint16_t>(DeviceComplexCommands::EEeramVersion9Address::AuxExamInfo), sizeof(uint16_t));
        std::shared_ptr<DeviceComplexCommands::GetDataFromEepromCommand> command = std::dynamic_pointer_cast<DeviceComplexCommands::GetDataFromEepromCommand>(m_usbDeviceCommands->createComplexCommand("GetDataFromEeprom", commandData));
        m_executedCommands[command.get()] = command;
        connect(command.get(), &DeviceComplexCommands::GetDataFromEepromCommand::answerIsReady, this, &GetExamFileNameJsonCommand::handleReadInfoMapLengthIsReady);
        return executeCommand(command);
    }

private slots:
    void handleReadInfoMapLengthIsReady(Usb::ComplexCommand* command, std::vector<uint8_t> data, std::shared_ptr<Usb::DeviceCommandStatus> status)
    {
        removeExecutedCommand(command);
        if (status->status != Usb::DeviceCommand::EStatus::OK)
        {
            emit answerIsReady(this, QJsonDocument(), DeviceWebApi::JsonCommandStatusCreator::create(status));
            return;
        }

        uint16_t infoMapLength = Common::ByteArrayProvider::getWordFromArray(data, 0);

        std::shared_ptr<Usb::IComplexCommandCreateData> readInfoMapCommandData = std::make_shared<Usb::ComplexCommandCreateMultidata<uint32_t, uint16_t, uint16_t>>(m_commandQueue->generateUid(), static_cast<uint16_t>(DeviceComplexCommands::EEeramVersion9Address::AuxExamInfo) + sizeof(uint16_t), infoMapLength);
        std::shared_ptr<DeviceComplexCommands::GetDataFromEepromCommand> readInfoMapCommand = std::dynamic_pointer_cast<DeviceComplexCommands::GetDataFromEepromCommand>(m_usbDeviceCommands->createComplexCommand("GetDataFromEeprom", readInfoMapCommandData));
        m_executedCommands[readInfoMapCommand.get()] = readInfoMapCommand;
        connect(readInfoMapCommand.get(), &DeviceComplexCommands::GetDataFromEepromCommand::answerIsReady, this, &GetExamFileNameJsonCommand::handleReadInfoMapIsReady);
        std::shared_ptr<Net::WebApi::JsonCommandStatus> jsonStatus = executeCommand(readInfoMapCommand);
        if (jsonStatus->result != Net::WebApi::EJsonCommandStatus::OK)
        {
            emit answerIsReady(this, QJsonDocument(), jsonStatus);
            return;
        }
    }

    void handleReadInfoMapIsReady(Usb::ComplexCommand* command, std::vector<uint8_t> data, std::shared_ptr<Usb::DeviceCommandStatus> status)
    {
        removeExecutedCommand(command);
        if (status->status != Usb::DeviceCommand::EStatus::OK)
        {
            emit answerIsReady(this, QJsonDocument(), DeviceWebApi::JsonCommandStatusCreator::create(status));
            return;
        }
        DeviceComplexCommands::InfoMap infoMap;
        infoMap.readFromBuffer(data);
        if (!infoMap.contains("fname"))
        {
            emit answerIsReady(this, QJsonDocument(), DeviceWebApi::JsonCommandStatusCreator::create(Usb::DeviceCommand::EStatus::BAD_DATA));
            return;
        }
        std::string examFileName = infoMap.getValue<std::string>("fname");

        QJsonObject jsonResult({
            {"FileName", QString::fromStdString(examFileName)}
        });
        QJsonDocument answer(jsonResult);
        emit answerIsReady(this, answer, DeviceWebApi::JsonCommandStatusCreator::create(status));
    }
};

} // namespace Incart::DeviceWebApi