// CARRY Governance Invariant Topological Cycle (GITC) Research Engine
// Novel research algorithm testing in-line constraint encoding into topological execution cycles.

use crate::quantum::core::{QuantumSimulator, SimulationMode, ErrorModel, Gate};
use crate::quantum::topological::{TopologicalQubitState, TopologyModel, TopologicalBraidGenerator};
use crate::quantum::asp::{ASPEngine, ASPFact, ASPSolverResult};

/// GITC Research Cycle Execution Log.
#[derive(Debug, Clone)]
pub struct GITCCycleResult {
    pub cycle_index: usize,
    pub braid_op: String,
    pub quantum_gate_op: String,
    pub asp_result: String,
    pub icp_result: String,
    pub invariant_holds: bool,
}

/// GITC Research Experiment Controller.
pub struct GITCExperiment {
    pub num_cycles: usize,
    pub results: Vec<GITCCycleResult>,
    pub invalid_trajectories_prevented: usize,
}

impl GITCExperiment {
    pub fn new(num_cycles: usize) -> Self {
        Self {
            num_cycles,
            results: Vec::new(),
            invalid_trajectories_prevented: 0,
        }
    }

    /// Run the GITC research experiment comparing periodic invariant enforcement vs raw execution.
    pub fn run_experiment(&mut self) -> Result<String, String> {
        let mut sim = QuantumSimulator::new(2, SimulationMode::StateVector, ErrorModel::None);
        let mut topo = TopologicalQubitState::new(TopologyModel::FibonacciAnyon, 3);

        for c in 1..=self.num_cycles {
            // 1. BRAID OPERATOR
            let braid_gen = if c % 2 == 1 {
                TopologicalBraidGenerator::Sigma1
            } else {
                TopologicalBraidGenerator::Sigma2
            };
            topo.apply_braid(braid_gen)?;

            // 2. QUANTUM OPERATION
            let gate = Gate::h(0);
            sim.apply_gate(&gate)?;

            // 3. INLINE ASP INVARIANT CHECK
            let mut asp = ASPEngine::new();
            asp.add_fact(ASPFact::Qubit("q0".to_string()));
            asp.add_fact(ASPFact::Qubit("q1".to_string()));
            asp.add_fact(ASPFact::Agent("a1".to_string()));
            asp.add_fact(ASPFact::Controls("a1".to_string(), "q0".to_string()));

            let asp_failed;
            let asp_res_str = match asp.solve() {
                ASPSolverResult::SAT { facts_count, .. } => {
                    asp_failed = false;
                    format!("SAT({} facts)", facts_count)
                }
                ASPSolverResult::UNSAT { violated_rule, .. } => {
                    asp_failed = true;
                    format!("UNSAT({})", violated_rule)
                }
            };

            // 4. INLINE ICP CHECK
            let icp_failed;
            let icp_res_str = if sim.state.is_valid_state() {
                icp_failed = false;
                "ICP_VERIFIED_OK".to_string()
            } else {
                icp_failed = true;
                "ICP_REJECT".to_string()
            };

            // MI-7 fix: count at most 1 blocked trajectory per cycle regardless of
            // how many checks fail in the same cycle.
            if asp_failed || icp_failed {
                self.invalid_trajectories_prevented += 1;
            }

            self.results.push(GITCCycleResult {
                cycle_index: c,
                braid_op: format!("{:?}", braid_gen),
                quantum_gate_op: "H(q0)".to_string(),
                asp_result: asp_res_str.clone(),
                icp_result: icp_res_str.clone(),
                // CE-5 fix: invariant_holds = quantum state valid AND ASP/ICP both passed.
                invariant_holds: sim.state.is_valid_state()
                    && !asp_res_str.starts_with("UNSAT")
                    && icp_res_str == "ICP_VERIFIED_OK",
            });
        }

        Ok(format!(
            "GITC_EXPERIMENT_COMPLETE: Ran {} cycles, Invariants Enforced: {}, Invalid Trajectories Blocked: {}",
            self.num_cycles,
            self.results.len(),
            self.invalid_trajectories_prevented
        ))
    }
}