#pragma once

#include "DeviceComplexJsonCommand.h"
#include "UsbDeviceManager.h"
#include "JsonCommandStatusCreator.h"
#include "DeviceSeriesParser.h"
#include <QJsonObject>
#include <QTcpSocket>

namespace Incart::DeviceWebApi
{

// Адаптированно для прибора: КТ-07-АД-3 (тип 38) HW 1.00, SW 1.23, ревизия ПО 1.03, GuiVer: 4.7
class GetDeviceInfoJsonCommand final : public DeviceComplexJsonCommand
{
private:
    const uint16_t m_startAddressLastModDate = 0x040a;

    Usb::UsbDeviceManager* m_usbDeviceManager;
    Usb::DeviceInfo m_deviceInfo;
    uint32_t m_deviceNumber;
    uint32_t m_deviceGuiVersion;
    uint16_t m_revision;
    uint16_t m_setupCounter;
    std::string m_lastModDate;
    uint8_t m_deviceState;
    std::string m_deviceStateText;

public:
    GetDeviceInfoJsonCommand(std::shared_ptr<Net::WebApi::JsonCommandDescription> description, Usb::UsbDeviceManager* usbDeviceManager) : DeviceComplexJsonCommand(description)
        , m_usbDeviceManager(usbDeviceManager)
        , m_deviceInfo(m_usbDeviceManager->getConnectedDeviceInfo())
        , m_lastModDate("?")
    {
    }

    GetDeviceInfoJsonCommand(Usb::UsbDeviceManager* usbDeviceManager) : GetDeviceInfoJsonCommand(createCommandDescription(), usbDeviceManager)
    {
    }

public:
    static std::shared_ptr<Net::WebApi::JsonCommandDescription> createCommandDescription()
    {
        return std::make_shared<Net::WebApi::JsonCommandDescription>("GetDevInfo",
          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>("Name", Net::WebApi::EJsonCommandUnitType::String),
            std::make_shared<Net::WebApi::JsonCommandUnit>("Type", Net::WebApi::EJsonCommandUnitType::Int),
            std::make_shared<Net::WebApi::JsonCommandUnit>("HardVer", Net::WebApi::EJsonCommandUnitType::String),
            std::make_shared<Net::WebApi::JsonCommandUnit>("SoftVer", Net::WebApi::EJsonCommandUnitType::String),
            std::make_shared<Net::WebApi::JsonCommandUnit>("VersionExtension", Net::WebApi::EJsonCommandUnitType::String),
            std::make_shared<Net::WebApi::JsonCommandUnit>("Number", Net::WebApi::EJsonCommandUnitType::Int),
            std::make_shared<Net::WebApi::JsonCommandUnit>("GuiVersion", Net::WebApi::EJsonCommandUnitType::String),
            std::make_shared<Net::WebApi::JsonCommandUnit>("Revision", Net::WebApi::EJsonCommandUnitType::String),
            std::make_shared<Net::WebApi::JsonCommandUnit>("SetupCount", Net::WebApi::EJsonCommandUnitType::Int),
            std::make_shared<Net::WebApi::JsonCommandUnit>("LastModDate", Net::WebApi::EJsonCommandUnitType::String),
            std::make_shared<Net::WebApi::JsonCommandUnit>("State", Net::WebApi::EJsonCommandUnitType::String),
            std::make_shared<Net::WebApi::JsonCommandUnit>("ServiceCounter", Net::WebApi::EJsonCommandUnitType::Int)
          })
        );
    }

    std::shared_ptr<Net::WebApi::JsonCommandStatus> execute(std::shared_ptr<Net::WebApi::IJsonCommandInfo> launchedCommandInfo) override
    {
        uid = launchedCommandInfo->uid;
        Usb::UsbDeviceCommandSet* commandSet = m_usbDeviceManager->getCommandSet();
        std::vector<uint8_t> commandBytes;
        Usb::ByteCommandQueue* commandQueue = m_usbDeviceManager->getCommandQueue();
        std::shared_ptr<Usb::LaunchedSimpleCommandInfo> commandInfo = std::make_shared<Usb::LaunchedSimpleCommandInfo>("ReadNumber", commandQueue->generateUid(), std::vector<uint8_t>{});
        Usb::DeviceCommand::EStatus answerStatus = commandSet->createCommandBytes(commandInfo, commandBytes);
        if (answerStatus != Usb::DeviceCommand::EStatus::OK)
        {
            return std::make_shared<Net::WebApi::ErrorJsonCommandStatus>(Usb::DeviceCommandStatusConverter::toText(answerStatus));
        }
        std::shared_ptr<Usb::ByteCommand> getNumberCommand = std::make_shared<Usb::ByteCommand>(commandInfo->name, commandInfo->uid, std::move(commandBytes));
        connect(getNumberCommand.get(), &Usb::ByteCommand::answerIsReady, this, &GetDeviceInfoJsonCommand::handleGetNumberIsReady);
        commandQueue->enqueue(getNumberCommand);
        return std::make_shared<Net::WebApi::OkJsonCommandStatus>();
    }

private slots:
    void handleGetNumberIsReady(std::shared_ptr<Usb::ByteCommand> /*command*/, std::vector<uint8_t> answer, int32_t status)
    {
        Usb::DeviceCommand::EStatus answerStatus = (Usb::DeviceCommand::EStatus)status;
        if (answerStatus != Usb::DeviceCommand::EStatus::OK)
        {
            emit answerIsReady(this, QJsonDocument(), DeviceWebApi::JsonCommandStatusCreator::create(answerStatus, answer));
            return;
        }

        m_deviceNumber = Common::ByteArrayProvider::getDWordFromArray(&answer[0], answer.size(), 4);

        Usb::UsbDeviceCommandSet* commandSet = m_usbDeviceManager->getCommandSet();
        std::vector<uint8_t> commandBytes;
        Usb::ByteCommandQueue* commandQueue = m_usbDeviceManager->getCommandQueue();
        std::shared_ptr<Usb::LaunchedSimpleCommandInfo> commandInfo = std::make_shared<Usb::LaunchedSimpleCommandInfo>("ReadGuiVersion", commandQueue->generateUid(), std::vector<uint8_t>{});
        answerStatus = commandSet->createCommandBytes(commandInfo, commandBytes);
        if (answerStatus != Usb::DeviceCommand::EStatus::OK)
        {
            emit answerIsReady(this, QJsonDocument(), DeviceWebApi::JsonCommandStatusCreator::create(answerStatus, answer));
            return;
        }
        std::shared_ptr<Usb::ByteCommand> readGuiVersionCommand = std::make_shared<Usb::ByteCommand>(commandInfo->name, commandInfo->uid, std::move(commandBytes));
        connect(readGuiVersionCommand.get(), &Usb::ByteCommand::answerIsReady, this, &GetDeviceInfoJsonCommand::handleGetGuiVersionIsReady);
        commandQueue->enqueue(readGuiVersionCommand);
    }

    void handleGetGuiVersionIsReady(std::shared_ptr<Usb::ByteCommand> /*command*/, std::vector<uint8_t> answer, int32_t status)
    {
        Usb::DeviceCommand::EStatus answerStatus = (Usb::DeviceCommand::EStatus)status;
        if (answerStatus != Usb::DeviceCommand::EStatus::OK)
        {
            emit answerIsReady(this, QJsonDocument(), DeviceWebApi::JsonCommandStatusCreator::create(answerStatus, answer));
            return;
        }

        m_deviceGuiVersion = parseGuiVersion(answer);

        Usb::UsbDeviceCommandSet* commandSet = m_usbDeviceManager->getCommandSet();
        std::vector<uint8_t> commandBytes;
        Usb::ByteCommandQueue* commandQueue = m_usbDeviceManager->getCommandQueue();
        std::shared_ptr<Usb::LaunchedSimpleCommandInfo> commandInfo = std::make_shared<Usb::LaunchedSimpleCommandInfo>("ReadRevision", commandQueue->generateUid(), std::vector<uint8_t>{});
        answerStatus = commandSet->createCommandBytes(commandInfo, commandBytes);
        if (answerStatus != Usb::DeviceCommand::EStatus::OK)
        {
            emit answerIsReady(this, QJsonDocument(), DeviceWebApi::JsonCommandStatusCreator::create(answerStatus, answer));
            return;
        }
        std::shared_ptr<Usb::ByteCommand> readRevisionCommand = std::make_shared<Usb::ByteCommand>(commandInfo->name, commandInfo->uid, std::move(commandBytes));
        connect(readRevisionCommand.get(), &Usb::ByteCommand::answerIsReady, this, &GetDeviceInfoJsonCommand::handleGetRevisionIsReady);
        commandQueue->enqueue(readRevisionCommand);
    }

    void handleGetRevisionIsReady(std::shared_ptr<Usb::ByteCommand> /*command*/, std::vector<uint8_t> answer, int32_t status)
    {
        Usb::DeviceCommand::EStatus answerStatus = (Usb::DeviceCommand::EStatus)status;
        if (answerStatus != Usb::DeviceCommand::EStatus::OK)
        {
            emit answerIsReady(this, QJsonDocument(), DeviceWebApi::JsonCommandStatusCreator::create(answerStatus, answer));
            return;
        }

        m_revision = parseRevision(answer);

        Usb::UsbDeviceCommandSet* commandSet = m_usbDeviceManager->getCommandSet();
        std::vector<uint8_t> commandBytes;
        Usb::ByteCommandQueue* commandQueue = m_usbDeviceManager->getCommandQueue();
        std::shared_ptr<Usb::LaunchedSimpleCommandInfo> commandInfo = std::make_shared<Usb::LaunchedSimpleCommandInfo>("ReadIdInv", commandQueue->generateUid(), std::vector<uint8_t>{});
        answerStatus = commandSet->createCommandBytes(commandInfo, commandBytes);
        if (answerStatus != Usb::DeviceCommand::EStatus::OK)
        {
            emit answerIsReady(this, QJsonDocument(), DeviceWebApi::JsonCommandStatusCreator::create(answerStatus, answer));
            return;
        }
        std::shared_ptr<Usb::ByteCommand> readIdInvCommand = std::make_shared<Usb::ByteCommand>(commandInfo->name, commandInfo->uid, std::move(commandBytes));
        connect(readIdInvCommand.get(), &Usb::ByteCommand::answerIsReady, this, &GetDeviceInfoJsonCommand::handleGetIdInvIsReady);
        commandQueue->enqueue(readIdInvCommand);
    }

    void handleGetIdInvIsReady(std::shared_ptr<Usb::ByteCommand> /*command*/, std::vector<uint8_t> answer, int32_t status)
    {
        Usb::DeviceCommand::EStatus answerStatus = (Usb::DeviceCommand::EStatus)status;
        if (answerStatus != Usb::DeviceCommand::EStatus::OK)
        {
            emit answerIsReady(this, QJsonDocument(), DeviceWebApi::JsonCommandStatusCreator::create(answerStatus, answer));
            return;
        }

        m_setupCounter = parseSetupCounter(answer);

        size_t readLength = 7;
        std::vector<uint8_t> commandBytes = { 0x7e, 0x06, 0x00, 0x03, /* address */ 0x00, 0x00, /* memory type */ 0x00, 0x00, /* read data length*/ 0x00, 0x00, 0xff, 0xff, 0xbd };
        Common::ByteArrayProvider::setWordToArray(m_startAddressLastModDate, &commandBytes[0], 4);
        Common::ByteArrayProvider::setWordToArray(0x0500, &commandBytes[0], 6);
        Common::ByteArrayProvider::setWordToArray(static_cast<uint16_t>(readLength), &commandBytes[0], 8);

        Usb::ByteCommandQueue* commandQueue = m_usbDeviceManager->getCommandQueue();
        std::shared_ptr<Usb::ByteCommand> readEepromCommand = std::make_shared<Usb::ByteCommand>("ReadEeprom", commandQueue->generateUid(), std::move(commandBytes));
        connect(readEepromCommand.get(), &Usb::ByteCommand::answerIsReady, this, &GetDeviceInfoJsonCommand::handleReadLastModDateIsReady);
        commandQueue->enqueue(readEepromCommand);
    }

    void handleReadLastModDateIsReady(std::shared_ptr<Usb::ByteCommand> /*command*/, std::vector<uint8_t> answer, int32_t status)
    {
        Usb::DeviceCommand::EStatus answerStatus = (Usb::DeviceCommand::EStatus)status;
        if (answerStatus != Usb::DeviceCommand::EStatus::OK)
        {
            emit answerIsReady(this, QJsonDocument(), DeviceWebApi::JsonCommandStatusCreator::create(answerStatus, answer));
            return;
        }
        if (answer.size() == 8)
        {
            emit answerIsReady(this, QJsonDocument(), DeviceWebApi::JsonCommandStatusCreator::create(Usb::DeviceCommand::EStatus::WRONG_FRAME_FORMAT, answer));
            return;
        }
        if (isValidLastModDate(answer))
        {
            int year = answer[4] + 2000;
            int month = answer[5];
            int day = answer[6];
            int hours = answer[7];
            int minutes = answer[8];
            int seconds = answer[9];
            m_lastModDate = "";
            if (day < 10)
            {
                m_lastModDate += "0";
            }
            m_lastModDate += std::to_string(day) + ".";
            if (month < 10)
            {
                m_lastModDate += "0";
            }
            m_lastModDate += std::to_string(month) + "." + std::to_string(year) + " ";
            if (hours < 10)
            {
                m_lastModDate += "0";
            }
            m_lastModDate += std::to_string(hours) + ":";
            if (minutes < 10)
            {
                m_lastModDate += "0";
            }
            m_lastModDate += std::to_string(minutes) + ":";
            if (seconds < 10)
            {
                m_lastModDate += "0";
            }
            m_lastModDate += std::to_string(seconds);
        }

        std::vector<uint8_t> commandBytes = { 0x7e, 0x00, 0x00, 0x0e, 0xff, 0xff, 0xbd };
        Usb::ByteCommandQueue* commandQueue = m_usbDeviceManager->getCommandQueue();
        std::shared_ptr<Usb::ByteCommand> readDeviceStateCommand = std::make_shared<Usb::ByteCommand>("ReadDeviceState", commandQueue->generateUid(), std::move(commandBytes));
        connect(readDeviceStateCommand.get(), &Usb::ByteCommand::answerIsReady, this, &GetDeviceInfoJsonCommand::handleReadDeviceStateIsReady);
        commandQueue->enqueue(readDeviceStateCommand);
    }

    void handleReadDeviceStateIsReady(std::shared_ptr<Usb::ByteCommand> /*command*/, std::vector<uint8_t> answer, int32_t status)
    {
        Usb::DeviceCommand::EStatus answerStatus = (Usb::DeviceCommand::EStatus)status;
        if (answerStatus != Usb::DeviceCommand::EStatus::OK)
        {
            emit answerIsReady(this, QJsonDocument(), DeviceWebApi::JsonCommandStatusCreator::create(answerStatus, answer));
            return;
        }

        m_deviceState = answer[4];
        if (m_deviceState == 1) // waiting
        {
            std::vector<uint8_t> commandBytes = { 0x7e, 0x01, 0x00, 0x09, 0x2a, 0xff, 0xff, 0xbd };
            Usb::ByteCommandQueue* commandQueue = m_usbDeviceManager->getCommandQueue();
            std::shared_ptr<Usb::ByteCommand> readDeviceStateDetailsCommand = std::make_shared<Usb::ByteCommand>("ReadDeviceStateDetails", commandQueue->generateUid(), std::move(commandBytes));
            connect(readDeviceStateDetailsCommand.get(), &Usb::ByteCommand::answerIsReady, this, &GetDeviceInfoJsonCommand::handleReadDeviceStateDetailsIsReady);
            commandQueue->enqueue(readDeviceStateDetailsCommand);
        }
        else
        {
            createDeviceStateText(m_deviceState, false, false, false);
        }
    }

    void handleReadDeviceStateDetailsIsReady(std::shared_ptr<Usb::ByteCommand> /*command*/, std::vector<uint8_t> answer, int32_t status)
    {
        Usb::DeviceCommand::EStatus answerStatus = (Usb::DeviceCommand::EStatus)status;
        if (answerStatus != Usb::DeviceCommand::EStatus::OK)
        {
            emit answerIsReady(this, QJsonDocument(), DeviceWebApi::JsonCommandStatusCreator::create(answerStatus, answer));
            return;
        }
        uint8_t deviceStateDetails = answer[5];
        bool isPrepared = false;
        if (deviceStateDetails == 1)
        {
            isPrepared = true;
        }

        m_deviceStateText = getDeviceStateText(m_deviceState, isPrepared, false, false);

        createDeviceStateText(m_deviceState, isPrepared, false, false);
    }

    void createDeviceStateText(uint8_t deviceState, bool isPrepared, bool isFullMemory, bool stoppedByVoltage)
    {
        m_deviceStateText = getDeviceStateText(deviceState, isPrepared, isFullMemory, stoppedByVoltage);

        QJsonObject jsonRootObject;
        if ((m_deviceInfo.typeInfo.type != 0) || (m_deviceInfo.hardwareVersion != 0) || (m_deviceInfo.softwareVersion != 0))
        {
            jsonRootObject.insert("Name", QString::fromStdString(m_deviceInfo.typeInfo.name));
            std::string deviceSeries = DevicesInfo::DeviceSeriesParser::pack(m_deviceInfo.typeInfo.series);
            jsonRootObject.insert("Type", static_cast<int>(m_deviceInfo.typeInfo.type));
            jsonRootObject.insert("HardVer", Usb::DeviceBaseInfoAggregator::toVersionText(m_deviceInfo.hardwareVersion));
            jsonRootObject.insert("SoftVer", Usb::DeviceBaseInfoAggregator::toVersionText(m_deviceInfo.softwareVersion));
            jsonRootObject.insert("VersionExtension", QString::fromStdString(m_deviceInfo.deviceVersionExtension));
            jsonRootObject.insert("Number", static_cast<int>(m_deviceNumber));
            jsonRootObject.insert("GuiVersion", Usb::DeviceBaseInfoAggregator::toVersionText(m_deviceGuiVersion));
            jsonRootObject.insert("Revision", Usb::DeviceBaseInfoAggregator::toVersionText(m_revision));
            jsonRootObject.insert("SetupCount", static_cast<int>(m_setupCounter));
            jsonRootObject.insert("LastModDate", QString::fromStdString(m_lastModDate));
            jsonRootObject.insert("State", QString::fromStdString(m_deviceStateText));
            jsonRootObject.insert("ServiceCounter", static_cast<int>(0));
        }
        QJsonDocument document(jsonRootObject);
        emit answerIsReady(this, document, std::make_shared<Net::WebApi::OkJsonCommandStatus>());
    }

private:
    uint8_t getLastModDateCrc(const std::vector<uint8_t>& data) const
    {
      uint8_t crc = 0x33;
      for (int i = 4; i + 1 < 11; i++)
      {
        crc += data[i];
      }
      return crc;
    }

    bool isValidLastModDate(const std::vector<uint8_t>& data) const
    {
        uint8_t crc = getLastModDateCrc(data);
        return data[10] == crc;
    }

    uint32_t parseGuiVersion(const std::vector<uint8_t>& data)
    {
        size_t offset = 5;
        uint32_t versionValue = Common::ByteArrayProvider::getDWordFromArray(&data[0], data.size() - 3, offset);
        return Common::ByteArrayProvider::swapDWord(versionValue);
    }

    uint16_t parseRevision(const std::vector<uint8_t>& data)
    {
        size_t offset = 5;
        uint16_t revisionValue = Common::ByteArrayProvider::getWordFromArray(data, offset);
        return Common::ByteArrayProvider::swapWord(revisionValue);
    }

    uint16_t parseSetupCounter(const std::vector<uint8_t>& data)
    {
        size_t offset = 5;
        if (data.size() < offset + 6)
        {
            return 0;
        }
        return Common::ByteArrayProvider::toWord(data[offset + 4], data[offset + 5]);
    }

    std::string getDeviceStateText(uint8_t deviceState, bool isPrepared, bool isFullMemory, bool stoppedByVoltage)
    {
        std::string deviceStateText = "";
        switch (deviceState)
        {
        case 1:
            deviceStateText += "Ожидание";
            break;
        case 2:
            deviceStateText += "Запись";
            break;
        }

        if (isPrepared)
        {
            deviceStateText += ", подготовлен к записи";
        }
        if (isFullMemory)
        {
            deviceStateText += ", память заполнена";
        }
        if (stoppedByVoltage)
        {
            deviceStateText += ", остановлен по питанию";
        }

        return deviceStateText;
    }
};

} // namespace Incart::DeviceWebApi