//! 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 {

    /// Whether two pins name the same state: the same repository at the

    /// same heads, in any order, or the same Git commit. The bookmark or

    /// branch each names does not count (#147): a subrepo at its pinned

    /// state is at it whatever bookmark it sits on.

    pub fn same_state(&self, other: &Pin) -> bool {

        match (self, other) {

            (

                Pin::Oxy {

                    repo: r1,

                    heads: h1,

                    ..

                },

                Pin::Oxy {

                    repo: r2,

                    heads: h2,

                    ..

                },

            ) => {

                let (mut a, mut b) = (h1.clone(), h2.clone());

                a.sort();

                a.dedup();

                b.sort();

                b.dedup();

                r1 == r2 && a == b

            }

            (Pin::Git { sha: a, .. }, Pin::Git { sha: b, .. }) => a == b,

            _ => false,

        }

    }

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

        );

    }

}