//! Projects (spec §23.1): checkouts the agents work in, with the

//! repository id and remote read from `.oxy/`, and dependencies read from

//! `.oxymodules`, matched to other registered projects by remote URL.

use crate::event::Event;

use anyhow::{Context, Result};

use serde_json::Value as Json;

use sqlx::SqliteConnection;

use std::path::Path;

/// What a checkout says about itself.

#[derive(Clone, Debug, Default, PartialEq, Eq)]

pub struct Checkout {

    pub repo_id: Option<String>,

    pub remote: Option<String>,

    /// The URLs of the subrepos it pins (`.oxymodules`).

    pub modules: Vec<String>,

}

/// Read `.oxy/id`, the remote (`origin`, else the first) and `.oxymodules`.

pub fn inspect(path: &Path) -> Result<Checkout> {

    if !path.is_dir() {

        anyhow::bail!("{} is not a directory", path.display());

    }

    let oxy = path.join(".oxy");

    let repo_id = std::fs::read_to_string(oxy.join("id")).ok().map(|s| s.trim().to_string()).filter(|s| !s.is_empty());

    let mut remotes: Vec<(String, String)> = Vec::new();

    if let Ok(text) = std::fs::read_to_string(oxy.join("config")) {

        for line in text.lines() {

            if let Some((k, v)) = line.split_once('=') {

                let k = k.trim();

                if let Some(name) = k.strip_prefix("remote.").and_then(|r| r.strip_suffix(".url")) {

                    remotes.push((name.to_string(), v.trim().trim_matches('"').to_string()));

                }

            }

        }

    }

    let remote = remotes.iter().find(|(n, _)| n == "origin").or(remotes.first()).map(|(_, u)| u.clone());

    let modules = std::fs::read_to_string(path.join(".oxymodules"))

        .map(|t| {

            t.lines()

                .filter_map(|l| l.trim().strip_prefix("url").map(|r| r.trim_start().trim_start_matches('=').trim().to_string()))

                .collect()

        })

        .unwrap_or_default();

    Ok(Checkout { repo_id, remote, modules })

}

/// A project's name: the directory's, lower-cased, made valid.

pub fn default_name(path: &Path) -> Result<String> {

    let base = path.canonicalize()?.file_name().and_then(|n| n.to_str()).map(str::to_lowercase).context("the path has no name")?;

    Ok(base.chars().map(|c| if c.is_ascii_alphanumeric() || c == '-' { c } else { '-' }).collect())

}

fn same_repo(a: &str, b: &str) -> bool {

    let n = |s: &str| s.trim_end_matches('/').trim_end_matches(".git").to_lowercase();

    n(a) == n(b)

}

/// Apply `project.added` to the tables, deriving relations both ways.

pub async fn project(conn: &mut SqliteConnection, e: &Event) -> sqlx::Result<()> {

    if e.kind != "project.added" {

        return Ok(());

    }

    let p = e.json();

    let s = |k: &str| p.get(k).and_then(Json::as_str).map(String::from);

    let Some(name) = s("name") else { return Ok(()) };

    let modules: Vec<String> = p

        .get("modules")

        .and_then(Json::as_array)

        .map(|a| a.iter().filter_map(|m| m.as_str().map(String::from)).collect())

        .unwrap_or_default();

    let remote = s("remote");

    sqlx::query("INSERT OR REPLACE INTO projects (name, path, repo_id, remote, modules, seq) VALUES (?, ?, ?, ?, ?, ?)")

        .bind(&name)

        .bind(s("path").unwrap_or_default())

        .bind(s("repo_id"))

        .bind(&remote)

        .bind(serde_json::to_string(&modules).unwrap_or_default())

        .bind(e.seq as i64)

        .execute(&mut *conn)

        .await?;

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

        sqlx::query_as("SELECT name, remote, modules FROM projects WHERE name != ?").bind(&name).fetch_all(&mut *conn).await?;

    for (other, other_remote, other_modules) in others {

        if other_remote.as_deref().is_some_and(|r| modules.iter().any(|m| same_repo(m, r))) {

            sqlx::query("INSERT OR IGNORE INTO project_relations (project, depends_on) VALUES (?, ?)")

                .bind(&name)

                .bind(&other)

                .execute(&mut *conn)

                .await?;

        }

        let theirs: Vec<String> = serde_json::from_str(&other_modules).unwrap_or_default();

        if remote.as_deref().is_some_and(|r| theirs.iter().any(|m| same_repo(m, r))) {

            sqlx::query("INSERT OR IGNORE INTO project_relations (project, depends_on) VALUES (?, ?)")

                .bind(&other)

                .bind(&name)

                .execute(&mut *conn)

                .await?;

        }

    }

    Ok(())

}

#[cfg(test)]

mod tests {

    use super::*;

    #[test]

    fn a_checkout_reports_its_id_remote_and_subrepos() {

        let dir = tempfile::tempdir().unwrap();

        std::fs::create_dir_all(dir.path().join(".oxy")).unwrap();

        std::fs::write(dir.path().join(".oxy/id"), "97e6").unwrap();

        std::fs::write(

            dir.path().join(".oxy/config"),

            "remote.earth.url = \"https://hub/a/hub\"\nremote.origin.url = \"https://hub/a/x\"\n",

        )

        .unwrap();

        std::fs::write(dir.path().join(".oxymodules"), "[deps/flow]\nurl = https://hub/a/flow\nbookmark = main\n").unwrap();

        let c = inspect(dir.path()).unwrap();

        assert_eq!(

            c,

            Checkout { repo_id: Some("97e6".into()), remote: Some("https://hub/a/x".into()), modules: vec!["https://hub/a/flow".into()] }

        );

        assert!(same_repo("https://hub/a/flow/", "https://HUB/a/flow.git"));

    }

}