//! `spectra project`: the work agents share (spec §23.1), any kind of it.

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 spectra_core::projects;

use std::path::{Path, PathBuf};

pub struct Add {

    pub target: String,

    pub name: Option<String>,

    pub path: Option<PathBuf>,

    pub description: String,

    pub url: Option<String>,

}

pub async fn add(ctx: &Ctx, a: Add, owner_home_flag: Option<PathBuf>) -> Result<i32> {

    // A folder that exists is the work's folder; anything else is a name.

    let as_dir = Path::new(&shellexpand(&a.target)).to_path_buf();

    let (name, path) = match (&a.path, as_dir.is_dir()) {

        (None, true) => {

            let path = as_dir.canonicalize()?;

            (a.name.clone().map(Ok).unwrap_or_else(|| projects::default_name(&path))?, Some(path))

        }

        (Some(p), _) => {

            let path = p.canonicalize().with_context(|| format!("{} does not exist", p.display()))?;

            (a.name.clone().unwrap_or_else(|| a.target.clone()), Some(path))

        }

        (None, false) => (a.name.clone().unwrap_or_else(|| a.target.clone()), None),

    };

    if !super::agent::valid_name(&name) {

        bail!("a project's name is lower-case letters, digits and dashes, starting with a letter or digit (--name)");

    }

    let home = owner_home(ctx, owner_home_flag);

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

    let path_s = path.as_ref().map(|p| p.display().to_string());

    let existing = all(&w).await?;

    if let Some(e) = existing.iter().find(|p| p["name"] == name.as_str() || (path_s.is_some() && p["path"].as_str() == path_s.as_deref())) {

        bail!("{} is already a project", e["name"].as_str().unwrap_or(""));

    }

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

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

    let payload = serde_json::json!({ "name": name, "path": path_s, "description": a.description, "url": a.url });

    events.push(signed_event(&owner, "human", "project.added", payload).project(name.clone()).subject(name.clone()));

    events.push(spectra_core::conversation::project_channel_event(&name));

    w.append(events).await?;

    println!("{} {}{}", ui::done("Added"), ui::subject(&name), path_s.map(|p| format!("  {}", ui::path(p))).unwrap_or_default());

    if !a.description.is_empty() {

        println!("{}", ui::kv("about", &a.description));

    }

    if let Some(u) = &a.url {

        println!("{}", ui::kv("link", u));

    }

    println!(

        "  {} {}",

        ui::note(),

        ui::dim(format!("agents talk about it in #{name}; link it with spectra project link {name} --depends-on OTHER"))

    );

    Ok(0)

}

/// `~/x` as the shell would have it.

fn shellexpand(s: &str) -> String {

    match (s.strip_prefix("~/"), std::env::var_os("HOME")) {

        (Some(rest), Some(h)) => Path::new(&h).join(rest).display().to_string(),

        _ => s.to_string(),

    }

}

/// `spectra project link P --depends-on Q [--remove]`.

pub async fn link(ctx: &Ctx, project: &str, on: &str, remove: bool, owner_home_flag: Option<PathBuf>) -> Result<i32> {

    if project == on {

        bail!("a project cannot depend on itself");

    }

    let home = owner_home(ctx, owner_home_flag);

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

    let existing = all(&w).await?;

    for n in [project, on] {

        if !existing.iter().any(|p| p["name"] == n) {

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

        }

    }

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

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

    let kind = if remove { "project.unlinked" } else { "project.linked" };

    events.push(

        signed_event(&owner, "human", kind, serde_json::json!({ "project": project, "depends_on": on })).project(project.to_string()),

    );

    w.append(events).await?;

    let verb = if remove { "Unlinked" } else { "Linked" };

    println!("{} {} {} {}", ui::done(verb), ui::subject(project), ui::dim("depends on"), ui::subject(on));

    Ok(0)

}

async fn relations(ledger: &Ledger, name: &str) -> Result<(Vec<String>, Vec<String>)> {

    let deps = sqlx::query_scalar("SELECT depends_on FROM project_relations WHERE project = ? ORDER BY 1")

        .bind(name)

        .fetch_all(ledger.pool())

        .await?;

    let users = sqlx::query_scalar("SELECT project FROM project_relations WHERE depends_on = ? ORDER BY 1")

        .bind(name)

        .fetch_all(ledger.pool())

        .await?;

    Ok((deps, users))

}

/// Every project with its relations and agents: from the daemon when one

/// serves, else from the ledger here.

async fn all(w: &super::Writer) -> Result<Vec<serde_json::Value>> {

    match (w.client(), w.ledger()) {

        (Some(c), _) => Ok(call(c, "GET", "/api/v1/projects", None).await?.as_array().cloned().unwrap_or_default()),

        (None, Some(l)) => local(l).await,

        (None, None) => Ok(vec![]),

    }

}

async fn local(ledger: &Ledger) -> Result<Vec<serde_json::Value>> {

    let rows: Vec<(String, Option<String>, String, Option<String>)> =

        sqlx::query_as("SELECT name, path, description, url FROM projects ORDER BY name").fetch_all(ledger.pool()).await?;

    let mut out = Vec::new();

    for (name, path, description, url) in rows {

        let (deps, users) = relations(ledger, &name).await?;

        let agents: Vec<String> = sqlx::query_scalar("SELECT name FROM agents WHERE project = ? AND disabled_ms IS NULL ORDER BY name")

            .bind(&name)

            .fetch_all(ledger.pool())

            .await?;

        out.push(serde_json::json!({ "name": name, "path": path, "description": description, "url": url, "depends_on": deps, "depended_on_by": users, "agents": agents }));

    }

    Ok(out)

}

pub async fn list(ctx: &Ctx, json: bool) -> Result<i32> {

    let out = match ctx.owner_client(&owner_home(ctx, None)).await? {

        Some(c) => call(&c, "GET", "/api/v1/projects", None).await?.as_array().cloned().unwrap_or_default(),

        None => local(&Ledger::open_read_only(&ctx.db()?).await?).await?,

    };

    if json {

        println!("{}", serde_json::Value::Array(out));

        return Ok(0);

    }

    if out.is_empty() {

        println!("{} {}", ui::note(), ui::dim("no projects yet: spectra project add NAME-OR-FOLDER"));

    }

    for p in out {

        let list =

            |k: &str| p[k].as_array().map(|a| a.iter().filter_map(|v| v.as_str()).collect::<Vec<_>>().join(", ")).unwrap_or_default();

        println!(

            "{} {}  {}",

            ui::glyph("▸", ">"),

            ui::bookmark(p["name"].as_str().unwrap_or("")),

            ui::path(p["path"].as_str().unwrap_or(""))

        );

        if let Some(d) = p["description"].as_str().filter(|d| !d.is_empty()) {

            println!("{}", ui::kv("about", d));

        }

        for (k, label) in [("depends_on", "depends on"), ("depended_on_by", "needed by"), ("agents", "agents")] {

            let v = list(k);

            if !v.is_empty() {

                println!("{}", ui::kv(label, v));

            }

        }

    }

    Ok(0)

}