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

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 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 home = owner_home(ctx, owner_home_flag);

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

    let path_s = path.display().to_string();

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

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

        bail!("{} is already a project ({})", path.display(), 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 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,

    });

    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), 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 now = all(&w).await?;

    let me = now.iter().find(|p| p["name"] == name.as_str()).cloned().unwrap_or_default();

    let names =

        |k: &str| me[k].as_array().map(|a| a.iter().filter_map(|v| v.as_str().map(String::from)).collect::<Vec<_>>()).unwrap_or_default();

    let (deps, users) = (names("depends_on"), names("depended_on_by"));

    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))

}

/// 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, 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 }));

    }

    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 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)

}