//! Proposal pages (hub spec §7): list, new, detail with conversation,

//! changes and files, comments anchored to atoms, reviews, landing.

use super::history::{render_files, FileRows};

use super::settings::{csrf, require};

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

use crate::auth::{Access, Role, Viewer};

use crate::db::{self, accounts, proposals as pdb};

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

use crate::repos::proposals::{self as pl, Projection, Source};

use crate::repos::view::{self, ChangeView, ConflictView};

use crate::repos::RepoName;

use crate::Shared;

use askama::Template;

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

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

use hub_api::{Approval, ProposalSource, ProposalState};

use oxy_core::hash::ChangeHash;

use serde::Deserialize;

use std::collections::{BTreeMap, HashMap};

// ------------------------------------------------------------------ list

#[derive(Template)]

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

pub struct ProposalsPage {

    shell: Shell,

    repo: RepoShell,

    rows: Vec<pdb::ProposalRow>,

    filter: String,

    counts: (usize, usize, usize),

    bookmarks: Vec<String>,

}

#[derive(Deserialize)]

pub struct ListQuery {

    state: Option<String>,

}

pub async fn list(

    State(app): State<Shared>,

    viewer: Viewer,

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

    Query(q): Query<ListQuery>,

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

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

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

    let all = pdb::list(&app.db, row.id, &[]).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    let counts = (

        all.iter().filter(|p| p.is_open()).count(),

        all.iter().filter(|p| p.state == "landed").count(),

        all.iter().filter(|p| p.state == "closed").count(),

    );

    let filter = q.state.unwrap_or_else(|| "open".into());

    let rows = all

        .into_iter()

        .filter(|p| match filter.as_str() {

            "open" => p.is_open(),

            "landed" => p.state == "landed",

            "closed" => p.state == "closed",

            _ => true,

        })

        .collect();

    let bookmarks = app

        .repos

        .read(&repo, |r, _| Ok(r.bookmarks()?.into_iter().map(|b| b.name).collect::<Vec<_>>()))

        .await

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

    Ok(Page(ProposalsPage { shell, repo: RepoShell::new(&app, &row, "proposals").with_role(role), rows, filter, counts, bookmarks }))

}

// ------------------------------------------------------------------- new

#[derive(Template)]

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

pub struct NewProposalPage {

    shell: Shell,

    repo: RepoShell,

    bookmarks: Vec<String>,

    source: String,

    target: String,

    error: Option<String>,

    /// Preview: the changes the proposal would add.

    preview: Vec<ChangeView>,

    conflicted: bool,

}

#[derive(Deserialize)]

pub struct NewQuery {

    source: Option<String>,

    target: Option<String>,

}

/// `owner/name:bookmark` for a fork, else a bookmark of this repository.

fn parse_source(app: &Shared, repo: &RepoName, source: &str) -> Option<(Option<RepoName>, String)> {

    if let Some((slug, bookmark)) = source.split_once(':') {

        let fork = RepoName::parse(slug)?;

        if !app.repos.exists(&fork) || fork == *repo {

            return None;

        }

        return Some((Some(fork), bookmark.to_string()));

    }

    crate::repos::names::valid_segment(source).then(|| (None, source.to_string()))

}

async fn preview_for(

    app: &Shared,

    repo: &RepoName,

    target: &str,

    source: &str,

) -> Result<(Vec<ChangeView>, bool), crate::repos::RepoError> {

    let Some((fork, bookmark)) = parse_source(app, repo, source) else { return Ok((vec![], false)) };

    let target = target.to_string();

    let fork_dir = fork.as_ref().map(|f| app.repos.dir(f));

    app.repos

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

            let projection = match &fork_dir {

                Some(dir) => {

                    let fork_repo = oxy_core::repo::Repo::open(dir)?;

                    let heads = fork_repo.bookmarks()?.into_iter().find(|b| b.name == bookmark).map(|b| b.heads).unwrap_or_default();

                    pl::project(r, cache, &target, Source::Fork { fork: &fork_repo, heads })?

                }

                None => {

                    let heads = r.bookmarks()?.into_iter().find(|b| b.name == bookmark).map(|b| b.heads).unwrap_or_default();

                    pl::project(r, cache, &target, Source::Bookmark(heads))?

                }

            };

            Ok((projection.changes, projection.conflicted))

        })

        .await

}

pub async fn new_form(

    State(app): State<Shared>,

    viewer: Viewer,

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

    Query(q): Query<NewQuery>,

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

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

    require(&viewer, &shell)?;

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

    let bookmarks = app

        .repos

        .read(&repo, |r, _| Ok(r.bookmarks()?.into_iter().map(|b| b.name).collect::<Vec<_>>()))

        .await

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

    let target = q.target.unwrap_or_else(|| row.default_bookmark.clone());

    let source = q.source.unwrap_or_default();

    let (preview, conflicted) =

        if source.is_empty() { (vec![], false) } else { preview_for(&app, &repo, &target, &source).await.unwrap_or((vec![], false)) };

    Ok(Page(NewProposalPage {

        shell,

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

        bookmarks,

        source,

        target,

        error: None,

        preview,

        conflicted,

    }))

}

#[derive(Deserialize)]

pub struct NewForm {

    #[serde(rename = "_csrf")]

    csrf_token: String,

    title: String,

    #[serde(default)]

    body: String,

    target: String,

    source: String,

    #[serde(default)]

    draft: Option<String>,

}

/// Open a proposal from a form or the API: validate, create, index, notify.

#[allow(clippy::too_many_arguments)]

pub async fn open_proposal(

    app: &Shared,

    repo: &RepoName,

    row: &db::repos::RepoRow,

    me: &accounts::Account,

    title: &str,

    body: &str,

    target: &str,

    source: &str,

    draft: bool,

) -> Result<pdb::ProposalRow, String> {

    if title.trim().is_empty() {

        return Err("Give the proposal a title.".into());

    }

    let bookmarks =

        app.repos.read(repo, |r, _| Ok(r.bookmarks()?.into_iter().map(|b| b.name).collect::<Vec<_>>())).await.map_err(|e| e.to_string())?;

    if !bookmarks.iter().any(|b| b == target) {

        return Err("Pick a target bookmark of this repository.".into());

    }

    let Some((fork, bookmark)) = parse_source(app, repo, source.trim()) else {

        return Err("The source is a bookmark of this repository, or owner/name:bookmark of a fork.".into());

    };

    if fork.is_none() && bookmark == target {

        return Err("The source and the target are the same bookmark.".into());

    }

    let (preview, _) = preview_for(app, repo, target, source.trim()).await.map_err(|e| e.to_string())?;

    if preview.is_empty() {

        return Err("The source adds nothing to the target.".into());

    }

    let source_repo_id = match &fork {

        Some(fk) => db::repos::get(&app.db, &fk.owner, &fk.name).await.map_err(|e| e.to_string())?.map(|r| r.id),

        None => None,

    };

    let created = pdb::create(

        &app.db,

        pdb::NewProposal {

            repo_id: row.id,

            title: title.trim(),

            body: body.trim(),

            author_id: Some(me.id),

            author: &me.username,

            draft,

            target,

            source_kind: if fork.is_some() { "fork" } else { "bookmark" },

            source_repo_id,

            source_bookmark: &bookmark,

            source_changes: "",

        },

    )

    .await

    .map_err(|e| e.to_string())?;

    pdb::add_event(&app.db, created.id, &me.username, "opened", "").await.ok();

    accounts::audit(&app.db, Some(me), "proposal.opened", &format!("{}#{}", row.slug(), created.number), title).await.ok();

    db::notify::index(&app.db, "proposal", row.id, created.id, created.number, &created.title, &created.body).await.ok();

    let url = format!("/{}/proposal/{}", row.slug(), created.number);

    crate::notify::deliver(

        app,

        crate::notify::Event {

            kind: "proposal.opened",

            title: format!("{}#{}: {}", row.slug(), created.number, created.title),

            url,

            actor: me,

            repo_id: row.id,

            thread: Some(("proposal", created.id)),

            mention_text: body,

            direct: vec![],

        },

    )

    .await;

    crate::hooks::emit(

        app,

        row,

        "proposal.opened",

        &me.username,

        serde_json::json!({ "number": created.number, "title": created.title, "target": target, "source": source }),

    )

    .await;

    Ok(created)

}

pub async fn create(

    State(app): State<Shared>,

    viewer: Viewer,

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

    Form(f): Form<NewForm>,

) -> Result<Response, Error> {

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

    let me = require(&viewer, &shell)?;

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

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

    match open_proposal(&app, &repo, &row, &me.account, &f.title, &f.body, &f.target, &f.source, f.draft.is_some()).await {

        Ok(created) => Ok(Redirect::to(&format!("/{owner}/{name}/proposal/{}", created.number)).into_response()),

        Err(msg) => {

            let bookmarks =

                app.repos.read(&repo, |r, _| Ok(r.bookmarks()?.into_iter().map(|b| b.name).collect::<Vec<_>>())).await.unwrap_or_default();

            Ok(Page(NewProposalPage {

                shell,

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

                bookmarks,

                source: f.source.clone(),

                target: f.target.clone(),

                error: Some(msg),

                preview: vec![],

                conflicted: false,

            })

            .into_response())

        }

    }

}

// ---------------------------------------------------------------- detail

/// A comment placed on a diff row, or general.

pub struct CommentView {

    pub row: pdb::CommentRow,

    pub body_html: String,

    pub line: Option<usize>,

}

pub struct ReviewView {

    pub row: pdb::ReviewRow,

    pub body_html: String,

    pub sealed: bool,

}

/// Everything the detail page and the API need, computed once under the lock.

pub struct Loaded {

    pub row: pdb::ProposalRow,

    pub changes: Vec<ChangeView>,

    pub hashes: Vec<ChangeHash>,

    pub heads: Vec<ChangeHash>,

    pub state: String,

    pub target_state: String,

    pub conflicted: bool,

    pub conflicts: Vec<ConflictView>,

    pub files: Vec<FileRows>,

    /// Atom per (path, new line number) of the projected state.

    pub atoms: HashMap<(String, usize), (String, u32)>,

    pub sealing_keys: Vec<String>,

    pub touched: Vec<String>,

    pub owners: Vec<String>,

    pub landed_already: bool,

}

/// Compute the projection and everything derived from it.

pub async fn load(app: &Shared, repo: &RepoName, row: pdb::ProposalRow) -> Result<Loaded, crate::repos::RepoError> {

    let fork_dir = match (row.source_kind.as_str(), row.source_repo_id) {

        ("fork", Some(id)) => {

            db::repos::get_by_id(&app.db, id).await.ok().flatten().and_then(|r| RepoName::new(&r.owner, &r.name)).map(|n| app.repos.dir(&n))

        }

        _ => None,

    };

    let r2 = row.clone();

    let loaded = app

        .repos

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

            let source = match (r2.source_kind.as_str(), &fork_dir) {

                ("changes", _) => Source::Changes(r2.source_changes().iter().filter_map(|h| ChangeHash::from_hex(h)).collect()),

                ("fork", Some(dir)) => {

                    let fork_repo = oxy_core::repo::Repo::open(dir)?;

                    let heads =

                        fork_repo.bookmarks()?.into_iter().find(|b| b.name == r2.source_bookmark).map(|b| b.heads).unwrap_or_default();

                    // Bring the fork's changes over now, so the projection below can read them.

                    let fork_state = fork_repo.load_state(&heads)?;

                    let missing: Vec<ChangeHash> = fork_state.changes().map(|(h, _)| *h).filter(|h| !r.store().has(h)).collect();

                    if !missing.is_empty() {

                        r.import_bundle(&fork_repo.bundle_for(&missing)?, r.current_policy()?.is_some())?;

                    }

                    Source::Changes(heads)

                }

                _ => {

                    let heads = r.bookmarks()?.into_iter().find(|b| b.name == r2.source_bookmark).map(|b| b.heads).unwrap_or_default();

                    Source::Bookmark(heads)

                }

            };

            let p: Projection = pl::project(r, cache, &r2.target, source)?;

            let target_loaded = cache.load(r, &p.target_heads)?;

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

            let mut atoms = HashMap::new();

            for f in &files {

                for l in &f.lines {

                    if let Some(n) = l.new_no {

                        if let Some((h, i)) = pl::atom_at(&p.loaded, &f.path, n as usize) {

                            atoms.insert((f.path.clone(), n as usize), (h.to_hex(), i));

                        }

                    }

                }

            }

            let touched: Vec<String> = p.files.iter().map(|f| f.path.clone()).collect();

            let owners = pl::owners_for(&target_loaded, &touched);

            let sealing = pl::sealing_keys(r, &p.hashes)?.into_iter().map(|k| k.to_hex()).collect();

            let landed_already = !p.hashes.is_empty() && p.hashes.iter().all(|h| target_loaded.state.contains(h));

            Ok(Loaded {

                row: r2,

                changes: p.changes,

                hashes: p.hashes,

                heads: p.heads,

                state: p.state.to_hex(),

                target_state: p.target_state.to_hex(),

                conflicted: p.conflicted,

                conflicts: p.conflicts,

                files,

                atoms,

                sealing_keys: sealing,

                touched,

                owners,

                landed_already,

            })

        })

        .await?;

    // Remember the projection for the list, the API and other proposals' stacking checks.

    let heads_csv = loaded.heads.iter().map(|h| h.to_hex()).collect::<Vec<_>>().join(",");

    let changes_csv = loaded.hashes.iter().map(|h| h.to_hex()).collect::<Vec<_>>().join(",");

    pdb::set_projection(&app.db, loaded.row.id, &loaded.state, &heads_csv, &loaded.target_state, &changes_csv, loaded.conflicted)

        .await

        .ok();

    Ok(loaded)

}

/// Reviews, approvals and blockers.

pub struct Verdict {

    pub reviews: Vec<ReviewView>,

    pub approvals: Vec<Approval>,

    pub blockers: Vec<String>,

    pub depends_on: Vec<i64>,

    pub requirements: pdb::Requirements,

}

pub async fn verdict(app: &Shared, loaded: &Loaded, repo_id: i64) -> Result<Verdict, sqlx::Error> {

    let rows = pdb::reviews(&app.db, loaded.row.id).await?;

    let links = accounts::identity_accounts(&app.db).await?;

    let sealed_accounts: Vec<String> = links.iter().filter(|(k, _)| loaded.sealing_keys.contains(k)).map(|(_, u)| u.clone()).collect();

    // Latest verdict per reviewer.

    let mut latest: BTreeMap<String, &pdb::ReviewRow> = BTreeMap::new();

    for r in &rows {

        latest.insert(r.author.clone(), r);

    }

    let mut approvals = Vec::new();

    for (who, r) in &latest {

        if r.verdict == "approve" {

            let sealed = sealed_accounts.contains(who);

            let key = links.iter().find(|(k, u)| u == who && loaded.sealing_keys.contains(k)).map(|(k, _)| k.clone());

            approvals.push(Approval { account: who.clone(), sealed, key });

        }

    }

    let reviews = rows

        .iter()

        .map(|r| ReviewView {

            row: r.clone(),

            body_html: render::markdown::render(&r.body, "/", "/"),

            sealed: r.verdict == "approve" && sealed_accounts.contains(&r.author),

        })

        .collect();

    let requirements = pdb::requirements(&app.db, repo_id).await?;

    let mut blockers = Vec::new();

    if loaded.row.state == "draft" {

        blockers.push("the proposal is a draft".into());

    }

    if loaded.hashes.is_empty() {

        blockers.push("the proposal adds no changes".into());

    }

    let sealed_count = approvals.iter().filter(|a| a.sealed).count() as i64;

    if sealed_count < requirements.required_approvals {

        blockers.push(format!("{sealed_count} of {} required sealed approvals", requirements.required_approvals));

    }

    if requirements.require_owners {

        let missing: Vec<&String> = loaded.owners.iter().filter(|o| !approvals.iter().any(|a| a.sealed && &a.account == *o)).collect();

        if !missing.is_empty() {

            blockers.push(format!("code owners still to approve: {}", missing.iter().map(|s| s.as_str()).collect::<Vec<_>>().join(", ")));

        }

    }

    if loaded.conflicted && !requirements.allow_conflicts {

        blockers.push("landing would carry conflicts, which this repository refuses".into());

    }

    let required = db::hooks::required_checks(&app.db, repo_id).await?;

    if !required.is_empty() {

        let checks = db::hooks::checks_for_state(&app.db, repo_id, &loaded.state).await?;