//! Client hooks (spec §20): executables in `.oxy/hooks/<event>`, never

//! cloned. Each receives one JSON object on stdin; `pre-*` hooks block the

//! operation by exiting non-zero, and their stderr becomes the error. The

//! `semantic-deps` hook runs only when `hooks.semantic-deps = true` and

//! answers `{"deps": ["<hash hex>", ...]}`.

use super::*;

use std::process::{Command, Stdio};

/// Minimal JSON string escaping.

pub fn json_str(s: &str) -> String {

    let mut out = String::with_capacity(s.len() + 2);

    out.push('"');

    for c in s.chars() {

        match c {

            '"' => out.push_str("\\\""),

            '\\' => out.push_str("\\\\"),

            '\n' => out.push_str("\\n"),

            '\r' => out.push_str("\\r"),

            '\t' => out.push_str("\\t"),

            c if (c as u32) < 0x20 => out.push_str(&format!("\\u{:04x}", c as u32)),

            c => out.push(c),

        }

    }

    out.push('"');

    out

}

pub fn json_array<I: IntoIterator<Item = String>>(items: I) -> String {

    format!("[{}]", items.into_iter().collect::<Vec<_>>().join(","))

}

/// What running a hook produced.

#[derive(Debug, Clone, PartialEq, Eq)]

pub struct HookOutcome {

    pub ran: bool,

    pub stdout: String,

}

impl Repo {

    fn hook_path(&self, event: &str) -> PathBuf {

        self.oxy.join("hooks").join(event)

    }

    /// Run the hook for `event` with `input` on stdin, if one exists and is

    /// executable. A non-zero exit is an error carrying the hook's stderr.

    pub fn run_hook(&self, event: &str, input: &str) -> Result<HookOutcome> {

        let path = self.hook_path(event);

        if !path.is_file() {

            return Ok(HookOutcome {

                ran: false,

                stdout: String::new(),

            });

        }

        let mut child = Command::new(&path)

            .current_dir(&self.root)

            .env("OXY_EVENT", event)

            .env("OXY_ROOT", &self.root)

            .stdin(Stdio::piped())

            .stdout(Stdio::piped())

            .stderr(Stdio::piped())

            .spawn()

            .map_err(|e| RepoError::Msg(format!("running hook {event}: {e}")))?;

        if let Some(mut stdin) = child.stdin.take() {

            let _ = stdin.write_all(input.as_bytes());

        }

        let out = child.wait_with_output()?;

        let stdout = String::from_utf8_lossy(&out.stdout).to_string();

        if !out.status.success() {

            let stderr = String::from_utf8_lossy(&out.stderr).trim().to_string();

            return fail(format!(

                "hook {event} refused: {}",

                if stderr.is_empty() {

                    "(no message)".to_string()

                } else {

                    stderr

                }

            ));

        }

        Ok(HookOutcome { ran: true, stdout })

    }

    /// Extra dependencies from the `semantic-deps` hook (spec §8.1, §20).

    pub(crate) fn semantic_deps(

        &self,

        change_id: &ChangeId,

        touched: &[String],

        candidates: &[(ChangeId, ChangeHash, Vec<String>)],

    ) -> Result<Vec<ChangeHash>> {

        if !self.config.semantic_deps {

            return Ok(vec![]);

        }

        let input = format!(

            "{{\"change_id\":{},\"touched_paths\":{},\"candidate_deps\":{}}}",

            json_str(&change_id.to_hex()),

            json_array(touched.iter().map(|p| json_str(p))),

            json_array(candidates.iter().map(|(id, h, paths)| format!(

                "{{\"change_id\":{},\"hash\":{},\"paths\":{}}}",

                json_str(&id.to_hex()),

                json_str(&h.to_hex()),

                json_array(paths.iter().map(|p| json_str(p)))

            )))

        );

        let out = self.run_hook("semantic-deps", &input)?;

        if !out.ran {

            return Ok(vec![]);

        }

        // Accept every 64-hex token after "deps"; any other shape is ignored.

        let body = out

            .stdout

            .split_once("\"deps\"")

            .map(|(_, rest)| rest.to_string())

            .unwrap_or_default();

        let mut deps = Vec::new();

        let bytes = body.as_bytes();

        let mut i = 0;

        while i + 64 <= bytes.len() {

            if bytes[i..i + 64].iter().all(|b| b.is_ascii_hexdigit())

                && (i == 0 || !bytes[i - 1].is_ascii_hexdigit())

                && (i + 64 == bytes.len() || !bytes[i + 64].is_ascii_hexdigit())

            {

                if let Some(h) = ObjectRef::from_hex(&body[i..i + 64]) {

                    deps.push(h);

                }

                i += 64;

            } else {

                i += 1;

            }

        }

        Ok(deps)

    }

}