#pragma once

#include "SetPelCommand.h"
#include "UsbDeviceManager.h"

namespace Incart::DeviceComplexCommands
{

class MicroMonSetPelCommand : public SetPelCommand
{
private:
    bool m_isReoOn;
    bool m_isPelOn;
    Usb::UsbDeviceManager* m_usbDeviceManager;

public:
    MicroMonSetPelCommand(uint32_t uid, bool isPelOn, Usb::UsbDeviceManager* deviceManager) : SetPelCommand(uid)
        , m_isPelOn(isPelOn)
        , m_usbDeviceManager(deviceManager)
    {
    }

public:
    std::shared_ptr<Usb::DeviceCommandStatus> execute() override
    {
        std::cout << __FUNCTION__ << " (1)" << std::endl;
        if (m_usbDeviceManager->getIsReoAndPelRead())
        {
            std::cout << __FUNCTION__ << " (2)" << std::endl;
            m_isReoOn = m_usbDeviceManager->getIsReoOn();
            writePel();
        }
        else
        {
            std::cout << __FUNCTION__ << " (3)" << std::endl;
            std::vector<uint8_t> commandBytes;
            Usb::ByteCommandQueue* commandQueue = m_usbDeviceManager->getCommandQueue();
            std::shared_ptr<Usb::LaunchedSimpleCommandInfo> commandInfo = std::make_shared<Usb::LaunchedSimpleCommandInfo>("ReadReoAndPel", commandQueue->generateUid(), std::vector<uint8_t>());
            m_usbDeviceManager->getCommandSet()->createCommandBytes(commandInfo, commandBytes);
            std::shared_ptr<Usb::ByteCommand> readReoPelCommand = std::make_shared<Usb::ByteCommand>(commandInfo->name, commandInfo->uid, commandBytes);
            connect(readReoPelCommand.get(), &Usb::ByteCommand::answerIsReady, this, &MicroMonSetPelCommand::handleReadReoPelAnswerIsReady);
            commandQueue->enqueue(readReoPelCommand);
        }
        return std::make_shared<Usb::DeviceCommandStatus>(Usb::DeviceCommand::EStatus::OK);
    }

private slots:
    void handleReadReoPelAnswerIsReady(std::shared_ptr<Usb::ByteCommand> /*command*/, std::vector<uint8_t> answer, int32_t status)
    {
        std::cout << __FUNCTION__ << " (4)" << std::endl;
        if (status != Usb::DeviceCommand::EStatus::OK)
        {
            std::cout << __FUNCTION__ << " (5)" << std::endl;
            emit answerIsReady(this, Usb::DeviceCommandStatusCreator::create(answer, status));
            return;
        }
        std::cout << __FUNCTION__ << " (6)" << std::endl;
        m_isReoOn = answer[5] == 1;
        m_usbDeviceManager->setIsReoOn(m_isReoOn);
        writePel();
    }

private:
    void writePel()
    {
        std::cout << __FUNCTION__ << " (7)" << std::endl;
        std::vector<uint8_t> commandBytes;
        std::vector<uint8_t> commandData(3);
        commandData[0] = 0x27;
        commandData[1] = m_isReoOn ? 0x01: 0x00;
        commandData[2] = m_isPelOn ? 0x01: 0x00;
        Usb::ByteCommandQueue* commandQueue = m_usbDeviceManager->getCommandQueue();
        std::shared_ptr<Usb::LaunchedSimpleCommandInfo> commandInfo = std::make_shared<Usb::LaunchedSimpleCommandInfo>("WriteReoAndPel", commandQueue->generateUid(), commandData);
        m_usbDeviceManager->getCommandSet()->createCommandBytes(commandInfo, commandBytes);
        std::shared_ptr<Usb::ByteCommand> writeReoPelCommand = std::make_shared<Usb::ByteCommand>(commandInfo->name, commandInfo->uid, commandBytes);
        connect(writeReoPelCommand.get(), &Usb::ByteCommand::answerIsReady, this, &MicroMonSetPelCommand::handleWriteReoPelAnswerIsReady);
        commandQueue->enqueue(writeReoPelCommand);
    }

    void handleWriteReoPelAnswerIsReady(std::shared_ptr<Usb::ByteCommand> /*command*/, std::vector<uint8_t> answer, int32_t status)
    {
        std::cout << __FUNCTION__ << " (8)" << std::endl;
        emit answerIsReady(this, Usb::DeviceCommandStatusCreator::create(answer, status));
    }
};


} // namespace Incart::DeviceComplexCommands