//! Beacon (spec §12): the brief an agent receives, compiled from the
//! layers the owner has set (overall, then the agent's project), each under
//! a heading naming it, with no other change; the version is the BLAKE3 of
//! that text. Briefs are `brief.set` events signed by the owner; nothing is
//! read from a file.

use crate::event::Event;
use anyhow::{bail, Result};

/// A brief over this is refused (spec §12.1).
pub const MAX_BRIEF: usize = 64 * 1024;

/// A compiled brief and its version.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Rules {
    pub text: String,
    /// The first 12 hex characters of BLAKE3(text).
    pub version: String,
}

/// Check a brief's text before it is signed.
pub fn check(text: &str) -> Result<()> {
    if text.len() > MAX_BRIEF {
        bail!("a brief is at most 64 KiB, so an agent can read it in one call ({} bytes)", text.len());
    }
    Ok(())
}

/// The text of one layer, if set.
pub async fn layer(pool: &sqlx::SqlitePool, project: Option<&str>) -> Result<Option<String>> {
    let (layer, p) = match project {
        Some(p) => ("project", p),
        None => ("overall", ""),
    };
    Ok(sqlx::query_scalar("SELECT text FROM briefs WHERE layer = ? AND project = ?").bind(layer).bind(p).fetch_optional(pool).await?)
}

/// The brief for an agent in `project` (none for the owner: the overall
/// brief alone).
pub async fn compile(pool: &sqlx::SqlitePool, project: Option<&str>) -> Result<Rules> {
    let mut text = String::new();
    if let Some(body) = layer(pool, None).await? {
        text.push_str("# Overall brief\n\n");
        text.push_str(body.trim_end());
        text.push('\n');
    }
    if let Some(p) = project {
        if let Some(body) = layer(pool, Some(p)).await? {
            if !text.is_empty() {
                text.push('\n');
            }
            text.push_str(&format!("# Project brief: {p}\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!("Your brief changed ({read} → {now}): call rules before continuing.")
}

/// Apply `brief.set`, `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() {
        // Only the owner sets a brief; an agent's key can never sign as `human`.
        "brief.set" if e.actor == "human" => {
            let project = p.get("project").and_then(|v| v.as_str()).unwrap_or("");
            let layer = if project.is_empty() { "overall" } else { "project" };
            let text = p.get("text").and_then(|v| v.as_str()).unwrap_or("");
            if text.trim().is_empty() {
                sqlx::query("DELETE FROM briefs WHERE layer = ? AND project = ?").bind(layer).bind(project).execute(&mut *conn).await?;
            } else {
                sqlx::query("INSERT OR REPLACE INTO briefs (layer, project, text, seq) VALUES (?, ?, ?, ?)")
                    .bind(layer)
                    .bind(project)
                    .bind(text)
                    .bind(e.seq as i64)
                    .execute(&mut *conn)
                    .await?;
            }
        }
        "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 a_brief_must_fit_in_one_call() {
        assert!(check("Write for a curious twelve-year-old.").is_ok());
        assert!(check(&"x".repeat(MAX_BRIEF)).is_ok());
        assert!(check(&"x".repeat(MAX_BRIEF + 1)).is_err());
        assert!(changed_line("aaa", "bbb").starts_with("Your brief changed (aaa → bbb)"));
    }
}