//! Repository overview, tree, file, raw and blame pages.

use super::{filters, lookup, Error, Page, RepoShell, Shell};

use crate::auth::Viewer;

use crate::render::{self, highlight};

use crate::repos::view::{self, EntryKind, FileBody};

use crate::Shared;

use askama::Template;

use axum::extract::{Path, Query, State};

use axum::response::{IntoResponse, Response};

use serde::Deserialize;

use std::collections::HashMap;

#[derive(Template)]

#[template(path = "overview.html")]

pub struct OverviewPage {

    shell: Shell,

    repo: RepoShell,

    o: view::Overview,

    readme_html: Option<String>,

    watching: bool,

    latest_release: Option<crate::db::releases::Release>,

    /// Set while the repository has no changes (hub spec §6).

    quickstart: Option<Quickstart>,

    fork: super::forks::ForkInfo,

    starred: bool,

    stars: i64,

    watchers: i64,

    topics: Vec<String>,

    /// Repositories that pin this one as a subrepo, and how far behind

    /// each is (Diffusion, #148).

    used_by: Vec<crate::diffusion::Consumer>,

}

/// A remote name from the hub's host: its first label when that is a

/// plain lowercase word (`earth` for `https://earth.example.org:7343`),

/// otherwise `hub`.

fn remote_name(base_url: &str) -> String {

    let host = base_url.split("://").nth(1).unwrap_or("").split(['/', ':']).next().unwrap_or("");

    let first = host.split('.').next().unwrap_or("");

    let plain = first.len() <= 20

        && first.starts_with(|c: char| c.is_ascii_lowercase())

        && first.chars().all(|c| c.is_ascii_lowercase() || c.is_ascii_digit());

    if plain && first != "www" && first != "localhost" {

        first.to_string()

    } else {

        "hub".to_string()

    }

}

/// The commands that get a first push into an empty repository, filled

/// in for this hub and this repository.

pub struct Quickstart {

    /// A remote name taken from the hub's host name (`earth` for

    /// `earth.example.org`), `hub` when that is not a plain word.

    pub remote: String,

    /// Where to download the hub's certificate, when it is self-signed.

    pub ca_url: Option<String>,

    /// Where the commands save that certificate.

    pub ca_file: String,

    /// Whether the viewer may push here.

    pub can_push: bool,

}

impl Quickstart {

    pub fn new(app: &Shared, can_push: bool) -> Quickstart {

        let base = app.config.base_url().trim_end_matches('/').to_string();

        let remote = remote_name(&base);

        let ca_file = format!("~/.config/oxy/{remote}-ca.pem");

        let ca_url = app.config.tls.self_signed.then(|| format!("{base}/.well-known/oxyhub-ca.pem"));

        Quickstart { remote, ca_url, ca_file, can_push }

    }

    /// Connect a checkout to this repository and push; the token line

    /// stays a placeholder so no secret is ever printed.

    pub fn connect(&self, clone_url: &str) -> String {

        let r = &self.remote;

        let mut s = format!("oxy remote add {r} {clone_url}\n");

        if let Some(ca) = &self.ca_url {

            s += &format!("curl -fsSL {ca} -o {}\n", self.ca_file);

            s += &format!("oxy config remote.{r}.ca {}\n", self.ca_file);

        }

        s += &format!("oxy config remote.{r}.token YOUR-TOKEN\n");

        s += &format!("oxy push {r}");

        s

    }

    /// Start a repository from nothing.

    pub fn fresh(&self, name: &str) -> String {

        format!("mkdir {name} && cd {name}\noxy init\necho \"# {name}\" > README.md\noxy commit -m \"First change\"")

    }

    /// Bring a Git branch across.

    pub fn git_import(&self, name: &str) -> String {

        format!("oxy git import --branch main path/to/git-checkout {name}\ncd {name}")

    }

}

pub async fn overview(

    State(app): State<Shared>,

    viewer: Viewer,

    Path((owner, name)): Path<(String, String)>,

) -> Result<Page<OverviewPage>, Error> {

    let shell = Shell::new(&app, &format!("/{owner}/{name}"), &viewer);

    let (repo, row, role) = lookup(&app, &shell, &viewer, &owner, &name).await?;

    let default = row.default_bookmark.clone();

    let mut o =

        app.repos.read(&repo, move |r, cache| view::overview(r, cache, &default)).await.map_err(|e| Error::from_repo(shell.clone(), e))?;

    // Contributors link to the hub accounts their keys are linked to.

    let linked: HashMap<String, String> = crate::db::accounts::identity_accounts(&app.db).await.unwrap_or_default().into_iter().collect();

    for c in &mut o.contributors {

        c.account = linked.get(&c.key).cloned();

    }

    // One row per account: a person's keys over time are one contributor,

    // their agents' shares summed beneath (as `oxy log` shows via).

    let mut merged: Vec<view::Contributor> = Vec::new();

    for c in std::mem::take(&mut o.contributors) {

        match c.account.as_ref().and_then(|a| merged.iter_mut().find(|m| m.account.as_deref() == Some(a))) {

            Some(m) => {

                m.changes += c.changes;

                for (who, n) in c.via {

                    match m.via.iter_mut().find(|(w, _)| *w == who) {

                        Some((_, k)) => *k += n,

                        None => m.via.push((who, n)),

                    }

                }

                m.via.sort_by(|a, b| b.1.cmp(&a.1).then(a.0.cmp(&b.0)));

            }

            None => merged.push(c),

        }

    }

    merged.sort_by(|a, b| b.changes.cmp(&a.changes).then(a.name.cmp(&b.name)));

    o.contributors = merged;

    let rs = RepoShell::new(&app, &row, "code").with_role(role);

    let readme_html = o.readme_html(&rs, &o.tree.target.label);

    let watching = match viewer.account() {

        Some(a) => crate::db::notify::watching(&app.db, a.id, row.id).await.unwrap_or(false),

        None => false,

    };

    let latest_release = crate::db::releases::latest(&app.db, row.id).await.ok().flatten();

    let quickstart = (o.changes == 0).then(|| Quickstart::new(&app, rs.can(crate::auth::Access::Write)));

    let fork = super::forks::info(&app, &shell, &viewer, &row).await;

    let starred = match viewer.account() {

        Some(a) => crate::db::repos::starred(&app.db, a.id, row.id).await.unwrap_or(false),

        None => false,

    };

    let (stars, watchers) = crate::db::repos::counts(&app.db, row.id).await.unwrap_or((0, 0));

    let topics = row.topic_list().into_iter().map(String::from).collect();

    let used_by = crate::diffusion::consumers(&app, &row, viewer.account()).await.unwrap_or_default();

    Ok(Page(OverviewPage {

        shell,

        repo: rs,

        o,

        readme_html,

        watching,

        latest_release,

        quickstart,

        fork,

        starred,

        stars,

        watchers,

        topics,

        used_by,

    }))

}

impl view::Overview {

    fn readme_html(&self, rs: &RepoShell, r: &str) -> Option<String> {

        self.tree.readme.as_ref().map(|md| {

            let dir = md.path.rsplit_once('/').map(|(d, _)| format!("{d}/")).unwrap_or_default();

            render::markdown::render(&md.text, &format!("{}/file/{r}/{dir}", rs.url), &format!("{}/raw/{r}/{dir}", rs.url))

        })

    }

}

#[derive(Template)]

#[template(path = "tree.html")]

pub struct TreePage {

    shell: Shell,

    repo: RepoShell,

    t: view::Tree,

    readme_html: Option<String>,

}

pub async fn tree_root(

    State(app): State<Shared>,

    viewer: Viewer,

    Path((owner, name, r)): Path<(String, String, String)>,

) -> Result<Page<TreePage>, Error> {

    tree(State(app), viewer, Path((owner, name, r, String::new()))).await

}

pub async fn tree(

    State(app): State<Shared>,

    viewer: Viewer,

    Path((owner, name, r, path)): Path<(String, String, String, String)>,

) -> Result<Page<TreePage>, Error> {

    let shell = Shell::new(&app, &format!("/{owner}/{name}/tree/{r}/{path}"), &viewer);

    let (repo, row, role) = lookup(&app, &shell, &viewer, &owner, &name).await?;

    let (spec, dir) = (r.clone(), path.clone());

    let t = app

        .repos

        .read(&repo, move |repo, cache| {

            let target = view::resolve(repo, cache, &spec)?;

            view::tree(repo, cache, target, &dir)

        })

        .await

        .map_err(|e| Error::from_repo(shell.clone(), e))?;

    let rs = RepoShell::new(&app, &row, "code").with_role(role);

    let readme_html = t.readme.as_ref().map(|md| {

        let dir = md.path.rsplit_once('/').map(|(d, _)| format!("{d}/")).unwrap_or_default();

        render::markdown::render(&md.text, &format!("{}/file/{r}/{dir}", rs.url), &format!("{}/raw/{r}/{dir}", rs.url))

    });

    Ok(Page(TreePage { shell, repo: rs, t, readme_html }))

}

#[derive(Deserialize)]

pub struct FileQuery {

    plain: Option<String>,

    blame: Option<String>,

    /// `source` shows a Markdown file's text instead of rendering it.

    view: Option<String>,

}

#[derive(Template)]

#[template(path = "file.html")]

pub struct FilePage {

    shell: Shell,

    repo: RepoShell,

    f: view::FileView,

    /// Highlighted lines when text.

    lines: Vec<String>,

    language: Option<&'static str>,

    markdown_html: Option<String>,

    is_image: bool,

    is_markdown: bool,

    blame: Option<Vec<BlameRow>>,

    /// The `{ref}` of this state for good (hub spec §6.6).

    permalink: Option<String>,

    /// Functions found in the file, each linking to its history.

    functions: Vec<crate::repos::functions::Function>,

}

/// A blame gutter entry: shown only on the first line of a run.

pub struct BlameRow {

    pub first: bool,

    pub hash: String,

    pub short: String,

    pub author: String,

    pub when_ms: u64,

    pub run: usize,

    /// 0 (the file's oldest line) to 9 (its newest), for shading.

    pub age: u8,

    /// The state address of the change's dependencies.

    pub before: Option<String>,

}

/// Shade steps from `when` within the file's span of times.

fn age_step(when: u64, oldest: u64, newest: u64) -> u8 {

    if newest <= oldest {

        return 9;

    }

    (((when.saturating_sub(oldest)) as u128 * 9 / (newest - oldest) as u128) as u8).min(9)

}

fn blame_rows(

    lines: &[oxy_core::repo::BlameLine],

    before: &std::collections::HashMap<oxy_core::hash::ChangeHash, Option<String>>,

) -> Vec<BlameRow> {

    let oldest = lines.iter().map(|l| l.when_ms).min().unwrap_or(0);

    let newest = lines.iter().map(|l| l.when_ms).max().unwrap_or(0);

    let mut rows: Vec<BlameRow> = Vec::with_capacity(lines.len());

    let mut i = 0;

    while i < lines.len() {

        let mut run = 1;

        while i + run < lines.len() && lines[i + run].hash == lines[i].hash {

            run += 1;

        }

        for k in 0..run {

            let l = &lines[i + k];

            rows.push(BlameRow {

                first: k == 0,

                hash: l.hash.to_hex(),

                short: l.hash.short(8),

                author: l.author.clone(),

                when_ms: l.when_ms,

                run,

                age: age_step(l.when_ms, oldest, newest),

                before: before.get(&l.hash).cloned().flatten(),

            });

        }

        i += run;

    }

    rows

}

pub async fn file(

    State(app): State<Shared>,

    viewer: Viewer,

    Path((owner, name, r, path)): Path<(String, String, String, String)>,

    Query(q): Query<FileQuery>,

) -> Result<Response, Error> {

    let shell = Shell::new(&app, &format!("/{owner}/{name}/file/{r}/{path}"), &viewer);

    let (repo, row, role) = lookup(&app, &shell, &viewer, &owner, &name).await?;

    if path == super::flow::RUN_LINK && !has_file(&app, &repo, &r, &path).await {

        return Ok(axum::response::Redirect::to(&format!("/{owner}/{name}/flow/at/{r}")).into_response());

    }

    let limit = app.config.limits.render_limit.0;

    if q.plain.is_some() {

        // Bytes only: no last change, sidebar or highlighting to compute.

        let (spec, p) = (r.clone(), path.clone());

        let (file_name, bytes) = app

            .repos

            .read(&repo, move |repo, cache| view::raw(repo, cache, &view::resolve(repo, cache, &spec)?, &p))

            .await

            .map_err(|e| Error::from_repo(shell.clone(), e))?;

        return Ok(super::raw(bytes, &file_name, true));

    }

    let want_blame = q.blame.is_some();

    let (spec, p) = (r.clone(), path.clone());

    let (f, blame) = app

        .repos

        .read(&repo, move |repo, cache| {

            let target = view::resolve(repo, cache, &spec)?;

            if want_blame {

                let b = view::blame(repo, cache, target, &p, limit)?;

                let rows = blame_rows(&b.lines, &b.before);

                Ok((b.file, Some(rows)))

            } else {

                Ok((view::file(repo, cache, target, &p, limit)?, None))

            }

        })

        .await

        .map_err(|e| Error::from_repo(shell.clone(), e))?;

    if q.plain.is_some() {

        return Ok(super::raw(f.bytes, &f.name, true));

    }

    let rs = RepoShell::new(&app, &row, "code").with_role(role);

    let is_image = super::mime_of(&f.name).starts_with("image/");

    let is_markdown = f.name.to_lowercase().ends_with(".md") || f.name.to_lowercase() == "readme";

    let want_source = q.view.as_deref() == Some("source") || blame.is_some();

    let (lines, language, markdown_html) = match &f.body {

        FileBody::Text(text) if !is_image => {

            if is_markdown && !want_source {

                let dir = f.path.rsplit_once('/').map(|(d, _)| format!("{d}/")).unwrap_or_default();

                let (base, raw) = (format!("{}/file/{r}/{dir}", rs.url), format!("{}/raw/{r}/{dir}", rs.url));

                (vec![], highlight::language(&f.path), Some(render::markdown::render(text, &base, &raw)))

            } else {

                (highlight::lines(&f.path, text), highlight::language(&f.path), None)

            }

        }

        _ => (vec![], None, None),

    };

    let permalink = f.target.permalink();

    let functions = match &f.body {

        FileBody::Text(text) if !is_image => crate::repos::functions::functions(&f.path, text),

        _ => vec![],

    };

    Ok(Page(FilePage { shell, repo: rs, f, lines, language, markdown_html, is_image, is_markdown, blame, permalink, functions })

        .into_response())

}

/// Whether `path` is a file in the state `r` names.

async fn has_file(app: &Shared, repo: &crate::repos::RepoName, r: &str, path: &str) -> bool {

    let (spec, p) = (r.to_string(), path.to_string());

    app.repos

        .read(repo, move |repo, cache| {

            let target = view::resolve(repo, cache, &spec)?;

            Ok(cache.load(repo, &target.heads)?.snapshot.files.get(&p).is_some_and(|f| f.kind != oxy_core::objects::NodeKind::Dir))

        })

        .await

        .unwrap_or(false)

}

/// `GET /{owner}/{name}/raw/{ref}/{path}`: a file's bytes (hub spec §6.3),

/// where relative images in rendered Markdown point. `.flow/stamp` is the

/// state stamp of `{ref}` unless a real file is there (§13.2).

pub async fn raw_file(

    State(app): State<Shared>,

    viewer: Viewer,

    Path((owner, name, r, path)): Path<(String, String, String, String)>,

) -> Result<Response, Error> {

    let shell = Shell::new(&app, &format!("/{owner}/{name}/raw/{r}/{path}"), &viewer);

    let (repo, _row, _role) = lookup(&app, &shell, &viewer, &owner, &name).await?;

    if path == super::flow::STAMP_IMAGE && !has_file(&app, &repo, &r, &path).await {

        return Ok(axum::response::Redirect::to(&format!("/{owner}/{name}/flow/stamp/{r}")).into_response());

    }

    let (spec, p) = (r.clone(), path.clone());

    let (file_name, bytes) = app

        .repos

        .read(&repo, move |repo, cache| {

            let target = view::resolve(repo, cache, &spec)?;

            view::raw(repo, cache, &target, &p)

        })

        .await

        .map_err(|e| Error::from_repo(shell.clone(), e))?;

    Ok(super::raw(bytes, &file_name, true))

}

#[derive(Deserialize)]

pub struct LastQuery {

    /// Comma-separated paths.

    paths: String,

}

/// `GET /{owner}/{name}/last/{ref}?paths=a,b` → JSON of last change per

/// path, fetched by the tree page after it paints (hub spec §6.5).

pub async fn last_changes(

    State(app): State<Shared>,

    viewer: Viewer,

    Path((owner, name, r)): Path<(String, String, String)>,

    Query(q): Query<LastQuery>,

) -> Result<Response, Error> {

    let shell = Shell::new(&app, "", &viewer);

    let (repo, _, _role) = lookup(&app, &shell, &viewer, &owner, &name).await?;

    let paths: Vec<String> = q.paths.split(',').filter(|p| !p.is_empty()).take(500).map(String::from).collect();

    let spec = r.clone();

    let found = app

        .repos

        .read(&repo, move |repo, cache| {

            let target = view::resolve(repo, cache, &spec)?;

            view::last_changes(repo, cache, &target.heads, &paths)

        })

        .await

        .map_err(|e| Error::from_repo(shell.clone(), e))?;

    let now = crate::db::now_ms() as u64;

    let body: Vec<serde_json::Value> = found

        .into_iter()

        .map(|(p, c)| {

            serde_json::json!({ "path": p, "hash": c.hash, "short": c.short, "title": c.title, "ago": render::time::ago(c.when_ms, now), "when": render::time::absolute(c.when_ms) })

        })

        .collect();

    Ok(axum::Json(body).into_response())

}

impl EntryKind {

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

        match self {

            EntryKind::Dir => "▸",

            EntryKind::File => "·",

            EntryKind::Symlink => "↪",

            EntryKind::Subrepo => "◫",

        }

    }

}

#[derive(Deserialize)]