#include "PrinterStateManager.h"
#include <QDebug>
#include "LogInfo.h"

PrinterStateManager* PrinterStateManager::s_instance = nullptr;

PrinterStateManager* PrinterStateManager::instance()
{
    if (!s_instance) {
        s_instance = new PrinterStateManager();
    }
    return s_instance;
}

PrinterStateManager::PrinterStateManager()
{
    initTransitions();
    m_currentState = PrinterState::IDLE;
    initTimer();
}

PrinterStateManager::~PrinterStateManager()
{
    if (m_updateUITimer) {
        m_updateUITimer->stop();
        m_updateUITimer->deleteLater();
        m_updateUITimer = NULL;
    }
    if (m_sysPara) {
        m_sysPara = NULL;
    }
}

void PrinterStateManager::initTimer()
{
    if (m_updateUITimer == NULL) {
        m_updateUITimer = new QTimer();
        connect(m_updateUITimer, &QTimer::timeout, this,
                &PrinterStateManager::slt_timeout);
        m_updateUITimer->setInterval(50);
        m_updateUITimer->setSingleShot(true);
    }
}

QString PrinterStateManager::stateName() const
{
    switch (m_currentState) {
    case PrinterState::IDLE: return "空闲";
    case PrinterState::SELF_CHECK: return "自检完成";
    case PrinterState::READY: return "就绪";
    case PrinterState::PRINTING: return "打印中";
    case PrinterState::STOPPING: return "停止中";
    case PrinterState::ERROR: return "故障";
    case PrinterState::POWER_OFF: return "关机中";
    default: return "未知";
    }
}

// ============ 初始化状态（开机时调用一次） ============
void PrinterStateManager::initFromSysPara()
{
    setState(PrinterState::IDLE, "Init from sysPara");
}

// ============ 状态转移表 ============
void PrinterStateManager::initTransitions()
{
    m_transitions = {
        // 开机流程
        {PrinterState::IDLE, PrinterEvent::PowerOn,
         PrinterState::SELF_CHECK, "IDLE → SELF_CHECK", nullptr},
        {PrinterState::SELF_CHECK, PrinterEvent::SelfCheckDone,
         PrinterState::READY, "SELF_CHECK → READY",
         [this]() -> bool { return guardReclaimTankOpen(); }},
        {PrinterState::SELF_CHECK, PrinterEvent::SelfCheckFailed,
         PrinterState::ERROR, "SELF_CHECK → ERROR", nullptr},
        // 注意，逆清洗和关回收槽时，需要把状态重新切换回自检
        {PrinterState::READY, PrinterEvent::ReSelfCheck,
         PrinterState::SELF_CHECK, "READY → SELF_CHECK", nullptr},

        // 打印流程
        {PrinterState::READY, PrinterEvent::StartPrint,
         PrinterState::PRINTING, "READY → PRINTING",
        [this]() -> bool { return guardCanStartPrint(); }},

        {PrinterState::PRINTING, PrinterEvent::StopPrint,
         PrinterState::STOPPING, "PRINTING → STOPPING", nullptr},
        {PrinterState::STOPPING, PrinterEvent::StopComplete,
         PrinterState::READY, "STOPPING → READY", nullptr},

        // 错误处理
        {PrinterState::READY, PrinterEvent::ErrorOccurred,
         PrinterState::ERROR, "READY → ERROR", nullptr},
        {PrinterState::PRINTING, PrinterEvent::ErrorOccurred,
         PrinterState::ERROR, "PRINTING → ERROR", nullptr},
        {PrinterState::STOPPING, PrinterEvent::ErrorOccurred,
         PrinterState::ERROR, "STOPPING → ERROR", nullptr},
        {PrinterState::ERROR, PrinterEvent::ErrorCleared,
         PrinterState::READY, "ERROR → READY", nullptr},

        // 关机
        {PrinterState::READY, PrinterEvent::PowerOff,
         PrinterState::POWER_OFF, "READY → POWER_OFF", nullptr},
        {PrinterState::PRINTING, PrinterEvent::PowerOff,
         PrinterState::POWER_OFF, "PRINTING → POWER_OFF", nullptr},
        {PrinterState::STOPPING, PrinterEvent::PowerOff,
         PrinterState::POWER_OFF, "STOPPING → POWER_OFF", nullptr},
        {PrinterState::ERROR, PrinterEvent::PowerOff,
         PrinterState::POWER_OFF, "ERROR → POWER_OFF", nullptr},
        {PrinterState::POWER_OFF, PrinterEvent::PowerOffDone,
         PrinterState::IDLE, "POWER_OFF → IDLE", nullptr},
    };
}

// ============ 查找转移 ============
PrinterStateManager::Transition* PrinterStateManager::findTransition(PrinterEvent event)
{
    for (Transition& trans : m_transitions) {
        if (trans.fromState == m_currentState && trans.event == event) {
            return &trans;
        }
    }
    return nullptr;
}

// ============ 请求切换状态（外部唯一接口） ============
void PrinterStateManager::requestTransition(PrinterEvent event)
{
    LogInfo::setRunStatusText(QString("Transition %1:%2")
                              .arg(stateName())
                              .arg(m_sysPara->status.reclaimTankstatus));

    Transition* trans = findTransition(event);
    if (!trans) {
        qDebug() << "Invalid transition, ignored";
        return;
    }

    // 检查守卫条件
    if (trans->guard) {
        bool result = trans->guard();
        if (!result) {
            qDebug() << "Guard condition failed for:" << trans->description;
            return;
        }
    }

    // 执行状态切换（内部管理）
    setState(trans->toState, trans->description);
}

static int f = 0;
void PrinterStateManager::checkReadyState()
{
    // 自检完成后，随时检查能否进入READY状态
    if (m_currentState == PrinterState::SELF_CHECK) {
        if (m_sysPara) {
            if (f ++ > 50) {
                f = 0;
                LogInfo::setRunStatusText
                        (QString("%3:%1---airPushing:%2")
                         .arg(m_sysPara->status.reclaimTankstatus)
                         .arg(m_sysPara->status.airPushing)
                         .arg(stateName()));
            }

            if (m_sysPara->status.airPushing) {
                emit sig_enableOpenTank(false);
                emit sig_enableCloseTank(false);
                return;
            }

            switch (m_sysPara->status.reclaimTankstatus) {
            case 5:
                setState(PrinterState::READY, "READY");
                break;
            default:
                // 回收槽状态变化后就更新一次
                if (lastState != m_sysPara->status.reclaimTankstatus
                        && m_sysPara->status.reclaimTankstatus != 0) {
                    if (m_updateUITimer && !m_updateUITimer->isActive()) {
                        m_updateUITimer->start();
                    }
                    lastState = m_sysPara->status.reclaimTankstatus;
                    emit sig_updateReclaimStatus();
                }
                break;
            }
        }
    }
}

// ============ 内部状态切换 ============
void PrinterStateManager::setState(PrinterState newState, const QString& reason)
{
    if (m_currentState == newState) {
        return;
    }

    m_previousState = m_currentState;
    m_currentState = newState;

    qDebug() << "State changed:" << stateName() << "Reason:" << reason;

    if (m_updateUITimer && !m_updateUITimer->isActive())
        m_updateUITimer->start();

    // 发送信号通知外部
    emit sig_stateChanged(newState, m_previousState, reason);
    emit sig_updateReclaimStatus();
}

// ============ 辅助函数 ============
QString PrinterStateManager::stateNameFromEnum(PrinterState state) const
{
    switch (state) {
    case PrinterState::IDLE: return "IDLE";
    case PrinterState::SELF_CHECK: return "SELF_CHECK";
    case PrinterState::READY: return "READY";
    case PrinterState::PRINTING: return "PRINTING";
    case PrinterState::STOPPING: return "STOPPING";
    case PrinterState::ERROR: return "ERROR";
    case PrinterState::POWER_OFF: return "POWER_OFF";
    default: return "UNKNOWN";
    }
}

// ============ 守卫条件函数 ============

static char times = 0;
bool PrinterStateManager::guardReclaimTankOpen()
{
    if (!m_sysPara) return false;
    if (times ++ > 50) {
        times = 0;
        LogInfo::setRunStatusText(QString("guardReclaimTankOpen:%1").arg(m_sysPara->status.reclainTankReachEnd));
        LogInfo::setRunStatusText(QString("reclaimTankstatus:%1").arg(m_sysPara->status.reclaimTankstatus));
    }

    return m_sysPara->status.reclainTankReachEnd || (m_sysPara->status.reclaimTankstatus == 5);
}

bool PrinterStateManager::guardInkSwintOpen()
{
    if (!m_sysPara) return false;
    LogInfo::setRunStatusText("guardInkSwintOpen:" + !(m_sysPara->status.statWarn & WARN_STATUS_INK_SWINT));
    return !(m_sysPara->status.statWarn & WARN_STATUS_INK_SWINT);
}

bool PrinterStateManager::guardNoError()
{
    if (!m_sysPara) return false;
    LogInfo::setRunStatusText("guardNoError:" + (m_sysPara->status.statWarn == 0));
    return m_sysPara->status.statWarn == 0;
}

bool PrinterStateManager::guardNoInkWarn()
{
    if (!m_sysPara) return false;
    return !(m_sysPara->status.statWarn & WARN_STATUS_INK_WARN);
}

bool PrinterStateManager::guardNoSolventWarn()
{
    if (!m_sysPara) return false;
    return !(m_sysPara->status.statWarn & WARN_STATUS_SOLV_WARN);
}

bool PrinterStateManager::guardSelfCheckDone()
{
    if (!m_sysPara) return false;
    LogInfo::setRunStatusText("guardSelfCheckDone:" + m_sysPara->status.selfCheckDone);
    return m_sysPara->status.selfCheckDone == true;
}

bool PrinterStateManager::guardCanStartPrint()
{
    if (!m_sysPara) return false;

    // 自检完成，开回收槽，开墨线，无异常报错
    return guardReclaimTankOpen() && guardInkSwintOpen() &&
            guardNoError() && guardSelfCheckDone();
}

void PrinterStateManager::slt_timeout()
{
    if (m_sysPara) {
        LogInfo::setRunStatusText(QString("slt_timeout ENTER:%1--state:%2--airPushing:%3")
                                  .arg(stateName())
                                  .arg(m_sysPara->status.reclaimTankstatus)
                                  .arg(m_sysPara->status.airPushing));

        switch (m_sysPara->status.reclaimTankstatus) {
        case 1: // 开
            emit sig_enableOpenTank(false);
            emit sig_enableCloseTank(true);
            break;
        case 2: // 关
            emit sig_enableOpenTank(true);
            emit sig_enableCloseTank(false);
            break;
        case 3:
        case 4:
            break;
        case 5: // 开完成
//            emit sig_enableStartPrint(true);
//            emit sig_enableStopPrint(true);
            emit sig_enableOpenTank(false);
            emit sig_enableCloseTank(true);
            break;
        case 6: // 6关完成
            emit sig_enableOpenTank(true);
            emit sig_enableCloseTank(false);
            break;
        case 0x10: // 故障
            emit sig_enableStartPrint(false);
            emit sig_enableStopPrint(false);
            emit sig_enableOpenTank(false);
            emit sig_enableCloseTank(true);
            break;
        case 0x11: // 卡住，关闭
        default:
            break;
        }
    }

    // STATE
    switch (m_currentState) {
    case PrinterState::SELF_CHECK:
        emit sig_enableStartPrint(false);
        emit sig_enableStopPrint(false);
        break;
    // 需要确认开完成时，状态是否一定是READY，然后避免重复操作 TODO
    case PrinterState::READY:
        emit sig_enableStartPrint(true);
        emit sig_enableStopPrint(true);
        break;
    default:
        break;
    }

    // 避免发出太多信号
    if (m_updateUITimer) m_updateUITimer->stop();
}