//! Beacon (spec §12): the house rules an agent receives, compiled from the

//! layers that exist, each under a heading naming it, with no other change;

//! the version is the BLAKE3 of that text. 0.1 has the site layer; kind,

//! project and agent layers, and committing them to the ledger, are 0.3.

use crate::event::Event;

use anyhow::{bail, Result};

use std::path::Path;

/// A rule file over this is refused (spec §12.2).

pub const MAX_RULES: usize = 64 * 1024;

/// Compiled rules and their version.

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

pub struct Rules {

    pub text: String,

    /// The first 12 hex characters of BLAKE3(text).

    pub version: String,

}

/// The rules for an agent, from `<data>/rules/`.

pub fn compile(data: &Path) -> Result<Rules> {

    let mut text = String::new();

    let site = data.join("rules").join("site.md");

    if let Ok(body) = std::fs::read_to_string(&site) {

        if body.len() > MAX_RULES {

            bail!("{} is over 64 KiB: the rules must stay readable in one call", site.display());

        }

        text.push_str("# House rules: site (rules/site.md)\n\n");

        text.push_str(body.trim_end());

        text.push('\n');

    }

    let version = blake3::hash(text.as_bytes()).to_hex()[..12].to_string();

    Ok(Rules { text, version })

}

/// The version `agent` last read, if any.

pub async fn last_read(pool: &sqlx::SqlitePool, agent: &str) -> sqlx::Result<Option<String>> {

    sqlx::query_scalar("SELECT version FROM rules_read WHERE agent = ?").bind(agent).fetch_optional(pool).await

}

/// The line every result begins with while an agent works on stale rules.

pub fn changed_line(read: &str, now: &str) -> String {

    format!("House rules changed ({read} → {now}): call rules before continuing.")

}

/// Apply `rules.read` and `tool.called` to their tables.

pub async fn project(conn: &mut sqlx::SqliteConnection, e: &Event) -> sqlx::Result<()> {

    let p = e.json();

    let agent = e.actor.strip_prefix("agent:");

    match e.kind.as_str() {

        "rules.read" => {

            if let (Some(a), Some(v)) = (agent, p.get("version").and_then(|v| v.as_str())) {

                sqlx::query("INSERT INTO rules_read (agent, version, at_ms) VALUES (?, ?, ?) ON CONFLICT(agent) DO UPDATE SET version = excluded.version, at_ms = excluded.at_ms")

                    .bind(a)

                    .bind(v)

                    .bind(e.at_ms as i64)

                    .execute(&mut *conn)

                    .await?;

            }

        }

        "tool.called" => {

            let s = |k: &str| p.get(k).and_then(|v| v.as_str()).map(String::from);

            if let (Some(a), Some(tool)) = (agent, s("tool")) {

                sqlx::query("INSERT OR IGNORE INTO tool_calls (seq, agent, tool, args, result, ms, is_error, read, session, at_ms) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)")

                    .bind(e.seq as i64)

                    .bind(a)

                    .bind(tool)

                    .bind(s("args").unwrap_or_default())

                    .bind(s("result").unwrap_or_default())

                    .bind(p.get("ms").and_then(|v| v.as_i64()).unwrap_or(0))

                    .bind(p.get("is_error").and_then(|v| v.as_bool()).unwrap_or(false))

                    .bind(p.get("read").and_then(|v| v.as_bool()).unwrap_or(false))

                    .bind(&e.session)

                    .bind(e.at_ms as i64)

                    .execute(&mut *conn)

                    .await?;

            }

        }

        _ => {}

    }

    Ok(())

}

#[cfg(test)]

mod tests {

    use super::*;

    #[test]

    fn the_version_follows_the_text_exactly() {

        let dir = tempfile::tempdir().unwrap();

        let empty = compile(dir.path()).unwrap();

        assert_eq!(empty.text, "");

        std::fs::create_dir_all(dir.path().join("rules")).unwrap();

        std::fs::write(dir.path().join("rules/site.md"), "Commit with oxy.\n").unwrap();

        let a = compile(dir.path()).unwrap();

        assert!(a.text.contains("Commit with oxy.") && a.text.starts_with("# House rules: site"));

        std::fs::write(dir.path().join("rules/site.md"), "Commit with oxy!\n").unwrap();

        let b = compile(dir.path()).unwrap();

        assert_ne!(a.version, b.version);

        assert_eq!(a.version.len(), 12);

        std::fs::write(dir.path().join("rules/site.md"), "x".repeat(MAX_RULES + 1)).unwrap();

        assert!(compile(dir.path()).is_err());

    }

}