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

#[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>,

}

/// 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 o =

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

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

    Ok(Page(OverviewPage { shell, repo: rs, o, readme_html, watching, latest_release, quickstart }))

}

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!("{}/file/{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!("{}/file/{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>>,

}

/// 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,

}

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?;

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

    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)?;

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

            } 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 = format!("{}/file/{r}/{dir}", rs.url);

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

            } else {

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

            }

        }

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

    };

    let blame = blame.map(|lines| {

        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,

                });

            }

            i += run;

        }

        rows

    });

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

}

#[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)]

pub struct CodeQuery {

    #[serde(default)]

    q: String,

    #[serde(default, rename = "ref")]

    r: Option<String>,

    #[serde(default)]

    path: String,

    #[serde(default)]

    re: Option<String>,

    #[serde(default)]

    case: Option<String>,

}

#[derive(Template)]

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

pub struct CodeSearchPage {

    shell: Shell,

    repo: RepoShell,

    q: String,

    r: String,

    path: String,

    regex: bool,

    case: bool,

    results: crate::repos::search::Results,

    error: Option<String>,

}

/// `GET /{owner}/{name}/search?q=…&ref=…&re=1&case=1&path=…` (hub spec §11).

pub async fn code_search(

    State(app): State<Shared>,

    viewer: Viewer,

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

    Query(q): Query<CodeQuery>,

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

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

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

    let r = q.r.clone().filter(|x| !x.is_empty()).unwrap_or_else(|| row.default_bookmark.clone());

    let (regex, case) = (q.re.is_some(), q.case.is_some());

    let mut results = crate::repos::search::Results::default();

    let mut error = None;

    if !q.q.trim().is_empty() {

        let (text, spec, prefix) = (q.q.clone(), r.clone(), q.path.trim_matches('/').to_string());

        let app2 = app.clone();

        let out = app

            .repos

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

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

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

                let state = oxy_core::objects::StateObject::new(loaded.heads.clone()).hash().to_hex();

                let key = format!("{state}\0{text}\0{regex}\0{case}\0{prefix}");

                if let Some(hit) = app2.repos.searches.get(&key) {

                    return Ok(Ok(hit));

                }

                let res = crate::repos::search::run(

                    &loaded,

                    &crate::repos::search::Query { text: &text, regex, case_sensitive: case, path_prefix: &prefix },

                );

                if let Ok(r) = &res {

                    app2.repos.searches.put(key, r.clone());

                }

                Ok(res)

            })

            .await

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

        match out {

            Ok(r) => results = r,

            Err(e) => error = Some(e),

        }

    }

    Ok(Page(CodeSearchPage {

        shell,

        repo: RepoShell::new(&app, &row, "code").with_role(role),

        q: q.q,

        r,

        path: q.path,

        regex,

        case,

        results,

        error,

    }))

}

#[cfg(test)]

mod tests {

    use super::remote_name;

    #[test]

    fn remote_names_come_from_the_host() {

        assert_eq!(remote_name("https://earth.andymccall.xyz:7343"), "earth");

        assert_eq!(remote_name("https://hub.example.org"), "hub");

        assert_eq!(remote_name("http://127.0.0.1:7300"), "hub");

        assert_eq!(remote_name("http://localhost:7300"), "hub");

        assert_eq!(remote_name("https://www.example.org"), "hub");

        assert_eq!(remote_name("https://My-Host.example"), "hub");

    }

}