//! Page-ready views of a repository, computed from `oxy-core` alone (hub

//! spec §1.4). Nothing here knows about HTTP or templates; every function

//! takes an open `Repo` and returns plain data.

use super::{RepoError, StateCache};

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

use oxy_core::objects::{Change, NodeKind};

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

use oxy_core::state::{FileContent, Snapshot};

use oxy_core::tree::TreeConflict;

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

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

fn fail(msg: impl Into<String>) -> RepoError {

    RepoError::Oxy(oxy_core::repo::RepoError::Msg(msg.into()))

}

// ------------------------------------------------------------------ refs

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

pub enum RefKind {

    Bookmark,

    Tag,

    Change,

}

/// What a `{ref}` path segment resolved to.

#[derive(Clone, Debug)]

pub struct RefTarget {

    /// The name as given (bookmark, tag) or the full hash.

    pub label: String,

    pub kind: RefKind,

    pub heads: Vec<ChangeHash>,

}

/// Resolve a bookmark name, a tag name, or a change hash prefix.

pub fn resolve(repo: &Repo, cache: &StateCache, spec: &str) -> Result<RefTarget> {

    let view = repo.view()?;

    if let Some(heads) = view.bookmarks.get(spec).map(|st| repo.store().get_state(st).map(|s| s.heads)).transpose()? {

        return Ok(RefTarget { label: spec.into(), kind: RefKind::Bookmark, heads });

    }

    if let Some(heads) = repo.tag_heads(spec)? {

        return Ok(RefTarget { label: spec.into(), kind: RefKind::Tag, heads });

    }

    let hash = resolve_change(repo, cache, spec)?;

    Ok(RefTarget { label: hash.to_hex(), kind: RefKind::Change, heads: vec![hash] })

}

/// A change by full hash or unique hex prefix, searched over every

/// bookmark's state.

pub fn resolve_change(repo: &Repo, cache: &StateCache, spec: &str) -> Result<ChangeHash> {

    let spec = spec.trim_start_matches('#');

    if spec.len() < 4 || !spec.chars().all(|c| c.is_ascii_hexdigit()) {

        return Err(fail(format!("{spec:?} is not a change")));

    }

    if let Some(h) = ChangeHash::from_hex(spec) {

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

            return Ok(h);

        }

    }

    let heads = all_heads(repo)?;

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

    let matches: Vec<ChangeHash> = loaded.state.changes().map(|(h, _)| *h).filter(|h| h.starts_with_hex(spec)).collect();

    match matches.len() {

        1 => Ok(matches[0]),

        0 => Err(fail(format!("no change matches {spec:?}"))),

        _ => Err(fail(format!("{spec:?} is ambiguous"))),

    }

}

/// The heads of every bookmark, deduplicated.

pub fn all_heads(repo: &Repo) -> Result<Vec<ChangeHash>> {

    let mut set = BTreeSet::new();

    for b in repo.bookmarks()? {

        set.extend(b.heads);

    }

    Ok(set.into_iter().collect())

}

// ---------------------------------------------------------------- authors

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

pub struct AuthorView {

    pub name: String,

    pub email: String,

    pub key: String,

    /// True when the key is not an identity the store knows.

    pub unknown: bool,

    /// The hub account the key is linked to, filled by the web layer.

    pub account: Option<String>,

}

pub fn author(repo: &Repo, key: &KeyId, message: &str) -> AuthorView {

    if key.is_zero() {

        // Imported from Git: the trailer carries the author.

        let line = message.lines().rev().find_map(|l| l.strip_prefix("Git-Author: ")).unwrap_or("unknown");

        let (name, email) = match line.split_once('<') {

            Some((n, e)) => (n.trim().to_string(), e.trim_end_matches('>').trim().to_string()),

            None => (line.trim().to_string(), String::new()),

        };

        return AuthorView { name, email, key: String::new(), unknown: true, account: None };

    }

    match repo.store().get_identity(key) {

        Ok(id) => AuthorView { name: id.name, email: id.email, key: key.to_hex(), unknown: false, account: None },

        Err(_) => AuthorView { name: key.short(12), email: String::new(), key: key.to_hex(), unknown: true, account: None },

    }

}

// ---------------------------------------------------------------- changes

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

pub enum SigView {

    Unsigned,

    Valid { key: String, name: String, sealed: bool, revoked: bool },

    Invalid(String),

}

impl SigView {

    pub fn glyph(&self) -> &'static str {

        match self {

            SigView::Unsigned => "○",

            SigView::Valid { revoked: true, .. } => "⊘",

            SigView::Valid { sealed: true, .. } => "◈",

            SigView::Valid { .. } => "✔",

            SigView::Invalid(_) => "✘",

        }

    }

    pub fn class(&self) -> &'static str {

        match self {

            SigView::Unsigned => "sig-unsigned",

            SigView::Valid { revoked: true, .. } => "sig-revoked",

            SigView::Valid { .. } => "sig-valid",

            SigView::Invalid(_) => "sig-invalid",

        }

    }

    pub fn title(&self) -> String {

        match self {

            SigView::Unsigned => "unsigned".into(),

            SigView::Valid { name, sealed: true, revoked: false, .. } => format!("sealed by {name}"),

            SigView::Valid { name, revoked: true, .. } => format!("signed by {name}, key revoked"),

            SigView::Valid { name, .. } => format!("signed by {name}"),

            SigView::Invalid(why) => format!("INVALID: {why}"),

        }

    }

}

pub fn signature(repo: &Repo, hash: &ChangeHash) -> SigView {

    match repo.verify_change(hash) {

        Ok(SignatureStatus::Unsigned) => SigView::Unsigned,

        Ok(SignatureStatus::Valid { key, name, sealed, revoked, .. }) => SigView::Valid { key: key.to_hex(), name, sealed, revoked },

        Ok(SignatureStatus::Invalid(why)) => SigView::Invalid(why),

        Err(e) => SigView::Invalid(e.to_string()),

    }

}

/// One change as history rows and change pages show it.

#[derive(Clone, Debug)]

pub struct ChangeView {

    pub hash: String,

    pub short: String,

    pub title: String,

    pub body: String,

    pub author: AuthorView,

    pub when_ms: u64,

    pub deps: Vec<String>,

    pub head: bool,

    pub resolution: bool,

    pub signature: SigView,

    /// Bookmarks and tags whose state has this change as a head.

    pub labels: Vec<Label>,

}

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

pub struct Label {

    pub name: String,

    pub kind: RefKind,

}

pub fn split_message(message: &str) -> (String, String) {

    let mut lines = message.lines();

    let title = lines.next().unwrap_or("").trim().to_string();

    let body = lines.collect::<Vec<_>>().join("\n").trim().to_string();

    (title, body)

}

/// Every bookmark and tag head, for labelling rows.

pub fn head_labels(repo: &Repo) -> Result<HashMap<ChangeHash, Vec<Label>>> {

    let mut out: HashMap<ChangeHash, Vec<Label>> = HashMap::new();

    for b in repo.bookmarks()? {

        for h in b.heads {

            out.entry(h).or_default().push(Label { name: b.name.clone(), kind: RefKind::Bookmark });

        }

    }

    for t in repo.tags()? {

        for h in t.heads {

            out.entry(h).or_default().push(Label { name: t.name.clone(), kind: RefKind::Tag });

        }

    }

    Ok(out)

}

fn change_view(

    repo: &Repo,

    hash: &ChangeHash,

    meta: &oxy_core::state::ChangeMeta,

    head: bool,

    labels: &HashMap<ChangeHash, Vec<Label>>,

) -> ChangeView {

    let (title, body) = split_message(&meta.message);

    ChangeView {

        hash: hash.to_hex(),

        short: hash.short(12),

        title,

        body,

        author: author(repo, &meta.author, &meta.message),

        when_ms: meta.hlc.wall_ms,

        deps: meta.deps.iter().map(|d| d.to_hex()).collect(),

        head,

        resolution: meta.kind == oxy_core::objects::ChangeKind::Resolution,

        signature: signature(repo, hash),

        labels: labels.get(hash).cloned().unwrap_or_default(),

    }

}

// ---------------------------------------------------------------- history

#[derive(Clone, Debug)]

pub struct History {

    pub target: RefTarget,

    pub entries: Vec<ChangeView>,

    pub total: usize,

    pub offset: usize,

    pub has_more: bool,

    pub path: Option<String>,

}

/// A window of the history of a state, newest first.

pub fn history(repo: &Repo, cache: &StateCache, target: RefTarget, path: Option<&str>, offset: usize, limit: usize) -> Result<History> {

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

    let head_set: BTreeSet<ChangeHash> = loaded.state.heads().into_iter().collect();

    let mut entries: Vec<(ChangeHash, oxy_core::state::ChangeMeta)> = match path {

        Some(p) => {

            let Some(node) = loaded.snapshot.files.get(p).map(|f| f.node) else { return Err(fail(format!("{p} is not in that state"))) };

            loaded

                .state

                .changes()

                .filter(|(h, _)| {

                    repo.store()

                        .get_change(h)

                        .map(|c| c.tree_ops.iter().any(|o| o.node() == node) || c.edits.iter().any(|x| x.node() == node))

                        .unwrap_or(false)

                })

                .map(|(h, m)| (*h, m.clone()))

                .collect()

        }

        None => loaded.state.changes().map(|(h, m)| (*h, m.clone())).collect(),

    };

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

    let total = entries.len();

    let labels = head_labels(repo)?;

    let window: Vec<ChangeView> =

        entries.iter().skip(offset).take(limit).map(|(h, m)| change_view(repo, h, m, head_set.contains(h), &labels)).collect();

    Ok(History { target, entries: window, total, offset, has_more: offset + limit < total, path: path.map(String::from) })

}

// ----------------------------------------------------------------- change

#[derive(Clone, Debug)]

pub struct ChangeDetail {

    pub view: ChangeView,

    pub dependents: Vec<ChangeView>,

    pub deps: Vec<ChangeView>,

    pub files: Vec<FileDiff>,

    /// Base content of each modified file, for context lines.

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

    pub in_bookmarks: Vec<String>,

    pub in_tags: Vec<String>,

    pub atoms: usize,

    pub tree_ops: usize,

}

pub fn change(repo: &Repo, cache: &StateCache, hash: &ChangeHash) -> Result<ChangeDetail> {

    let c: Change = repo.store().get_change(hash)?;

    let labels = head_labels(repo)?;

    let heads = all_heads(repo)?;

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

    let state = &loaded.state;

    let is_head = state.heads().contains(hash);

    let meta = oxy_core::state::ChangeMeta::of(&c);

    let view = change_view(repo, hash, &meta, is_head, &labels);

    let deps = c.deps.iter().filter_map(|d| state.get(d).map(|m| change_view(repo, d, m, state.heads().contains(d), &labels))).collect();

    let mut dependents: Vec<ChangeView> = state

        .changes()

        .filter(|(_, m)| m.deps.contains(hash))

        .map(|(h, m)| change_view(repo, h, m, state.heads().contains(h), &labels))

        .collect();

    dependents.sort_by_key(|c| std::cmp::Reverse(c.when_ms));

    let base = cache.load(repo, &c.deps)?;

    let files = crate::render::diff::change_files(&c, &base.state, &base.snapshot);

    let base_snapshot = &base.snapshot;

    let mut bases = BTreeMap::new();

    for f in &files {

        let old = f.from.as_deref().unwrap_or(&f.path);

        if let Some(FileContent::Text { bytes, .. }) = base_snapshot.files.get(old).map(|s| &s.content) {

            bases.insert(f.path.clone(), bytes.clone());

        }

    }

    let mut in_bookmarks = Vec::new();

    for b in repo.bookmarks()? {

        if cache.load(repo, &b.heads)?.state.contains(hash) {

            in_bookmarks.push(b.name);

        }

    }

    let mut in_tags = Vec::new();

    for t in repo.tags()? {

        if cache.load(repo, &t.heads)?.state.contains(hash) {

            in_tags.push(t.name);

        }

    }

    Ok(ChangeDetail { view, dependents, deps, files, bases, in_bookmarks, in_tags, atoms: c.edits.len(), tree_ops: c.tree_ops.len() })

}

// ------------------------------------------------------------------- tree

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

pub enum EntryKind {

    Dir,

    File,

    Symlink,

    Subrepo,

}

#[derive(Clone, Debug)]

pub struct Entry {

    pub name: String,

    pub path: String,

    pub kind: EntryKind,

    pub exec: bool,

    pub size: Option<u64>,

    pub conflicted: bool,

}

#[derive(Clone, Debug)]

pub struct Tree {

    pub target: RefTarget,

    pub path: String,

    pub entries: Vec<Entry>,

    /// `(name, path)` from the root down to this directory.

    pub crumbs: Vec<(String, String)>,

    pub readme: Option<Readme>,

}

#[derive(Clone, Debug)]

pub struct Readme {

    pub path: String,

    pub text: String,

}

pub fn crumbs(path: &str) -> Vec<(String, String)> {

    let mut out = Vec::new();

    let mut so_far = String::new();

    for part in path.split('/').filter(|p| !p.is_empty()) {

        if !so_far.is_empty() {

            so_far.push('/');

        }

        so_far.push_str(part);

        out.push((part.to_string(), so_far.clone()));

    }

    out

}

fn entry_of(path: &str, name: &str, f: &oxy_core::state::FileState) -> Entry {

    let kind = match f.kind {

        NodeKind::Dir => EntryKind::Dir,

        NodeKind::File => EntryKind::File,

        NodeKind::Symlink => EntryKind::Symlink,

        NodeKind::Subrepo => EntryKind::Subrepo,

    };

    let size = match &f.content {

        FileContent::Text { bytes, .. } => Some(bytes.len() as u64),

        _ => None,

    };

    Entry { name: name.to_string(), path: path.to_string(), kind, exec: f.mode.exec, size, conflicted: f.is_conflicted() }

}

/// The entries directly under `dir` (`""` for the root).

pub fn tree(repo: &Repo, cache: &StateCache, target: RefTarget, dir: &str) -> Result<Tree> {

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

    tree_of(repo, target, &loaded.snapshot, dir)

}

pub fn tree_of(_repo: &Repo, target: RefTarget, snapshot: &Snapshot, dir: &str) -> Result<Tree> {

    let dir = dir.trim_matches('/');

    if !dir.is_empty() {

        match snapshot.files.get(dir) {

            Some(f) if f.kind == NodeKind::Dir => {}

            _ => return Err(RepoError::NotFound),

        }

    }

    let prefix = if dir.is_empty() { String::new() } else { format!("{dir}/") };

    let mut entries: Vec<Entry> = snapshot

        .files

        .iter()

        .filter(|(p, _)| p.starts_with(&prefix) && !p[prefix.len()..].contains('/'))

        .map(|(p, f)| entry_of(p, &p[prefix.len()..], f))

        .collect();

    entries.sort_by(|a, b| {

        (a.kind != EntryKind::Dir).cmp(&(b.kind != EntryKind::Dir)).then_with(|| a.name.to_lowercase().cmp(&b.name.to_lowercase()))

    });

    let readme = entries

        .iter()

        .find(|e| {

            e.kind == EntryKind::File && matches!(e.name.to_lowercase().as_str(), "readme.md" | "readme" | "readme.txt" | "readme.markdown")

        })

        .and_then(|e| match &snapshot.files.get(&e.path)?.content {

            FileContent::Text { bytes, .. } => Some(Readme { path: e.path.clone(), text: String::from_utf8_lossy(bytes).into_owned() }),

            _ => None,

        });

    Ok(Tree { target, path: dir.to_string(), entries, crumbs: crumbs(dir), readme })

}

// ------------------------------------------------------------------- file

#[derive(Clone, Debug)]

pub enum FileBody {

    Text(String),

    Binary,

    TooLarge,

}

#[derive(Clone, Debug)]

pub struct FileView {

    pub target: RefTarget,

    pub path: String,

    pub name: String,

    pub crumbs: Vec<(String, String)>,

    pub kind: EntryKind,

    pub exec: bool,

    pub size: u64,

    pub body: FileBody,

    pub conflicted: bool,

    /// Raw bytes, for the `?plain=1` response and images.

    pub bytes: Vec<u8>,

    pub last_change: Option<ChangeView>,

}

pub fn file(repo: &Repo, cache: &StateCache, target: RefTarget, path: &str, render_limit: u64) -> Result<FileView> {

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

    let snapshot = &loaded.snapshot;

    let path = path.trim_matches('/');

    let Some(f) = snapshot.files.get(path) else { return Err(RepoError::NotFound) };

    let (kind, bytes) = match (&f.kind, &f.content) {

        (NodeKind::Dir, _) => return Err(RepoError::NotFound),

        (NodeKind::Symlink, FileContent::Text { bytes, .. }) => (EntryKind::Symlink, bytes.clone()),

        (NodeKind::Subrepo, FileContent::Text { bytes, .. }) => (EntryKind::Subrepo, bytes.clone()),

        (_, FileContent::Text { bytes, .. }) => (EntryKind::File, bytes.clone()),

        (_, FileContent::Opaque { blobs }) => {

            let bytes = match blobs.first() {

                Some(b) => repo.read_blob(b)?,