//! Subrepositories (spec §7.8): the pin stored as a `subrepo` node's

//! content, and the `.oxymodules` file mapping paths to remotes.

//!

//! Pin encoding: `{0: 1, 1: kind, 2: locator, 3: pin, 4: bookmark}`; kind 0

//! is an Oxygen repository (locator = repository id, pin = sorted heads),

//! kind 1 a Git repository (locator = null, pin = commit sha as text).

use crate::cbor::{self, Value};

use crate::hash::ChangeHash;

use crate::objects::{array, bytes, check_version, field, oref, text, uint, ObjectError, FORMAT_VERSION};

use std::collections::BTreeMap;

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

pub enum Pin {

    Oxy { repo: [u8; 16], heads: Vec<ChangeHash>, bookmark: String },

    Git { sha: String, branch: String },

}

impl Pin {

    pub fn encode(&self) -> Vec<u8> {

        let v = match self {

            Pin::Oxy { repo, heads, bookmark } => {

                let mut heads = heads.clone();

                heads.sort();

                heads.dedup();

                Value::map([

                    (0, Value::Uint(FORMAT_VERSION)),

                    (1, Value::Uint(0)),

                    (2, Value::Bytes(repo.to_vec())),

                    (3, Value::Array(heads.iter().map(|h| Value::Bytes(h.0.to_vec())).collect())),

                    (4, Value::Text(bookmark.clone())),

                ])

            }

            Pin::Git { sha, branch } => Value::map([

                (0, Value::Uint(FORMAT_VERSION)),

                (1, Value::Uint(1)),

                (2, Value::Null),

                (3, Value::Text(sha.clone())),

                (4, Value::Text(branch.clone())),

            ]),

        };

        cbor::encode(&v)

    }

    pub fn decode(b: &[u8]) -> Result<Pin, ObjectError> {

        let v = cbor::decode(b)?;

        let m = v.as_map().ok_or_else(|| ObjectError::Schema("pin: expected map".into()))?;

        check_version(m)?;

        let bookmark = text(field(m, 4, "bookmark")?, "bookmark")?.to_owned();

        match uint(field(m, 1, "kind")?, "kind")? {

            0 => {

                let repo: [u8; 16] = bytes(field(m, 2, "repo")?, "repo")?.try_into().map_err(|_| ObjectError::Schema("pin: repo id must be 16 bytes".into()))?;

                let heads = array(field(m, 3, "heads")?, "heads")?.iter().map(|h| oref(h, "head")).collect::<Result<Vec<_>, _>>()?;

                Ok(Pin::Oxy { repo, heads, bookmark })

            }

            1 => Ok(Pin::Git { sha: text(field(m, 3, "sha")?, "sha")?.to_owned(), branch: bookmark }),

            k => Err(ObjectError::Schema(format!("pin: unknown kind {k}"))),

        }

    }

    /// A one-line description for listings.

    pub fn summary(&self) -> String {

        match self {

            Pin::Oxy { heads, bookmark, .. } => format!("oxy {bookmark} {}", heads.iter().map(|h| h.short(12)).collect::<Vec<_>>().join(" ")),

            Pin::Git { sha, branch } => format!("git {branch} {}", &sha[..sha.len().min(12)]),

        }

    }

    pub fn is_git(&self) -> bool {

        matches!(self, Pin::Git { .. })

    }

}

/// One `.oxymodules` entry.

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

pub struct Module {

    pub url: String,

    /// Oxygen bookmark or Git branch to track.

    pub bookmark: Option<String>,

    pub git: bool,

}

/// `.oxymodules`: `[path]` sections with `url`, and `bookmark` (Oxygen) or

/// `branch` (Git) keys.

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

pub struct Modules {

    pub entries: BTreeMap<String, Module>,

}

impl Modules {

    pub fn parse(text: &str) -> Modules {

        let mut out = Modules::default();

        let mut current: Option<String> = None;

        for line in text.lines() {

            let line = line.trim();

            if line.is_empty() || line.starts_with('#') {

                continue;

            }

            if let Some(inner) = line.strip_prefix('[').and_then(|l| l.strip_suffix(']')) {

                let path = inner.trim().trim_matches('"').trim_end_matches('/').to_string();

                out.entries.entry(path.clone()).or_default();

                current = Some(path);

                continue;

            }

            let (Some(path), Some((k, v))) = (&current, line.split_once('=')) else { continue };

            let v = v.trim().trim_matches('"').to_string();

            let m = out.entries.get_mut(path).unwrap();

            match k.trim() {

                "url" => m.url = v,

                "bookmark" => {

                    m.bookmark = Some(v);

                    m.git = false;

                }

                "branch" => {

                    m.bookmark = Some(v);

                    m.git = true;

                }

                "kind" => m.git = v == "git",

                _ => {}

            }

        }

        out

    }

    pub fn to_text(&self) -> String {

        let mut s = String::new();

        for (path, m) in &self.entries {

            s.push_str(&format!("[{path}]\nurl = {}\n", m.url));

            if m.git {

                s.push_str("kind = git\n");

            }

            if let Some(b) = &m.bookmark {

                s.push_str(&format!("{} = {b}\n", if m.git { "branch" } else { "bookmark" }));

            }

            s.push('\n');

        }

        s

    }

    /// From Git's `.gitmodules` (`[submodule "name"]` with `path`, `url`, `branch`).

    pub fn from_gitmodules(text: &str) -> Modules {

        let mut out = Modules::default();

        let mut path: Option<String> = None;

        let mut url = String::new();

        let mut branch: Option<String> = None;

        let flush = |out: &mut Modules, path: &Option<String>, url: &str, branch: &Option<String>| {

            if let Some(p) = path {

                out.entries.insert(p.clone(), Module { url: url.to_string(), bookmark: branch.clone(), git: true });

            }

        };

        for line in text.lines() {

            let line = line.trim();

            if line.starts_with("[submodule") {

                flush(&mut out, &path, &url, &branch);

                path = None;

                url.clear();

                branch = None;

                continue;

            }

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

                let v = v.trim().to_string();

                match k.trim() {

                    "path" => path = Some(v.trim_end_matches('/').to_string()),

                    "url" => url = v,

                    "branch" => branch = Some(v),

                    _ => {}

                }

            }

        }

        flush(&mut out, &path, &url, &branch);

        out

    }

    /// Git's `.gitmodules` form of the Git-kind entries.

    pub fn to_gitmodules(&self) -> String {

        let mut s = String::new();

        for (path, m) in &self.entries {

            if !m.git {

                continue;

            }

            s.push_str(&format!("[submodule \"{path}\"]\n\tpath = {path}\n\turl = {}\n", m.url));

            if let Some(b) = &m.bookmark {

                s.push_str(&format!("\tbranch = {b}\n"));

            }

        }

        s

    }

}

#[cfg(test)]

mod tests {

    use super::*;

    use crate::hash::ObjectRef;

    #[test]

    fn pins_round_trip() {

        let o = Pin::Oxy { repo: [7; 16], heads: vec![ObjectRef([2; 32]), ObjectRef([1; 32])], bookmark: "main".into() };

        let back = Pin::decode(&o.encode()).unwrap();

        assert_eq!(back, Pin::Oxy { repo: [7; 16], heads: vec![ObjectRef([1; 32]), ObjectRef([2; 32])], bookmark: "main".into() });

        let g = Pin::Git { sha: "0cb4742f64cf204e5fafd0963749d84afc561892".into(), branch: "main".into() };

        assert_eq!(Pin::decode(&g.encode()).unwrap(), g);

        assert!(g.is_git() && !o.is_git());

    }

    #[test]

    fn modules_files() {

        let text = "[libs/sub]\nurl = ../sub\nbookmark = main\n\n[vendor/x]\nurl = https://example.org/x.git\nkind = git\nbranch = trunk\n";

        let m = Modules::parse(text);

        assert_eq!(m.entries["libs/sub"], Module { url: "../sub".into(), bookmark: Some("main".into()), git: false });

        assert_eq!(m.entries["vendor/x"], Module { url: "https://example.org/x.git".into(), bookmark: Some("trunk".into()), git: true });

        assert_eq!(Modules::parse(&m.to_text()), m);

        let gm = "[submodule \"rstar-api\"]\n\tpath = rstar-api\n\turl = https://github.com/x/rstar-api.git\n[submodule \"c\"]\n\tpath = cstar-api\n\turl = https://github.com/x/cstar-api.git\n\tbranch = dev\n";

        let g = Modules::from_gitmodules(gm);

        assert_eq!(g.entries.len(), 2);

        assert!(g.entries["rstar-api"].git && g.entries["rstar-api"].bookmark.is_none());

        assert_eq!(g.entries["cstar-api"].bookmark.as_deref(), Some("dev"));

        assert!(g.to_gitmodules().contains("[submodule \"cstar-api\"]") && g.to_gitmodules().contains("branch = dev"));

    }

}