// CARRY Answer Set Programming (ASP) Constraint Engine
// Declarative constraint solver evaluating system rules over the quantum governance graph.

use std::collections::HashSet;

/// ASP Atom / Fact representations.
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum ASPFact {
    Qubit(String),
    Entangled(String, String),
    Agent(String),
    Controls(String, String), // controls(Agent, Qubit)
    Partner(String, String),   // partner(Agent1, Agent2)
    TopologyModel(String),
}

/// Result of ASP Solver Evaluation.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ASPSolverResult {
    SAT { facts_count: usize, rules_evaluated: usize },
    UNSAT { violated_rule: String, details: String },
}

/// ASP Constraint Solver Engine.
pub struct ASPEngine {
    pub facts: HashSet<ASPFact>,
    pub rules_evaluated: usize,
}

impl ASPEngine {
    pub fn new() -> Self {
        Self {
            facts: HashSet::new(),
            rules_evaluated: 0,
        }
    }

    pub fn add_fact(&mut self, fact: ASPFact) {
        self.facts.insert(fact);
    }

    /// Evaluate declarative ASP integrity constraints over the registered facts.
    pub fn solve(&mut self) -> ASPSolverResult {
        self.rules_evaluated = 0;

        // Rule 1: :- controls(A, Q), not qubit(Q).
        self.rules_evaluated += 1;
        for fact in &self.facts {
            if let ASPFact::Controls(agent, qubit) = fact {
                let qubit_exists = self.facts.contains(&ASPFact::Qubit(qubit.clone()));
                if !qubit_exists {
                    return ASPSolverResult::UNSAT {
                        violated_rule: ":- controls(A,Q), not qubit(Q).".to_string(),
                        details: format!("Agent {} controls unknown qubit {}", agent, qubit),
                    };
                }
            }
        }

        // Rule 2: :- entangled(Q1, Q2), Q1 = Q2.
        self.rules_evaluated += 1;
        for fact in &self.facts {
            if let ASPFact::Entangled(q1, q2) = fact {
                if q1 == q2 {
                    return ASPSolverResult::UNSAT {
                        violated_rule: ":- entangled(Q1,Q2), Q1 = Q2.".to_string(),
                        details: format!("Self-entanglement on qubit {}", q1),
                    };
                }
            }
        }

        // Rule 3: :- partner(A, B), A = B.
        self.rules_evaluated += 1;
        for fact in &self.facts {
            if let ASPFact::Partner(a, b) = fact {
                if a == b {
                    return ASPSolverResult::UNSAT {
                        violated_rule: ":- partner(A,B), A = B.".to_string(),
                        details: format!("Agent {} cannot be partner to itself", a),
                    };
                }
            }
        }

        // Rule 4: :- controls(A, Q), not agent(A).
        self.rules_evaluated += 1;
        for fact in &self.facts {
            if let ASPFact::Controls(agent, _) = fact {
                let agent_exists = self.facts.contains(&ASPFact::Agent(agent.clone()));
                if !agent_exists {
                    return ASPSolverResult::UNSAT {
                        violated_rule: ":- controls(A,Q), not agent(A).".to_string(),
                        details: format!("Unknown agent {} declared control over qubit", agent),
                    };
                }
            }
        }

        ASPSolverResult::SAT {
            facts_count: self.facts.len(),
            rules_evaluated: self.rules_evaluated,
        }
    }
}