//! `spectra project`: the checkouts agents work in (spec §23.1).

use super::identity::{owner_home, refresh_owner};
use super::{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 async fn add(ctx: &Ctx, path: &Path, name: Option<String>, remote: Option<String>, owner_home_flag: Option<PathBuf>) -> Result<i32> {
    let path = path.canonicalize().with_context(|| format!("{} does not exist", path.display()))?;
    let name = match name {
        Some(n) => n,
        None => projects::default_name(&path)?,
    };
    if !super::agent::valid_name(&name) {
        bail!("a project's name is lower-case letters, digits and dashes (--name)");
    }
    let checkout = projects::inspect(&path)?;
    let ledger = ctx.writer().await?;
    let exists: Option<String> = sqlx::query_scalar("SELECT name FROM projects WHERE name = ? OR path = ?")
        .bind(&name)
        .bind(path.display().to_string())
        .fetch_optional(ledger.pool())
        .await?;
    if let Some(e) = exists {
        bail!("{} is already a project ({e})", path.display());
    }
    let home = owner_home(ctx, owner_home_flag);
    refresh_owner(&ledger, &home).await?;
    let owner = KeyPair::load_home(&home)?;
    let remote = remote.or(checkout.remote.clone());
    let payload = serde_json::json!({
        "name": name, "path": path.display().to_string(), "repo_id": checkout.repo_id, "remote": remote, "modules": checkout.modules,
    });
    ledger
        .append(vec![
            signed_event(&owner, "human", "project.added", payload).project(name.clone()).subject(name.clone()),
            spectra_core::conversation::project_channel_event(&name),
        ])
        .await?;
    ledger.checkpoint().await?;
    println!("{} {}  {}", ui::done("Added"), ui::subject(&name), ui::path(path.display()));
    if let Some(r) = &remote {
        println!("{}", ui::kv("remote", r));
    }
    if let Some(id) = &checkout.repo_id {
        println!("{}", ui::kv("repo", ui::hash(id)));
    }
    let (deps, users) = relations(&ledger, &name).await?;
    if !deps.is_empty() {
        println!("{}", ui::kv("pins", deps.join(", ")));
    }
    if !users.is_empty() {
        println!("{}", ui::kv("pinned by", users.join(", ")));
    }
    if checkout.repo_id.is_none() {
        println!("  {} {}", ui::note(), ui::dim("not an Oxygen checkout: relations come from .oxymodules, so it has none"));
    }
    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))
}

pub async fn list(ctx: &Ctx, json: bool) -> Result<i32> {
    let ledger = Ledger::open_read_only(&ctx.db()?).await?;
    let rows: Vec<(String, String, Option<String>)> =
        sqlx::query_as("SELECT name, path, remote FROM projects ORDER BY name").fetch_all(ledger.pool()).await?;
    let mut out = Vec::new();
    for (name, path, remote) 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, "remote": remote, "depends_on": deps, "depended_on_by": users, "agents": agents }));
    }
    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 PATH"));
    }
    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(""))
        );
        for (k, label) in [("depends_on", "pins"), ("depended_on_by", "pinned by"), ("agents", "agents")] {
            let v = list(k);
            if !v.is_empty() {
                println!("{}", ui::kv(label, v));
            }
        }
    }
    Ok(0)
}