//! History, change and compare pages.

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

use crate::auth::Viewer;

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

use crate::repos::view;

use crate::Shared;

use askama::Template;

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

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

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

    viewer: Viewer,

    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}"), &viewer);

    let (repo, row, role) = lookup(&app, &shell, &viewer, &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, cache| {

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

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

        })

        .await

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

    let mut h = h;

    super::attribute(&app, &mut h.entries.iter_mut().collect::<Vec<_>>()).await;

    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").with_role(role), h, rows, lanes }))

}

#[derive(Deserialize)]

pub struct FunctionQuery {

    start: usize,

    end: usize,

    #[serde(default)]

    name: String,

}

#[derive(Template)]

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

pub struct FunctionPage {

    shell: Shell,

    repo: RepoShell,

    r: String,

    path: String,

    name: String,

    start: usize,

    end: usize,

    entries: Vec<view::ChangeView>,

    rows: Vec<graph::Row>,

    lanes: usize,

}

/// `GET /{owner}/{name}/function/{ref}/{path}?start=…&end=…&name=…`: the

/// history of a function (hub spec §6.6): every change that wrote or

/// deleted one of its lines, exactly (Oxygen spec §27), with a graph of how

/// those changes depend on each other.

pub async fn function(

    State(app): State<Shared>,

    viewer: Viewer,

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

    Query(q): Query<FunctionQuery>,

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

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

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

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

    let mut entries = app

        .repos

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

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

            let history = repo.line_history(&target.heads, &p, start, end)?;

            let labels = view::head_labels(repo)?;

            Ok(history.iter().map(|e| view::change_view_pub(repo, &e.hash, &e.change, e.is_head, &labels)).collect::<Vec<_>>())

        })

        .await

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

    // The graph shows how these changes depend on one another.

    let listed: std::collections::HashSet<String> = entries.iter().map(|c| c.hash.clone()).collect();

    for c in &mut entries {

        c.deps.retain(|d| listed.contains(d));

    }

    super::attribute(&app, &mut entries.iter_mut().collect::<Vec<_>>()).await;

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

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

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

    Ok(Page(FunctionPage {

        shell,

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

        r,

        path,

        name: q.name,

        start,

        end,

        entries,

        rows,

        lanes,

    }))

}

/// Changes a swimlane board shows at most.

const BOARD: usize = 60;

#[derive(Template)]

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

pub struct LanesPage {

    shell: Shell,

    repo: RepoShell,

    target: view::RefTarget,

    total: usize,

    board: graph::Board,

    /// The open proposal whose source this bookmark is, when the viewer may

    /// rewrite it: cards can then be dragged onto each other (P3b).

    proposal: Option<i64>,

}

/// `GET /{owner}/{name}/lanes/{ref}`: a bookmark's newest changes as

/// swimlanes (hub spec §6.7): independent work in separate lanes, time

/// left to right, dependencies as edges and no merge nodes.

pub async fn lanes(

    State(app): State<Shared>,

    viewer: Viewer,

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

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

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

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

    let spec = r.clone();

    let h = app

        .repos

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

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

            view::history(repo, cache, target, None, 0, BOARD)

        })

        .await

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

    let board = graph::board(&h.entries);

    let proposal = editable_proposal(&app, &viewer, &row, role, &r).await.map(|p| p.number);

    Ok(Page(LanesPage {

        shell,

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

        target: h.target,

        total: h.total,

        board,

        proposal,

    }))

}

/// The open proposal whose source is `bookmark` of this repository, when

/// the viewer is its author or may write here: only those bookmarks are

/// rewritten from the board, and only by their owners' clients.

async fn editable_proposal(

    app: &Shared,

    viewer: &Viewer,

    row: &crate::db::repos::RepoRow,

    role: crate::auth::Role,

    bookmark: &str,

) -> Option<crate::db::proposals::ProposalRow> {

    let me = viewer.account()?;

    let open = crate::db::proposals::list(&app.db, row.id, &["open", "draft"]).await.ok()?;

    open.into_iter().find(|p| {

        p.source_bookmark == bookmark

            && p.source_repo_id.is_none_or(|id| id == row.id)

            && (p.author_id == Some(me.id) || role >= crate::auth::Role::Write)

    })

}

/// One rewrite the board offers for a drop (hub spec §6.7).

#[derive(serde::Serialize)]

pub struct PlanOption {

    /// `squash` or `rebase`.

    kind: &'static str,

    summary: String,

    /// What to run in a checkout of the bookmark.

    command: String,

    /// The same, handed to oxygen-vscode.

    vscode: String,

}

#[derive(Deserialize)]

pub struct PlanForm {

    #[serde(rename = "_csrf")]

    csrf_token: String,

    /// The dragged change and the one it was dropped on, full hashes.

    change: String,

    target: String,

}

/// The rewrites a drop may mean, for a proposal bookmark (pure, tested):

/// squashing `c` into `t` when `c` needs nothing `t` lacks, rebasing `c`

/// onto `t` when `t` does not already have it. Reordering independent

/// changes means nothing in Oxygen, so a drop never offers it.

pub fn plan_options(state: &oxy_core::state::State, c: &oxy_core::hash::ChangeHash, t: &oxy_core::hash::ChangeHash) -> Vec<&'static str> {

    use oxy_core::graph::DepOracle;

    if c == t || !state.contains(c) || !state.contains(t) || state.depends_on(t, c) {

        return vec![];

    }

    let mut out = Vec::new();

    let closure = state.closure(t);

    let deps_ok = state.get(c).is_some_and(|m| m.deps.iter().all(|d| d == t || closure.contains(d)));

    if deps_ok {

        out.push("squash");

    }

    if !state.get(c).is_some_and(|m| m.deps.contains(t)) {

        out.push("rebase");

    }

    out

}

/// `POST /{owner}/{name}/lanes/{bookmark}/plan`: what dropping one card on

/// another would do, as commands for the author's client to run and sign.

/// The hub rewrites nothing itself.

pub async fn plan(

    State(app): State<Shared>,

    viewer: Viewer,

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

    axum::extract::Form(f): axum::extract::Form<PlanForm>,

) -> Result<Response, Error> {

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

    super::settings::csrf(&viewer, &f.csrf_token, &shell)?;

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

    let problem = |msg: &str| (axum::http::StatusCode::BAD_REQUEST, axum::Json(serde_json::json!({ "error": msg }))).into_response();

    let Some(proposal) = editable_proposal(&app, &viewer, &row, role, &r).await else {

        return Ok(problem("Changes are rearranged only on the bookmark of an open proposal you may change."));

    };

    let (Some(c), Some(t)) = (oxy_core::hash::ChangeHash::from_hex(&f.change), oxy_core::hash::ChangeHash::from_hex(&f.target)) else {

        return Ok(problem("Name two changes."));

    };

    let (spec, target_bookmark) = (r.clone(), proposal.target.clone());

    let found = app

        .repos

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

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

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

            // What has landed on the target is history, not a draft.

            let landed = match repo.view()?.bookmarks.get(&target_bookmark) {

                Some(st) => {

                    let heads = repo.store().get_state(st)?.heads;

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

                    target_state.state.contains(&c) || target_state.state.contains(&t)

                }

                None => false,

            };

            let meta = |h: &oxy_core::hash::ChangeHash| loaded.state.get(h).map(|m| m.change_id.short(8));

            Ok((plan_options(&loaded.state, &c, &t), landed, meta(&c), meta(&t)))

        })

        .await

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

    let (kinds, landed, Some(cid), Some(tid)) = found else {

        return Ok(problem("Both changes must be on this bookmark."));

    };

    if landed {

        return Ok(problem(&format!("That change is already on {}; only the proposal's own changes are rearranged.", proposal.target)));

    }

    if kinds.is_empty() {

        return Ok(problem("That drop means nothing here: the change is already part of the other, or they are the same."));

    }

    let base = format!("{}/{owner}/{name}", app.config.base_url().trim_end_matches('/'));

    let enc = super::settings::urlencode;

    let options: Vec<PlanOption> = kinds

        .into_iter()

        .map(|kind| {

            let (summary, command) = match kind {

                "squash" => (

                    format!("Squash {cid} into {tid}: one change instead of two."),

                    format!("oxy squash #{} --into #{}", c.to_hex(), t.to_hex()),

                ),

                _ => (

                    format!("Rebase {cid} onto {tid}: {cid} comes to depend on {tid}."),

                    format!("oxy rebase #{} --onto #{}", c.to_hex(), t.to_hex()),

                ),

            };

            let vscode = format!(

                "vscode://oxygenhub.oxygen-vscode/plan?url={}&bookmark={}&kind={kind}&change={}&target={}",

                enc(&base),

                enc(&r),

                c.to_hex(),

                t.to_hex()

            );

            PlanOption { kind, summary, command: format!("oxy bookmark switch {r} && {command} && oxy push --force"), vscode }

        })

        .collect();

    Ok(axum::Json(serde_json::json!({ "proposal": proposal.number, "options": options })).into_response())

}

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

    render_files_with(files, bases, diff::Options::default())

}

/// `render_files` with diff options (hub spec §6.4: `?w=1` hides whitespace changes).

pub fn render_files_with(files: &[FileDiff], bases: &BTreeMap<String, Vec<u8>>, opts: diff::Options) -> 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_with(base, &f.hunks, 3, opts);

            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,

    ignore_ws: bool,

    /// Receipts runners signed for the state whose only head is this change.

    receipts: Vec<super::flow::ReceiptRow>,

    /// Whether the viewer may run the pipeline on this change.

    can_run: bool,

}

/// `?w=1` on a diff page hides whitespace-only changes.

#[derive(Deserialize, Default)]

pub struct DiffQuery {

    #[serde(default)]

    w: Option<String>,

}

impl DiffQuery {

    pub fn options(&self) -> diff::Options {

        diff::Options { ignore_whitespace: self.w.as_deref() == Some("1") }

    }

}

pub async fn change(

    State(app): State<Shared>,

    viewer: Viewer,

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

    Query(q): Query<DiffQuery>,

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

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

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

    let spec = hash.clone();

    let c = app

        .repos

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

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

            view::change(repo, cache, &h)

        })

        .await

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

    let mut c = c;

    {

        let mut all: Vec<&mut view::ChangeView> = vec![&mut c.view];

        all.extend(c.deps.iter_mut());

        all.extend(c.dependents.iter_mut());

        super::attribute(&app, &mut all).await;

    }

    let files = render_files_with(&c.files, &c.bases, q.options());

    let ignore_ws = q.options().ignore_whitespace;

    let body_html =

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

    let receipts = match oxy_core::hash::ChangeHash::from_hex(&c.view.hash) {

        Some(h) => super::flow::receipts_of(&app, &repo, vec![h]).await,

        None => vec![],

    };

    let can_run = super::flow::why_not_run(crate::flow::enabled(&app, &row), viewer.account().is_some(), role).is_none();

    Ok(Page(ChangePage {

        shell,

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

        c,

        files,

        body_html,

        ignore_ws,

        receipts,

        can_run,

    }))

}

#[derive(Template)]

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

pub struct ComparePage {

    shell: Shell,

    repo: RepoShell,

    cmp: view::Compare,

    files: Vec<FileRows>,

    ignore_ws: bool,

    /// The two sides as given, for the pickers.

    base_spec: String,

    head_spec: String,

    /// Bookmarks and tags to pick from.

    bookmarks: Vec<String>,

    tags: Vec<String>,

    propose: Option<Propose>,

}

/// "Propose this": head into base, when both are bookmarks and the viewer may write.

pub struct Propose {

    pub url: String,

    /// An open proposal of head into base already.

    pub existing: Option<i64>,

}

#[derive(Deserialize)]

pub struct CompareForm {

    base: Option<String>,

    head: Option<String>,

}

/// `/compare`: the pickers' form target, or a sensible first comparison:

/// the most recently changed other bookmark against the default.

pub async fn compare_index(

    State(app): State<Shared>,

    viewer: Viewer,

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

    Query(q): Query<CompareForm>,

) -> Result<Response, Error> {

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

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

    let clean = |s: Option<String>| s.map(|x| x.trim().to_string()).filter(|x| !x.is_empty() && !x.contains("..."));

    let (base, head) = match (clean(q.base), clean(q.head)) {

        (Some(b), Some(h)) => (b, h),

        (b, h) => {

            let default = row.default_bookmark.clone();

            let d = default.clone();

            let newest = app

                .repos

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

                    Ok(view::bookmarks(r, cache, &d)?.into_iter().filter(|b| !b.default).max_by_key(|b| b.latest_ms).map(|b| b.name))

                })

                .await

                .ok()

                .flatten();

            (b.unwrap_or_else(|| default.clone()), h.unwrap_or_else(|| newest.unwrap_or(default)))

        }

    };

    let enc = |s: &str| s.replace('%', "%25").replace(' ', "%20").replace('?', "%3F").replace('#', "%23");

    Ok(axum::response::Redirect::to(&format!("/{owner}/{name}/compare/{}...{}", enc(&base), enc(&head))).into_response())

}

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

pub async fn compare(

    State(app): State<Shared>,

    viewer: Viewer,

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

    Query(q): Query<DiffQuery>,

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

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

    let (repo, row, role) = lookup(&app, &shell, &viewer, &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