#include "offline_simulation_service.h"

#include <utility>

OfflineSimulationService::OfflineSimulationService(
    VirtualRegisterRepository &repository,
    QObject *parent)
    : QObject(parent),
      repository_(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();
    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::stop()
{
    timer_.stop();
    executor_.resetRuntime();
    logic_snapshot_.clear();
    if (state_ == SimulationState::Stopped)
    {
        return;
    }
    state_ = SimulationState::Stopped;
    last_error_ = {true, LogicScanError::None, {}, {}, {}, {}};
    emit stateChanged();
}

LogicScanResult OfflineSimulationService::executeOnce()
{
    if (state_ != SimulationState::Running)
    {
        return {false,
                LogicScanError::InvalidLogic,
                "离线仿真尚未运行",
                {},
                {},
                {}};
    }
    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)
{
    timer_.stop();
    executor_.resetRuntime();
    last_error_ = error;
    state_ = SimulationState::Faulted;
    emit stateChanged();
}