//! [`CodexExecSession`] — adapter structuré Codex (ARCHITECTURE §17.2, spike **S2**).
//!
//! Pilote `codex exec --json` en mode non-interactif et traduit sa sortie structurée
//! vers le contrat universel [`ReplyEvent`]. Le **spike S2 est résolu** : le format
//! réel est vérifié (2026-06-09) et ISOLÉ dans [`parse_event`].
//!
//! # Séparation parsing / machinerie (CRUCIAL — §17.2)
//!
//! Comme pour Claude, la machinerie de process vit dans [`super::process`] et ignore
//! le format. **Seule [`parse_event`] (et la composition de la commande) porte le
//! format Codex** ; la machinerie reste inchangée.

use std::sync::{Arc, Mutex};

use async_trait::async_trait;
use serde_json::Value;

use domain::ports::{
    AgentSession, AgentSessionError, ReplyEvent, ReplyProgress, ReplyProgressKind,
    ReplyProgressSource, ReplyProgressStage, ReplyStream,
};
use domain::sandbox::{SandboxEnforcer, SandboxPlan};
use domain::SessionId;

use super::process::{run_turn, SpawnLine};

/// Résultat du parsing d'une ligne Codex : **zéro ou plusieurs** événements et/ou un
/// id de conversation Codex capté. Miroir de `claude::ParsedLine` (vecteur d'events
/// pour homogénéité du drain ; en pratique Codex rend 0 ou 1 événement par ligne).
#[derive(Debug, Default, PartialEq, Eq)]
pub struct ParsedLine {
    /// Événements universels à émettre (dans l'ordre), vide pour une ligne de contrôle.
    pub events: Vec<ReplyEvent>,
    /// Id de conversation Codex capté (= `thread_id`, pour la reprise).
    pub conversation_id: Option<String>,
}

/// **Parse une ligne de la sortie structurée de `codex exec --json`** vers le contrat
/// universel.
///
/// # Format RÉEL vérifié 2026-06-09 (spike S2 résolu)
///
/// Commande : `codex exec --json --skip-git-repo-check "<prompt>"` ;
/// reprise : `codex exec resume <thread_id> --json --skip-git-repo-check "<prompt>"`.
///
/// Le flux est du **JSONL**. Types réels :
///
/// - `{"type":"thread.started","thread_id":"<id>"}` ⇒ capte le `thread_id`
///   (= id de conversation pour la reprise), **aucun** événement émis.
/// - `{"type":"turn.started"}` ⇒ [`ReplyEvent::Heartbeat`] (vivacité non terminale).
/// - `{"type":"item.completed","item":{"id":"item_0","type":"agent_message","text":"…"}}`
///   ⇒ si `item.type=="agent_message"` ⇒ [`ReplyEvent::Final`] (`content` = `item.text`,
///   c'est la réponse) ; si `item.type=="error"` ⇒ [`ReplyEvent::Error`] avec message
///   extrait de `item.text`, `item.message`, `item.error.message`, `item.error`, puis
///   des champs top-level `stderr`/`message`/`error.message`/`error` ; sinon
///   (`reasoning`/`command`/autre) ⇒ [`ReplyEvent::ToolActivity`] (`label` = `item.type`).
/// - `{"type":"turn.completed","usage":{…}}` ⇒ [`ReplyEvent::Heartbeat`] (le `Final`
///   vient de l'`agent_message`, pas de `turn.completed`).
///
/// Ligne vide ⇒ ignorée ; type inconnu ⇒ ignoré sans erreur ; JSON illisible ⇒
/// [`AgentSessionError::Decode`] (jamais de JSON brut propagé).
///
/// # Errors
/// [`AgentSessionError::Decode`] si la ligne n'est pas un JSON valide.
pub fn parse_event(line: &str) -> Result<ParsedLine, AgentSessionError> {
    let trimmed = line.trim();
    if trimmed.is_empty() {
        return Ok(ParsedLine::default());
    }
    let value: Value = serde_json::from_str(trimmed)
        .map_err(|e| AgentSessionError::Decode(format!("ligne JSON illisible: {e}")))?;

    let mut conversation_id = None;
    let mut events = Vec::new();

    match value.get("type").and_then(Value::as_str) {
        Some("thread.started") => {
            // Handshake : on ne capte que le thread_id (= id de conversation).
            conversation_id = value
                .get("thread_id")
                .and_then(Value::as_str)
                .map(str::to_owned);
        }
        // Début/fin de tour côté moteur : pas de contenu, mais preuve de vivacité ⇒
        // battement de cœur non terminal (readiness/heartbeat lot 1). Le `Final` vient
        // toujours de l'`agent_message`, jamais de `turn.completed`.
        Some("turn.started") => {
            events.push(ReplyEvent::Progress {
                progress: provider_progress(
                    ReplyProgressKind::Turn,
                    ReplyProgressStage::Started,
                    "tour démarré",
                    "turn.started",
                ),
            });
            events.push(ReplyEvent::Heartbeat);
        }
        Some("turn.completed") => {
            events.push(ReplyEvent::Progress {
                progress: provider_progress(
                    ReplyProgressKind::Turn,
                    ReplyProgressStage::Completed,
                    "tour terminé côté provider",
                    "turn.completed",
                ),
            });
            events.push(ReplyEvent::Heartbeat);
        }
        Some("item.completed") => {
            if let Some(item) = value.get("item") {
                match item.get("type").and_then(Value::as_str) {
                    Some("agent_message") => {
                        let content = item
                            .get("text")
                            .and_then(Value::as_str)
                            .unwrap_or_default()
                            .to_owned();
                        events.push(ReplyEvent::Final { content });
                    }
                    Some("error") => {
                        events.push(ReplyEvent::Error {
                            message: codex_error_message(&value, item),
                        });
                    }
                    // reasoning / command / tout autre item ⇒ activité (label = type).
                    Some(kind) => {
                        events.push(ReplyEvent::Progress {
                            progress: provider_progress(
                                ReplyProgressKind::Tool,
                                ReplyProgressStage::Completed,
                                kind,
                                "item.completed",
                            )
                            .with_tool_name(kind.to_owned()),
                        });
                        events.push(ReplyEvent::ToolActivity {
                            label: kind.to_owned(),
                        });
                    }
                    None => {}
                }
            }
        }
        // type inconnu : ignoré (robustesse).
        _ => {}
    }

    Ok(ParsedLine {
        events,
        conversation_id,
    })
}

fn provider_progress(
    kind: ReplyProgressKind,
    stage: ReplyProgressStage,
    label: impl Into<String>,
    native_event: impl Into<String>,
) -> ReplyProgress {
    ReplyProgress::new(ReplyProgressSource::ProviderNative, kind, stage, label)
        .with_provider_event("codex", native_event)
}

const CODEX_ERROR_FALLBACK: &str = "Codex a renvoyé une erreur.";

fn non_blank_string(value: Option<&Value>) -> Option<String> {
    value
        .and_then(Value::as_str)
        .map(str::trim)
        .filter(|s| !s.is_empty())
        .map(str::to_owned)
}

fn error_value_message(value: Option<&Value>) -> Option<String> {
    let value = value?;
    non_blank_string(value.get("message")).or_else(|| non_blank_string(Some(value)))
}

fn codex_error_message(root: &Value, item: &Value) -> String {
    non_blank_string(item.get("text"))
        .or_else(|| non_blank_string(item.get("message")))
        .or_else(|| error_value_message(item.get("error")))
        .or_else(|| non_blank_string(root.get("stderr")))
        .or_else(|| non_blank_string(root.get("message")))
        .or_else(|| error_value_message(root.get("error")))
        .unwrap_or_else(|| CODEX_ERROR_FALLBACK.to_owned())
}

/// Adapter de session structurée Codex.
///
/// Incarnation « un `codex exec` par tour » (§17.2 (b)) : chaque `send` relance
/// `codex exec --json` avec le prompt et, dès qu'un `thread_id` a été capté, la
/// sous-commande de reprise. L'incarnation « process persistant » resterait derrière
/// le **même** port sans toucher au parsing.
pub struct CodexExecSession {
    /// Id de session IdeA.
    id: SessionId,
    /// Binaire à lancer (`codex` en prod, fake CLI en test).
    command: String,
    /// Répertoire de travail (run dir isolé §14.1).
    cwd: String,
    /// Codex CLI sandbox mode passed to `codex exec --sandbox`.
    sandbox_mode: String,
    /// Project/workspace roots that must be writable in Codex's CLI sandbox.
    writable_roots: Vec<String>,
    /// Structured policy projection of Codex workspace-write sandbox network access.
    network_access: Option<bool>,
    /// Profile-selected model forwarded as a Codex config override on every exec turn.
    model: Option<String>,
    /// Profile-selected reasoning effort forwarded as a Codex config override.
    model_reasoning_effort: Option<String>,
    /// Variables d'environnement préparées au lancement (ex. `CODEX_HOME` isolé).
    env: Vec<(String, String)>,
    /// Id de conversation **du moteur** Codex, capté au premier tour, `None` avant.
    conversation_id: Mutex<Option<String>>,
    /// Plan de sandbox OS **par lancement** (lot LP4-4), porté dans chaque
    /// [`SpawnLine`]. `None` ⇒ aucun sandboxing (drain async natif).
    sandbox: Option<SandboxPlan>,
    /// Enforcer OS **par instance** (lot LP4-4), passé à [`run_turn`]. `None` ⇒ pas
    /// de sandboxing même si un plan est présent (cohérent avec le chemin PTY).
    sandbox_enforcer: Option<Arc<dyn SandboxEnforcer>>,
}

impl CodexExecSession {
    /// Construit l'adapter. `command` est injecté (⇒ testable avec un fake CLI) ;
    /// `seed_conversation_id` amorce la reprise ou reste `None` (conversation neuve).
    /// `sandbox` / `sandbox_enforcer` (lot LP4-4) pilotent le sandboxing OS ;
    /// `None`/`None` ⇒ chemin natif inchangé.
    #[must_use]
    pub fn new(
        id: SessionId,
        command: impl Into<String>,
        cwd: impl Into<String>,
        seed_conversation_id: Option<String>,
        writable_roots: Vec<String>,
        env: Vec<(String, String)>,
        sandbox: Option<SandboxPlan>,
        sandbox_enforcer: Option<Arc<dyn SandboxEnforcer>>,
    ) -> Self {
        Self::new_with_policy_and_overrides(
            id,
            command,
            cwd,
            seed_conversation_id,
            "workspace-write",
            writable_roots,
            None,
            None,
            None,
            env,
            sandbox,
            sandbox_enforcer,
        )
    }

    /// Construit l'adapter avec la politique compatible `codex exec` résolue par
    /// `LaunchAgent`.
    #[must_use]
    #[allow(clippy::too_many_arguments)]
    pub fn new_with_policy(
        id: SessionId,
        command: impl Into<String>,
        cwd: impl Into<String>,
        seed_conversation_id: Option<String>,
        sandbox_mode: impl Into<String>,
        writable_roots: Vec<String>,
        network_access: Option<bool>,
        env: Vec<(String, String)>,
        sandbox: Option<SandboxPlan>,
        sandbox_enforcer: Option<Arc<dyn SandboxEnforcer>>,
    ) -> Self {
        Self::new_with_policy_and_overrides(
            id,
            command,
            cwd,
            seed_conversation_id,
            sandbox_mode,
            writable_roots,
            network_access,
            None,
            None,
            env,
            sandbox,
            sandbox_enforcer,
        )
    }

    /// Construit l'adapter avec politique + overrides de config issus du profil IdeA.
    #[must_use]
    #[allow(clippy::too_many_arguments)]
    pub fn new_with_policy_and_overrides(
        id: SessionId,
        command: impl Into<String>,
        cwd: impl Into<String>,
        seed_conversation_id: Option<String>,
        sandbox_mode: impl Into<String>,
        writable_roots: Vec<String>,
        network_access: Option<bool>,
        model: Option<String>,
        model_reasoning_effort: Option<String>,
        env: Vec<(String, String)>,
        sandbox: Option<SandboxPlan>,
        sandbox_enforcer: Option<Arc<dyn SandboxEnforcer>>,
    ) -> Self {
        Self {
            id,
            command: command.into(),
            cwd: cwd.into(),
            sandbox_mode: sandbox_mode.into(),
            writable_roots,
            network_access,
            model,
            model_reasoning_effort,
            env,
            conversation_id: Mutex::new(seed_conversation_id),
            sandbox,
            sandbox_enforcer,
        }
    }

    /// Compose la ligne de commande d'un tour.
    ///
    /// Format RÉEL vérifié 2026-06-10 (codex 0.137.0) :
    /// - Conversation neuve : `codex exec --json --skip-git-repo-check
    ///   --sandbox workspace-write --add-dir <project-root> <prompt>`.
    /// - Reprise (id connu) : `codex exec --json
    ///   --skip-git-repo-check --sandbox workspace-write --add-dir <project-root> resume
    ///   <thread_id> <prompt>`.
    ///
    /// **Autonomie d'écriture (D3)** : `--sandbox workspace-write` autorise l'agent à
    /// écrire dans son workspace. `codex exec` est déjà non-interactif (aucun prompt
    /// d'approbation possible), donc on ne passe **pas** `--ask-for-approval` : ce flag
    /// appartient à la commande interactive `codex`, pas à la sous-commande `exec` qui
    /// sort sur `error: unexpected argument '--ask-for-approval' found`. Comme l'agent
    /// tourne depuis son run dir isolé, `--add-dir` expose explicitement le project root
    /// à la sandbox Codex pour que les écritures Git touchent le vrai workspace.
    fn build_spawn_line(&self, prompt: &str) -> SpawnLine {
        let mut args = vec!["exec".to_owned()];
        let conversation_id = self.conversation_id.lock().expect("mutex sain").clone();
        args.push("--json".to_owned());
        args.push("--skip-git-repo-check".to_owned());
        if !self.sandbox_mode.trim().is_empty() {
            args.push("--sandbox".to_owned());
            args.push(self.sandbox_mode.clone());
        }
        if self.sandbox_mode == "workspace-write" {
            for root in self.writable_roots.iter().filter(|root| !root.is_empty()) {
                args.push("--add-dir".to_owned());
                args.push(root.clone());
            }
        }
        if let Some(network_access) = self.network_access {
            args.push("-c".to_owned());
            args.push(format!(
                "sandbox_workspace_write.network_access={network_access}"
            ));
        }
        if let Some(model) = self
            .model
            .as_deref()
            .filter(|model| !model.trim().is_empty())
        {
            args.push("-c".to_owned());
            args.push(format!("model={}", codex_toml_string(model)));
        }
        if let Some(effort) = self
            .model_reasoning_effort
            .as_deref()
            .filter(|effort| !effort.trim().is_empty())
        {
            args.push("-c".to_owned());
            args.push(format!(
                "model_reasoning_effort={}",
                codex_toml_string(effort)
            ));
        }
        if let Some(id) = conversation_id {
            args.push("resume".to_owned());
            args.push(id);
        }
        args.push(prompt.to_owned());
        let mut env = self.env.clone();
        if let Some(network_access) = self.network_access {
            upsert_env(
                &mut env,
                "CODEX_SANDBOX_NETWORK_DISABLED",
                if network_access { "0" } else { "1" },
            );
        }
        SpawnLine {
            command: self.command.clone(),
            args,
            cwd: self.cwd.clone(),
            env,
            stdin: None,
            sandbox: self.sandbox.clone(),
        }
    }
}

fn codex_toml_string(value: &str) -> String {
    serde_json::to_string(value).expect("string serialization cannot fail")
}

fn upsert_env(env: &mut Vec<(String, String)>, key: &str, value: &str) {
    if let Some((_, existing)) = env.iter_mut().find(|(k, _)| k == key) {
        *existing = value.to_owned();
    } else {
        env.push((key.to_owned(), value.to_owned()));
    }
}

#[async_trait]
impl AgentSession for CodexExecSession {
    fn id(&self) -> SessionId {
        self.id
    }

    fn conversation_id(&self) -> Option<String> {
        self.conversation_id.lock().expect("mutex sain").clone()
    }

    async fn send(&self, prompt: &str) -> Result<ReplyStream, AgentSessionError> {
        self.send_inner(prompt, None).await
    }

    async fn send_with_tap(
        &self,
        prompt: &str,
        tap: std::sync::mpsc::Sender<ReplyEvent>,
    ) -> Result<ReplyStream, AgentSessionError> {
        self.send_inner(prompt, Some(tap)).await
    }

    async fn shutdown(&self) -> Result<(), AgentSessionError> {
        // « un run par tour » ⇒ pas de process long survivant : idempotent, no-op.
        Ok(())
    }
}

impl CodexExecSession {
    async fn send_inner(
        &self,
        prompt: &str,
        tap: Option<std::sync::mpsc::Sender<ReplyEvent>>,
    ) -> Result<ReplyStream, AgentSessionError> {
        let spec = self.build_spawn_line(prompt);
        let has_tap = tap.is_some();
        let (line_tap, parser_thread) = tap.map_or((None, None), |event_tap| {
            let (line_tx, line_rx) = std::sync::mpsc::channel::<String>();
            let parser = std::thread::spawn(move || {
                for line in line_rx {
                    if let Ok(parsed) = parse_event(&line) {
                        for event in parsed.events {
                            if !matches!(event, ReplyEvent::Final { .. }) {
                                let _ = event_tap.send(event);
                            }
                        }
                    }
                }
            });
            (Some(line_tx), Some(parser))
        });
        let raw_result = run_turn(&spec, None, self.sandbox_enforcer.as_ref(), line_tap).await;
        if let Some(parser) = parser_thread {
            let _ = parser.join();
        }
        let raw_lines = raw_result?;

        let mut events = Vec::new();
        let mut captured_id = None;
        // Fix canal (B2, bootstrap) : un tour `codex exec` peut émettre PLUSIEURS
        // `agent_message` — un préambule (« je vais… ») puis la conclusion. On ne coupe
        // donc plus au premier : on retient le **dernier** `agent_message` comme unique
        // `Final` terminal (la conclusion du tour), et on dégrade les précédents en
        // activité non terminale (readiness préservée). Ainsi le demandeur reçoit la
        // conclusion, pas le préambule. Absence d'`agent_message` ⇒ aucun `Final`
        // (no-reply inchangé).
        let mut last_final: Option<String> = None;
        for line in &raw_lines {
            let parsed = parse_event(line)?;
            if let Some(id) = parsed.conversation_id {
                captured_id = Some(id);
            }
            for event in parsed.events {
                match event {
                    ReplyEvent::Final { content } => {
                        // Un `agent_message` précédemment retenu est supersédé : il devient
                        // une annonce non terminale, on garde le plus récent en conclusion.
                        if last_final.is_some() {
                            if !has_tap {
                                events.push(ReplyEvent::Announcement {
                                    text: last_final.take().expect("présent"),
                                });
                            }
                        }
                        last_final = Some(content);
                    }
                    other => {
                        if !has_tap {
                            events.push(other);
                        }
                    }
                }
            }
        }
        // Le dernier `agent_message` retenu est le seul `Final` terminal, émis en fin de
        // flux (après les heartbeats/activités du tour).
        if let Some(content) = last_final {
            events.push(ReplyEvent::Final { content });
        }
        if let Some(id) = captured_id {
            *self.conversation_id.lock().expect("mutex sain") = Some(id);
        }

        Ok(Box::new(events.into_iter()))
    }
}