#pragma once

#include "ComplexCommand.h"
#include "ByteCommandQueue.h"
#include "GetTimeCommand.h"
#include "ByteArrayProvider.h"
#include "UsbDeviceManager.h"
#include "DateTimeObject.h"

namespace Incart::DeviceComplexCommands
{

class MicroMonGetTimeCommand : public Usb::GetTimeCommand
{
private:
    Usb::UsbDeviceManager* const m_usbDeviceManager;

public:
    MicroMonGetTimeCommand(uint32_t uid, Usb::UsbDeviceManager* const usbDeviceManager) : Usb::GetTimeCommand(uid)
        , m_usbDeviceManager(usbDeviceManager)
    {
    }

public:
    std::shared_ptr<Usb::DeviceCommandStatus> execute() override
    {
        std::vector<uint8_t> commandBytes;
        Usb::ByteCommandQueue* commandQueue = m_usbDeviceManager->getCommandQueue();
        std::shared_ptr<Usb::LaunchedSimpleCommandInfo> commandInfo = std::make_shared<Usb::LaunchedSimpleCommandInfo>("ReadRtc", commandQueue->generateUid(), std::vector<uint8_t>());
        Usb::DeviceCommand::EStatus status = m_usbDeviceManager->getCommandSet()->createCommandBytes(commandInfo, commandBytes);
        if (status != Usb::DeviceCommand::EStatus::OK)
        {
            return Usb::DeviceCommandStatusCreator::create({}, status);
        }

        std::shared_ptr<Usb::ByteCommand> command = std::make_shared<Usb::ByteCommand>(commandInfo->name, commandInfo->uid, std::move(commandBytes));
        connect(command.get(), &Usb::ByteCommand::answerIsReady, this, &MicroMonGetTimeCommand::handleAnswerIsReady);
        commandQueue->enqueue(command);
        return std::make_shared<Usb::DeviceCommandStatus>(Usb::DeviceCommand::EStatus::OK);
    }

private slots:
    void handleAnswerIsReady(std::shared_ptr<Usb::ByteCommand> /*command*/, std::vector<uint8_t> answer, int32_t status)
    {
        std::shared_ptr<Usb::DeviceCommandStatus> statusInfo = nullptr;
        Common::DateTimeObject dateTime;
        if (status != Usb::DeviceCommand::EStatus::OK)
        {
           statusInfo = Usb::DeviceCommandStatusCreator::create(answer, status);
        }
        else if (answer.size() != 13)
        {
            statusInfo = std::make_shared<Usb::DeviceCommandStatusInfo<std::vector<uint8_t>>>(Usb::DeviceCommand::EStatus::WRONG_FRAME_FORMAT, answer);
        }
        else
        {
            std::vector<uint8_t> dateTimeBytes(answer.begin()+4, answer.begin()+10);
            dateTimeBytes[0] &= 0x7f; // seconds
            dateTimeBytes[1] &= 0x7f; // minutes
            dateTimeBytes[2] &= 0x3f; // hours
            dateTimeBytes[3] &= 0x3f; // days
            dateTimeBytes[4] &= 0x1f; // month
            for (size_t i = 0; i < dateTimeBytes.size(); ++i)
            {
                if (!Common::ByteArrayProvider::toDecFromHex(dateTimeBytes[i], dateTimeBytes[i]))
                {
                   statusInfo = std::make_shared<Usb::DeviceCommandStatusInfo<std::vector<uint8_t>>>(Usb::DeviceCommand::EStatus::WRONG_FRAME_FORMAT, answer);
                }
            }

            if (statusInfo == nullptr)
            {
                dateTime = Common::DateTimeObject{static_cast<uint32_t>(2000 + dateTimeBytes[5]), dateTimeBytes[4], dateTimeBytes[3], dateTimeBytes[2], dateTimeBytes[1], dateTimeBytes[0]};
                statusInfo = std::make_shared<Usb::DeviceCommandStatus>(Usb::DeviceCommand::EStatus::OK);
            }
        }
        emit answerIsReady(this, dateTime, statusInfo);
    }
};

} // namespace Incart::DeviceComplexCommands