#include "offline_simulation_service.h"

#include <utility>

OfflineSimulationService::OfflineSimulationService(
    VirtualRegisterRepository &repository,
    VirtualRegisterRepository *initial_repository,
    QObject *parent)
    : QObject(parent),
      repository_(repository),
      initial_repository_(initial_repository)
{
    timer_.setInterval(kDefaultScanIntervalMs);
    timer_.setTimerType(Qt::PreciseTimer);
    connect(&timer_, &QTimer::timeout,
            this, &OfflineSimulationService::handleTimeout);
}

SimulationStartResult OfflineSimulationService::start(
    const std::vector<ControlLogic> &logics)
{
    if (state_ == SimulationState::Running)
    {
        return {false, SimulationStartError::AlreadyRunning, {}};
    }

    // 仿真期间使用启动时快照，编辑器后续修改不会改变正在扫描的逻辑
    std::vector<ControlLogic> snapshot = logics;
    const LogicScanResult validation = executor_.validate(snapshot);
    if (!validation.succeeded)
    {
        last_error_ = validation;
        return {false, SimulationStartError::InvalidLogic, validation};
    }

    // 重启会话时清空沿触发状态和运行值，再装载编辑态确认的初始值
    timer_.stop();
    executor_.resetRuntime();
    repository_.clear();
    if (initial_repository_ != nullptr)
    {
        repository_.copyFrom(*initial_repository_);
    }
    logic_snapshot_ = std::move(snapshot);
    successful_scan_count_ = 0;
    last_error_ = {true, LogicScanError::None, {}, {}, {}, {}};
    trace_snapshot_.clear();
    state_ = SimulationState::Running;
    timer_.start();
    emit stateChanged();
    return {true, SimulationStartError::None, {true, LogicScanError::None, {}, {}, {}, {}}};
}

void OfflineSimulationService::restoreInitialValues()
{
    repository_.clear();
    if (initial_repository_ != nullptr)
    {
        repository_.copyFrom(*initial_repository_);
    }
}

void OfflineSimulationService::stop()
{
    timer_.stop();
    executor_.resetRuntime();
    logic_snapshot_.clear();
    if (state_ == SimulationState::Stopped)
    {
        return;
    }
    // 运行结束后丢弃本轮输出，编辑态继续看到下一轮要使用的初始值
    restoreInitialValues();
    state_ = SimulationState::Stopped;
    last_error_ = {true, LogicScanError::None, {}, {}, {}, {}};
    emit stateChanged();
}

LogicScanResult OfflineSimulationService::executeOnce()
{
    if (state_ != SimulationState::Running)
    {
        return {false,
                LogicScanError::InvalidLogic,
                "离线仿真尚未运行",
                {},
                {},
                {}};
    }
    // 执行器负责一轮完整扫描；任何读写错误都会让服务进入 Faulted
    const LogicScanResult result = executor_.executeScan(
        logic_snapshot_, repository_, &trace_snapshot_);
    if (!result.succeeded)
    {
        enterFault(result);
        return result;
    }
    ++successful_scan_count_;
    emit scanCompleted();
    return result;
}

SimulationState OfflineSimulationService::state() const
{
    return state_;
}

int OfflineSimulationService::scanIntervalMs() const
{
    return timer_.interval();
}

std::uint64_t OfflineSimulationService::successfulScanCount() const
{
    return successful_scan_count_;
}

const LogicScanResult &OfflineSimulationService::lastError() const
{
    return last_error_;
}

const LogicTraceSnapshot &OfflineSimulationService::traceSnapshot() const
{
    return trace_snapshot_;
}

void OfflineSimulationService::handleTimeout()
{
    executeOnce();
}

void OfflineSimulationService::enterFault(const LogicScanResult &error)
{
    // 故障后停止定时器和运行时状态，保留错误及最后轨迹供 UI 诊断
    timer_.stop();
    executor_.resetRuntime();
    last_error_ = error;
    state_ = SimulationState::Faulted;
    emit stateChanged();
}