//! History, change and compare pages.

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

use crate::render::{self, diff, graph};

use crate::repos::view;

use crate::Shared;

use askama::Template;

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

use oxy_core::repo::FileDiff;

use serde::Deserialize;

use std::collections::BTreeMap;

const PAGE: usize = 50;

#[derive(Deserialize)]

pub struct HistoryQuery {

    path: Option<String>,

    offset: Option<usize>,

}

#[derive(Template)]

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

pub struct HistoryPage {

    shell: Shell,

    repo: RepoShell,

    h: view::History,

    rows: Vec<graph::Row>,

    lanes: usize,

}

pub async fn history(

    State(app): State<Shared>,

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

    Query(q): Query<HistoryQuery>,

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

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

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

    let spec = r.clone();

    let path = q.path.clone().filter(|p| !p.is_empty());

    let offset = q.offset.unwrap_or(0);

    let h = app

        .repos

        .read(&repo, move |repo| {

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

            view::history(repo, target, path.as_deref(), offset, PAGE)

        })

        .await

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

    let graph_input: Vec<(String, Vec<String>)> = h.entries.iter().map(|c| (c.hash.clone(), c.deps.clone())).collect();

    let rows = graph::layout(&graph_input);

    let lanes = graph::width(&rows);

    Ok(Page(HistoryPage { shell, repo: RepoShell::new(&app, &row, "changes"), h, rows, lanes }))

}

/// A file's diff, rendered.

pub struct FileRows {

    pub path: String,

    pub from: Option<String>,

    pub kind: String,

    pub lines: Vec<diff::Line>,

    pub added: usize,

    pub removed: usize,

    pub anchor: String,

}

pub fn render_files(files: &[FileDiff], bases: &BTreeMap<String, Vec<u8>>) -> Vec<FileRows> {

    files

        .iter()

        .enumerate()

        .map(|(i, f)| {

            let base = bases.get(&f.path).map(Vec::as_slice).unwrap_or(b"");

            let lines = diff::unified(base, &f.hunks, 3);

            FileRows {

                path: f.path.clone(),

                from: f.from.clone(),

                kind: f.kind.clone(),

                added: lines.iter().filter(|l| l.kind == diff::Kind::Add).count(),

                removed: lines.iter().filter(|l| l.kind == diff::Kind::Del).count(),

                lines,

                anchor: format!("diff-{i}"),

            }

        })

        .collect()

}

#[derive(Template)]

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

pub struct ChangePage {

    shell: Shell,

    repo: RepoShell,

    c: view::ChangeDetail,

    files: Vec<FileRows>,

    body_html: String,

}

pub async fn change(

    State(app): State<Shared>,

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

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

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

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

    let spec = hash.clone();

    let c = app

        .repos

        .read(&repo, move |repo| {

            let h = view::resolve_change(repo, &spec)?;

            view::change(repo, &h)

        })

        .await

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

    let files = render_files(&c.files, &c.bases);

    let body_html =

        if c.view.body.is_empty() { String::new() } else { format!("<pre class=\"msg\">{}</pre>", render::escape(&c.view.body)) };

    Ok(Page(ChangePage { shell, repo: RepoShell::new(&app, &row, "changes"), c, files, body_html }))

}

#[derive(Template)]

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

pub struct ComparePage {

    shell: Shell,

    repo: RepoShell,

    cmp: view::Compare,

    files: Vec<FileRows>,

}

/// `/compare/{base}...{head}`.

pub async fn compare(

    State(app): State<Shared>,

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

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

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

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

    let Some((a, b)) = spec.split_once("...") else {

        return Err(Error::bad(shell, "compare takes base...head"));

    };

    let (a, b) = (a.to_string(), b.to_string());

    let cmp = app

        .repos

        .read(&repo, move |repo| {

            let base = view::resolve(repo, &a)?;

            let head = view::resolve(repo, &b)?;

            view::compare(repo, base, head)

        })

        .await

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

    let files = render_files(&cmp.files, &cmp.bases);

    Ok(Page(ComparePage { shell, repo: RepoShell::new(&app, &row, "changes"), cmp, files }))

}