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

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,
    };
    Ok(Page(OverviewPage { shell, repo: rs, o, readme_html, watching }))
}

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 => "◫",
        }
    }
}