//! Proposals (hub spec §7): the projected state, its diff and conflicts,

//! atom anchors for comments, seal-backed approvals, code owners and the

//! landing requirements. Pure functions over `oxy-core`, run under the

//! repository lock.

use super::cache::{Loaded, StateCache};

use super::view::{self, ChangeView, ConflictView, RefTarget};

use super::RepoError;

use oxy_core::hash::{ChangeHash, KeyId, ObjectRef};

use oxy_core::objects::StateObject;

use oxy_core::repo::{FileDiff, Repo};

use oxy_core::state::FileContent;

use std::collections::{BTreeMap, BTreeSet, HashMap};

use std::sync::Arc;

type Result<T> = std::result::Result<T, RepoError>;

/// Where a proposal's changes come from, resolved.

pub enum Source<'a> {

    /// Heads of a bookmark of this repository.

    Bookmark(Vec<ChangeHash>),

    /// A fork: its repository directory and the bookmark's heads there.

    Fork {

        fork: &'a Repo,

        heads: Vec<ChangeHash>,

    },

    Changes(Vec<ChangeHash>),

}

/// The projected state of a proposal and what the pages show of it.

pub struct Projection {

    pub target_heads: Vec<ChangeHash>,

    pub target_state: ObjectRef,

    pub heads: Vec<ChangeHash>,

    pub state: ObjectRef,

    /// The changes the proposal adds, dependency order.

    pub changes: Vec<ChangeView>,

    pub hashes: Vec<ChangeHash>,

    pub conflicted: bool,

    pub conflicts: Vec<ConflictView>,

    pub files: Vec<FileDiff>,

    pub bases: BTreeMap<String, Vec<u8>>,

    pub loaded: Arc<Loaded>,

}

/// Compute the projection: the union of the target's heads and the

/// source, with the source's changes brought into this store when they

/// come from a fork.

pub fn project(repo: &Repo, cache: &StateCache, target: &str, source: Source<'_>) -> Result<Projection> {

    let target_heads = repo.bookmarks()?.into_iter().find(|b| b.name == target).map(|b| b.heads).unwrap_or_default();

    let candidate: Vec<ChangeHash> = match &source {

        Source::Bookmark(heads) => heads.clone(),

        Source::Changes(hashes) => hashes.clone(),

        Source::Fork { fork, heads } => {

            // Objects are content addressed: copy what is missing straight from the fork's store.

            let fork_state = fork.load_state(heads)?;

            let missing: Vec<ChangeHash> = fork_state.changes().map(|(h, _)| *h).filter(|h| !repo.store().has(h)).collect();

            if !missing.is_empty() {

                let bundle = fork.bundle_for(&missing)?;

                repo.import_bundle(&bundle, repo.current_policy()?.is_some())?;

            }

            heads.clone()

        }

    };

    for h in &candidate {

        if !repo.store().has(h) {

            return Err(RepoError::Oxy(oxy_core::repo::RepoError::Msg(format!("change {} is not in this repository", h.short(12)))));

        }

    }

    let mut union: Vec<ChangeHash> = target_heads.clone();

    union.extend(candidate.iter().copied());

    let loaded = cache.load(repo, &union)?;

    let heads = loaded.state.heads();

    let target_loaded = cache.load(repo, &target_heads)?;

    let labels = view::head_labels(repo)?;

    let head_set: BTreeSet<ChangeHash> = heads.iter().copied().collect();

    let mut added: Vec<(ChangeHash, oxy_core::state::ChangeMeta)> =

        loaded.state.changes().filter(|(h, _)| !target_loaded.state.contains(h)).map(|(h, m)| (*h, m.clone())).collect();

    // Dependency order, oldest first: a change after everything it depends on.

    added.sort_by(|a, b| a.1.hlc.cmp(&b.1.hlc).then(a.0.cmp(&b.0)));

    let hashes: Vec<ChangeHash> = added.iter().map(|(h, _)| *h).collect();

    let changes: Vec<ChangeView> = added.iter().map(|(h, m)| view::change_view_pub(repo, h, m, head_set.contains(h), &labels)).collect();

    let conflicted = loaded.snapshot.is_conflicted();

    let conflicts = if conflicted { view::conflicts_in(repo, &loaded, "projected") } else { vec![] };

    let (files, bases) = crate::render::diff::snapshot_diff(&target_loaded.snapshot, &loaded.snapshot);

    let state = StateObject::new(heads.clone()).hash();

    let target_state = StateObject::new(target_heads.clone()).hash();

    Ok(Projection { target_heads, target_state, heads, state, changes, hashes, conflicted, conflicts, files, bases, loaded })

}

/// The atom at line `new_no` (1-based) of `path` in the projected state.

pub fn atom_at(loaded: &Loaded, path: &str, new_no: usize) -> Option<(ChangeHash, u32)> {

    let f = loaded.snapshot.files.get(path)?;

    if !matches!(f.content, FileContent::Text { .. }) {

        return None;

    }

    let lines = loaded.state.live_lines(&f.node);

    lines.get(new_no.checked_sub(1)?).map(|((h, i), _)| (*h, *i))

}

/// Every live line of `path` as its atom, in order: `atom_at` for a whole

/// file at once (computing them per line is quadratic in the file's length).

pub fn atoms_of(loaded: &Loaded, path: &str) -> Option<Vec<(ChangeHash, u32)>> {

    let f = loaded.snapshot.files.get(path)?;

    if !matches!(f.content, FileContent::Text { .. }) {

        return None;

    }

    Some(loaded.state.live_lines(&f.node).iter().map(|((h, i), _)| (*h, *i)).collect())

}

/// The current line (1-based) of an atom in `path`, if it is still live.

pub fn line_of(loaded: &Loaded, path: &str, atom: (ChangeHash, u32)) -> Option<usize> {

    let f = loaded.snapshot.files.get(path)?;

    let lines = loaded.state.live_lines(&f.node);

    lines.iter().position(|((h, i), _)| (*h, *i) == atom).map(|p| p + 1)

}

/// Keys that have sealed every one of `hashes` with a valid seal.

pub fn sealing_keys(repo: &Repo, hashes: &[ChangeHash]) -> Result<Vec<KeyId>> {

    if hashes.is_empty() {

        return Ok(vec![]);

    }

    let mut counts: HashMap<KeyId, usize> = HashMap::new();

    for h in hashes {

        let mut keys_here: BTreeSet<KeyId> = BTreeSet::new();

        for seal_ref in repo.store().seals_for(h)? {

            let attest = repo.store().get_attest(&seal_ref)?;

            let oxy_core::attest::AttestBody::Seal { hashes: covered } = &attest.body else { continue };

            if !covered.contains(h) {

                continue;

            }

            for sig in repo.store().signatures(&seal_ref)? {

                if let Ok(id) = repo.store().get_identity(&sig.key) {

                    if oxy_core::identity::verify(&id, &sig, oxy_core::identity::Domain::Attest, &seal_ref).is_ok() {

                        keys_here.insert(sig.key);

                    }

                }

            }

        }

        for k in keys_here {

            *counts.entry(k).or_default() += 1;

        }

    }

    Ok(counts.into_iter().filter(|(_, n)| *n == hashes.len()).map(|(k, _)| k).collect())

}

/// `.oxyowners` in the target state (CODEOWNERS syntax): the owners of

/// every path the proposal touches.

pub fn owners_for(target: &Loaded, touched: &[String]) -> Vec<String> {

    let Some(f) = target.snapshot.files.get(".oxyowners") else { return vec![] };

    let FileContent::Text { bytes, .. } = &f.content else { return vec![] };

    let text = String::from_utf8_lossy(bytes);

    let rules: Vec<(String, Vec<String>)> = text

        .lines()

        .map(str::trim)

        .filter(|l| !l.is_empty() && !l.starts_with('#'))

        .filter_map(|l| {

            let mut parts = l.split_whitespace();

            let pattern = parts.next()?.to_string();

            let owners: Vec<String> = parts.map(|o| o.trim_start_matches('@').to_string()).collect();

            Some((pattern, owners))

        })

        .collect();

    let mut out: BTreeSet<String> = BTreeSet::new();

    for path in touched {

        // The last matching rule wins, as in CODEOWNERS.

        if let Some((_, owners)) = rules.iter().rev().find(|(pattern, _)| owner_pattern_matches(pattern, path)) {

            out.extend(owners.iter().cloned());

        }

    }

    out.into_iter().collect()

}

fn owner_pattern_matches(pattern: &str, path: &str) -> bool {

    let p = pattern.trim_start_matches('/');

    if p == "*" {

        return true;

    }

    if let Some(dir) = p.strip_suffix('/') {

        return path.starts_with(&format!("{dir}/"));

    }

    if let Some(ext) = p.strip_prefix("*.") {

        return path.ends_with(&format!(".{ext}"));

    }

    if let Some(prefix) = p.strip_suffix("/*") {

        return path.strip_prefix(&format!("{prefix}/")).is_some_and(|rest| !rest.contains('/'));

    }

    if let Some(prefix) = p.strip_suffix("/**") {

        return path.starts_with(&format!("{prefix}/"));

    }

    path == p || path.starts_with(&format!("{p}/"))

}

/// The union of two head lists as a state object reference, for landing.

pub fn state_ref(heads: &[ChangeHash]) -> ObjectRef {

    StateObject::new(heads.to_vec()).hash()

}

/// A proposal's changes as a `RefTarget`, for browsing its tree.

pub fn target_of(label: &str, heads: &[ChangeHash]) -> RefTarget {

    RefTarget { label: label.into(), kind: view::RefKind::Change, heads: heads.to_vec() }

}

#[cfg(test)]

mod tests {

    use super::*;

    #[test]

    fn owner_patterns() {

        assert!(owner_pattern_matches("*", "any/thing"));

        assert!(owner_pattern_matches("docs/", "docs/spec.md"));

        assert!(!owner_pattern_matches("docs/", "src/docs.rs"));

        assert!(owner_pattern_matches("*.rs", "src/main.rs"));

        assert!(owner_pattern_matches("src/*", "src/main.rs"));

        assert!(!owner_pattern_matches("src/*", "src/a/b.rs"));

        assert!(owner_pattern_matches("crates/**", "crates/hub/src/lib.rs"));

        assert!(owner_pattern_matches("Cargo.toml", "Cargo.toml"));

    }

}