//! `spectra brief`: what the owner tells the agents (spec §12.1), an

//! overall brief and one per project, each a signed `brief.set` event.

use super::identity::owner_home;

use super::{call, ui, Ctx};

use anyhow::{bail, Context, Result};

use spectra_core::keys::KeyPair;

use spectra_core::ledger::Ledger;

use spectra_core::principals::signed_event;

use std::path::PathBuf;

fn label(project: Option<&str>) -> String {

    project.map(|p| format!("{p}'s brief")).unwrap_or_else(|| "the overall brief".into())

}

/// A layer's current text: from the daemon when one serves, else the ledger.

async fn current(ctx: &Ctx, project: Option<&str>) -> Result<Option<String>> {

    let home = owner_home(ctx, None);

    if let Some(c) = ctx.owner_client(&home).await? {

        let v = call(&c, "GET", "/api/v1/briefs", None).await?;

        return Ok(match project {

            None => v["overall"].as_str().map(String::from),

            Some(p) => v["projects"]

                .as_array()

                .and_then(|a| a.iter().find(|x| x["project"] == p))

                .and_then(|x| x["text"].as_str())

                .map(String::from),

        });

    }

    let ledger = Ledger::open_read_only(&ctx.db()?).await?;

    spectra_core::rules::layer(ledger.pool(), project).await

}

pub async fn show(ctx: &Ctx, project: Option<String>, as_json: bool) -> Result<i32> {

    let text = current(ctx, project.as_deref()).await?;

    if as_json {

        println!("{}", serde_json::json!({ "project": project, "text": text }));

        return Ok(0);

    }

    println!("{}", ui::section(label(project.as_deref())));

    match text {

        Some(t) => println!("{}", t.trim_end()),

        None => println!("{} {}", ui::note(), ui::dim("not set: spectra brief set [--project P] \"…\", or spectra brief edit")),

    }

    Ok(0)

}

pub async fn set(ctx: &Ctx, project: Option<String>, text: String, owner_home_flag: Option<PathBuf>) -> Result<i32> {

    spectra_core::rules::check(&text)?;

    let home = owner_home(ctx, owner_home_flag);

    let w = ctx.owner_writer(&home).await?;

    if let Some(p) = &project {

        let known = match (w.client(), w.ledger()) {

            (Some(c), _) => {

                call(c, "GET", "/api/v1/projects", None).await?.as_array().is_some_and(|l| l.iter().any(|x| x["name"] == p.as_str()))

            }

            (None, Some(l)) => sqlx::query_scalar::<_, String>("SELECT name FROM projects WHERE name = ?")

                .bind(p)

                .fetch_optional(l.pool())

                .await?

                .is_some(),

            (None, None) => false,

        };

        if !known {

            bail!("no project named {p} (spectra project list)");

        }

    }

    let mut events: Vec<_> = w.refresh_event(&home).await?.into_iter().collect();

    let owner = KeyPair::load_home(&home)?;

    let mut e = signed_event(&owner, "human", "brief.set", serde_json::json!({ "project": project, "text": text }));

    e.project = project.clone();

    events.push(e);

    w.append(events).await?;

    let verb = if text.trim().is_empty() { "Cleared" } else { "Set" };

    println!("{} {}", ui::done(verb), ui::subject(label(project.as_deref())));

    println!("  {} {}", ui::note(), ui::dim("agents are told on their next call that their brief changed"));

    Ok(0)

}

/// Read the text from an argument, a file, or `-` for standard input.

pub fn text_of(text: Option<String>, file: Option<PathBuf>) -> Result<String> {

    match (text, file) {

        (Some(t), None) => Ok(t),

        (None, Some(f)) if f.as_os_str() == "-" => {

            let mut s = String::new();

            std::io::Read::read_to_string(&mut std::io::stdin(), &mut s)?;

            Ok(s)

        }

        (None, Some(f)) => std::fs::read_to_string(&f).with_context(|| format!("reading {}", f.display())),

        (Some(_), Some(_)) => bail!("give the text or --file, not both"),

        (None, None) => bail!("give the text, or --file FILE (- for standard input), or use spectra brief edit"),

    }

}

/// `spectra brief edit`: the current text in `$VISUAL` or `$EDITOR`.

pub async fn edit(ctx: &Ctx, project: Option<String>, owner_home_flag: Option<PathBuf>) -> Result<i32> {

    let before = current(ctx, project.as_deref()).await?.unwrap_or_default();

    let dir = tempfile::tempdir()?;

    let path = dir.path().join(format!("{}.md", project.as_deref().unwrap_or("overall")));

    std::fs::write(&path, &before)?;

    let editor = std::env::var("VISUAL").or_else(|_| std::env::var("EDITOR")).unwrap_or_else(|_| "nano".into());

    let mut parts = editor.split_whitespace();

    let program = parts.next().context("no editor ($VISUAL or $EDITOR)")?;

    let status = std::process::Command::new(program).args(parts).arg(&path).status().with_context(|| format!("running {editor}"))?;

    if !status.success() {

        bail!("{editor} did not finish cleanly: nothing was changed");

    }

    let after = std::fs::read_to_string(&path)?;

    if after == before {

        println!("{} {}", ui::note(), ui::dim("unchanged"));

        return Ok(0);

    }

    set(ctx, project, after, owner_home_flag).await

}