Milestone 0.3: proposals and review de505df5cf8d

-- Proposals and review (hub spec §7). Approvals are seals in the object

-- store; rows here only record intent and discussion.

-- One number space per repository, shared by proposals and issues.

CREATE TABLE numbers (

    repo_id INTEGER PRIMARY KEY REFERENCES repositories(id) ON DELETE CASCADE,

    next    INTEGER NOT NULL DEFAULT 1

);

CREATE TABLE proposals (

    id               INTEGER PRIMARY KEY,

    repo_id          INTEGER NOT NULL REFERENCES repositories(id) ON DELETE CASCADE,

    number           INTEGER NOT NULL,

    title            TEXT NOT NULL,

    body             TEXT NOT NULL DEFAULT '',

    author_id        INTEGER REFERENCES accounts(id) ON DELETE SET NULL,

    author           TEXT NOT NULL DEFAULT '',

    state            TEXT NOT NULL DEFAULT 'open' CHECK (state IN ('draft', 'open', 'landed', 'closed')),

    target           TEXT NOT NULL,

    source_kind      TEXT NOT NULL CHECK (source_kind IN ('bookmark', 'fork', 'changes')),

    source_repo_id   INTEGER REFERENCES repositories(id) ON DELETE SET NULL,

    source_bookmark  TEXT NOT NULL DEFAULT '',

    source_changes   TEXT NOT NULL DEFAULT '',

    projected_state  TEXT NOT NULL DEFAULT '',

    projected_heads  TEXT NOT NULL DEFAULT '',

    projected_target TEXT NOT NULL DEFAULT '',

    projected_changes TEXT NOT NULL DEFAULT '',

    conflicted       INTEGER NOT NULL DEFAULT 0,

    landed_state     TEXT NOT NULL DEFAULT '',

    created_ms       INTEGER NOT NULL,

    updated_ms       INTEGER NOT NULL,

    UNIQUE (repo_id, number)

);

CREATE TABLE proposal_comments (

    id          INTEGER PRIMARY KEY,

    proposal_id INTEGER NOT NULL REFERENCES proposals(id) ON DELETE CASCADE,

    author_id   INTEGER REFERENCES accounts(id) ON DELETE SET NULL,

    author      TEXT NOT NULL DEFAULT '',

    body        TEXT NOT NULL,

    path        TEXT NOT NULL DEFAULT '',

    -- The atom the comment anchors to: the change that introduced the line and its index.

    anchor_change TEXT NOT NULL DEFAULT '',

    anchor_index  INTEGER NOT NULL DEFAULT 0,

    resolved    INTEGER NOT NULL DEFAULT 0,

    created_ms  INTEGER NOT NULL

);

CREATE INDEX proposal_comments_by_proposal ON proposal_comments (proposal_id, created_ms);

CREATE TABLE proposal_reviews (

    id          INTEGER PRIMARY KEY,

    proposal_id INTEGER NOT NULL REFERENCES proposals(id) ON DELETE CASCADE,

    author_id   INTEGER NOT NULL REFERENCES accounts(id) ON DELETE CASCADE,

    author      TEXT NOT NULL DEFAULT '',

    verdict     TEXT NOT NULL CHECK (verdict IN ('comment', 'changes', 'approve')),

    body        TEXT NOT NULL DEFAULT '',

    created_ms  INTEGER NOT NULL

);

CREATE INDEX proposal_reviews_by_proposal ON proposal_reviews (proposal_id, created_ms);

CREATE TABLE proposal_events (

    id          INTEGER PRIMARY KEY,

    proposal_id INTEGER NOT NULL REFERENCES proposals(id) ON DELETE CASCADE,

    at_ms       INTEGER NOT NULL,

    actor       TEXT NOT NULL DEFAULT '',

    event       TEXT NOT NULL,

    detail      TEXT NOT NULL DEFAULT ''

);

-- Landing requirements per repository (hub spec §7.4).

ALTER TABLE repositories ADD COLUMN required_approvals INTEGER NOT NULL DEFAULT 0;

ALTER TABLE repositories ADD COLUMN require_owners INTEGER NOT NULL DEFAULT 0;

ALTER TABLE repositories ADD COLUMN allow_conflicts INTEGER NOT NULL DEFAULT 0;

//! The `proposals`, `proposal_comments`, `proposal_reviews` and

//! `proposal_events` tables, and the per-repository number space.

use super::{now_ms, Pool};

use sqlx::FromRow;

#[derive(Clone, Debug, FromRow)]

pub struct ProposalRow {

    pub id: i64,

    pub repo_id: i64,

    pub number: i64,

    pub title: String,

    pub body: String,

    pub author_id: Option<i64>,

    pub author: String,

    pub state: String,

    pub target: String,

    pub source_kind: String,

    pub source_repo_id: Option<i64>,

    pub source_bookmark: String,

    pub source_changes: String,

    pub projected_state: String,

    pub projected_heads: String,

    pub projected_target: String,

    pub projected_changes: String,

    pub conflicted: bool,

    pub landed_state: String,

    pub created_ms: i64,

    pub updated_ms: i64,

}

impl ProposalRow {

    pub fn projected_heads(&self) -> Vec<String> {

        self.projected_heads.split(',').filter(|s| !s.is_empty()).map(String::from).collect()

    }

    pub fn projected_changes(&self) -> Vec<String> {

        self.projected_changes.split(',').filter(|s| !s.is_empty()).map(String::from).collect()

    }

    pub fn source_changes(&self) -> Vec<String> {

        self.source_changes.split(',').filter(|s| !s.is_empty()).map(String::from).collect()

    }

    pub fn is_open(&self) -> bool {

        self.state == "open" || self.state == "draft"

    }

}

#[derive(Clone, Debug, FromRow)]

pub struct CommentRow {

    pub id: i64,

    pub proposal_id: i64,

    pub author_id: Option<i64>,

    pub author: String,

    pub body: String,

    pub path: String,

    pub anchor_change: String,

    pub anchor_index: i64,

    pub resolved: bool,

    pub created_ms: i64,

}

#[derive(Clone, Debug, FromRow)]

pub struct ReviewRow {

    pub id: i64,

    pub proposal_id: i64,

    pub author_id: i64,

    pub author: String,

    pub verdict: String,

    pub body: String,

    pub created_ms: i64,

}

#[derive(Clone, Debug, FromRow)]

pub struct EventRow {

    pub id: i64,

    pub at_ms: i64,

    pub actor: String,

    pub event: String,

    pub detail: String,

}

/// Take the next number of a repository's shared number space.

pub async fn next_number(pool: &Pool, repo_id: i64) -> sqlx::Result<i64> {

    let mut tx = pool.begin().await?;

    sqlx::query("INSERT OR IGNORE INTO numbers (repo_id, next) VALUES (?, 1)").bind(repo_id).execute(&mut *tx).await?;

    let n: i64 = sqlx::query_scalar("SELECT next FROM numbers WHERE repo_id = ?").bind(repo_id).fetch_one(&mut *tx).await?;

    sqlx::query("UPDATE numbers SET next = next + 1 WHERE repo_id = ?").bind(repo_id).execute(&mut *tx).await?;

    tx.commit().await?;

    Ok(n)

}

pub struct NewProposal<'a> {

    pub repo_id: i64,

    pub title: &'a str,

    pub body: &'a str,

    pub author_id: Option<i64>,

    pub author: &'a str,

    pub draft: bool,

    pub target: &'a str,

    pub source_kind: &'a str,

    pub source_repo_id: Option<i64>,

    pub source_bookmark: &'a str,

    pub source_changes: &'a str,

}

pub async fn create(pool: &Pool, p: NewProposal<'_>) -> sqlx::Result<ProposalRow> {

    let number = next_number(pool, p.repo_id).await?;

    let now = now_ms();

    sqlx::query_as(

        "INSERT INTO proposals (repo_id, number, title, body, author_id, author, state, target, source_kind, source_repo_id, source_bookmark, source_changes, created_ms, updated_ms) \

         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING *",

    )

    .bind(p.repo_id)

    .bind(number)

    .bind(p.title)

    .bind(p.body)

    .bind(p.author_id)

    .bind(p.author)

    .bind(if p.draft { "draft" } else { "open" })

    .bind(p.target)

    .bind(p.source_kind)

    .bind(p.source_repo_id)

    .bind(p.source_bookmark)

    .bind(p.source_changes)

    .bind(now)

    .bind(now)

    .fetch_one(pool)

    .await

}

pub async fn get(pool: &Pool, repo_id: i64, number: i64) -> sqlx::Result<Option<ProposalRow>> {

    sqlx::query_as("SELECT * FROM proposals WHERE repo_id = ? AND number = ?").bind(repo_id).bind(number).fetch_optional(pool).await

}

pub async fn list(pool: &Pool, repo_id: i64, states: &[&str]) -> sqlx::Result<Vec<ProposalRow>> {

    let all: Vec<ProposalRow> =

        sqlx::query_as("SELECT * FROM proposals WHERE repo_id = ? ORDER BY number DESC").bind(repo_id).fetch_all(pool).await?;

    Ok(all.into_iter().filter(|p| states.is_empty() || states.contains(&p.state.as_str())).collect())

}

/// Open proposals of every repository, for the front page.

pub async fn open_for_author(pool: &Pool, author_id: i64) -> sqlx::Result<Vec<ProposalRow>> {

    sqlx::query_as("SELECT * FROM proposals WHERE author_id = ? AND state IN ('open', 'draft') ORDER BY updated_ms DESC")

        .bind(author_id)

        .fetch_all(pool)

        .await

}

pub async fn set_projection(

    pool: &Pool,

    id: i64,

    state: &str,

    heads: &str,

    target_state: &str,

    changes: &str,

    conflicted: bool,

) -> sqlx::Result<()> {

    sqlx::query("UPDATE proposals SET projected_state = ?, projected_heads = ?, projected_target = ?, projected_changes = ?, conflicted = ? WHERE id = ?")

        .bind(state)

        .bind(heads)

        .bind(target_state)

        .bind(changes)

        .bind(conflicted)

        .bind(id)

        .execute(pool)

        .await?;

    Ok(())

}

pub async fn set_state(pool: &Pool, id: i64, state: &str, landed_state: &str) -> sqlx::Result<()> {

    sqlx::query("UPDATE proposals SET state = ?, landed_state = ?, updated_ms = ? WHERE id = ?")

        .bind(state)

        .bind(landed_state)

        .bind(now_ms())

        .bind(id)

        .execute(pool)

        .await?;

    Ok(())

}

pub async fn edit(pool: &Pool, id: i64, title: &str, body: &str, target: &str) -> sqlx::Result<()> {

    sqlx::query("UPDATE proposals SET title = ?, body = ?, target = ?, updated_ms = ? WHERE id = ?")

        .bind(title)

        .bind(body)

        .bind(target)

        .bind(now_ms())

        .bind(id)

        .execute(pool)

        .await?;

    Ok(())

}

pub async fn touch(pool: &Pool, id: i64) -> sqlx::Result<()> {

    sqlx::query("UPDATE proposals SET updated_ms = ? WHERE id = ?").bind(now_ms()).bind(id).execute(pool).await?;

    Ok(())

}

pub async fn comments(pool: &Pool, proposal_id: i64) -> sqlx::Result<Vec<CommentRow>> {

    sqlx::query_as("SELECT * FROM proposal_comments WHERE proposal_id = ? ORDER BY created_ms, id").bind(proposal_id).fetch_all(pool).await

}

pub async fn add_comment(

    pool: &Pool,

    proposal_id: i64,

    author_id: Option<i64>,

    author: &str,

    body: &str,

    path: &str,

    anchor: Option<(&str, i64)>,

) -> sqlx::Result<CommentRow> {

    let row = sqlx::query_as(

        "INSERT INTO proposal_comments (proposal_id, author_id, author, body, path, anchor_change, anchor_index, created_ms) VALUES (?, ?, ?, ?, ?, ?, ?, ?) RETURNING *",

    )

    .bind(proposal_id)

    .bind(author_id)

    .bind(author)

    .bind(body)

    .bind(path)

    .bind(anchor.map(|a| a.0).unwrap_or(""))

    .bind(anchor.map(|a| a.1).unwrap_or(0))

    .bind(now_ms())

    .fetch_one(pool)

    .await?;

    touch(pool, proposal_id).await?;

    Ok(row)

}

pub async fn set_comment_resolved(pool: &Pool, id: i64, resolved: bool) -> sqlx::Result<()> {

    sqlx::query("UPDATE proposal_comments SET resolved = ? WHERE id = ?").bind(resolved).bind(id).execute(pool).await?;

    Ok(())

}

pub async fn reviews(pool: &Pool, proposal_id: i64) -> sqlx::Result<Vec<ReviewRow>> {

    sqlx::query_as("SELECT * FROM proposal_reviews WHERE proposal_id = ? ORDER BY created_ms, id").bind(proposal_id).fetch_all(pool).await

}

pub async fn add_review(pool: &Pool, proposal_id: i64, author_id: i64, author: &str, verdict: &str, body: &str) -> sqlx::Result<ReviewRow> {

    let row = sqlx::query_as(

        "INSERT INTO proposal_reviews (proposal_id, author_id, author, verdict, body, created_ms) VALUES (?, ?, ?, ?, ?, ?) RETURNING *",

    )

    .bind(proposal_id)

    .bind(author_id)

    .bind(author)

    .bind(verdict)

    .bind(body)

    .bind(now_ms())

    .fetch_one(pool)

    .await?;

    touch(pool, proposal_id).await?;

    Ok(row)

}

pub async fn events(pool: &Pool, proposal_id: i64) -> sqlx::Result<Vec<EventRow>> {

    sqlx::query_as("SELECT id, at_ms, actor, event, detail FROM proposal_events WHERE proposal_id = ? ORDER BY at_ms, id")

        .bind(proposal_id)

        .fetch_all(pool)

        .await

}

pub async fn add_event(pool: &Pool, proposal_id: i64, actor: &str, event: &str, detail: &str) -> sqlx::Result<()> {

    sqlx::query("INSERT INTO proposal_events (proposal_id, at_ms, actor, event, detail) VALUES (?, ?, ?, ?, ?)")

        .bind(proposal_id)

        .bind(now_ms())

        .bind(actor)

        .bind(event)

        .bind(detail)

        .execute(pool)

        .await?;

    Ok(())

}

/// Landing requirements of a repository.

#[derive(Clone, Copy, Debug, Default, FromRow)]

pub struct Requirements {

    pub required_approvals: i64,

    pub require_owners: bool,

    pub allow_conflicts: bool,

}

pub async fn requirements(pool: &Pool, repo_id: i64) -> sqlx::Result<Requirements> {

    sqlx::query_as("SELECT required_approvals, require_owners, allow_conflicts FROM repositories WHERE id = ?")

        .bind(repo_id)

        .fetch_one(pool)

        .await

}

pub async fn set_requirements(pool: &Pool, repo_id: i64, r: Requirements) -> sqlx::Result<()> {

    sqlx::query("UPDATE repositories SET required_approvals = ?, require_owners = ?, allow_conflicts = ? WHERE id = ?")

        .bind(r.required_approvals)

        .bind(r.require_owners)

        .bind(r.allow_conflicts)

        .bind(repo_id)

        .execute(pool)

        .await?;

    Ok(())

}

//! Proposals (hub spec §7): the projected state, its diff and conflicts,

//! atom anchors for comments, seal-backed approvals, code owners and the

//! landing requirements. Pure functions over `oxy-core`, run under the

//! repository lock.

use super::cache::{Loaded, StateCache};

use super::view::{self, ChangeView, ConflictView, RefTarget};

use super::RepoError;

use oxy_core::hash::{ChangeHash, KeyId, ObjectRef};

use oxy_core::objects::StateObject;

use oxy_core::repo::{FileDiff, Repo};

use oxy_core::state::FileContent;

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

use std::sync::Arc;

type Result<T> = std::result::Result<T, RepoError>;

/// Where a proposal's changes come from, resolved.

pub enum Source<'a> {

    /// Heads of a bookmark of this repository.

    Bookmark(Vec<ChangeHash>),

    /// A fork: its repository directory and the bookmark's heads there.

    Fork {

        fork: &'a Repo,

        heads: Vec<ChangeHash>,

    },

    Changes(Vec<ChangeHash>),

}

/// The projected state of a proposal and what the pages show of it.

pub struct Projection {

    pub target_heads: Vec<ChangeHash>,

    pub target_state: ObjectRef,

    pub heads: Vec<ChangeHash>,

    pub state: ObjectRef,

    /// The changes the proposal adds, dependency order.

    pub changes: Vec<ChangeView>,

    pub hashes: Vec<ChangeHash>,

    pub conflicted: bool,

    pub conflicts: Vec<ConflictView>,

    pub files: Vec<FileDiff>,

    pub bases: BTreeMap<String, Vec<u8>>,

    pub loaded: Arc<Loaded>,

}

/// Compute the projection: the union of the target's heads and the

/// source, with the source's changes brought into this store when they

/// come from a fork.

pub fn project(repo: &Repo, cache: &StateCache, target: &str, source: Source<'_>) -> Result<Projection> {

    let target_heads = repo.bookmarks()?.into_iter().find(|b| b.name == target).map(|b| b.heads).unwrap_or_default();

    let candidate: Vec<ChangeHash> = match &source {

        Source::Bookmark(heads) => heads.clone(),

        Source::Changes(hashes) => hashes.clone(),

        Source::Fork { fork, heads } => {

            // Objects are content addressed: copy what is missing straight from the fork's store.

            let fork_state = fork.load_state(heads)?;

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

            if !missing.is_empty() {

                let bundle = fork.bundle_for(&missing)?;

                repo.import_bundle(&bundle, repo.current_policy()?.is_some())?;

            }

            heads.clone()

        }

    };

    for h in &candidate {

        if !repo.store().has(h) {

            return Err(RepoError::Oxy(oxy_core::repo::RepoError::Msg(format!("change {} is not in this repository", h.short(12)))));

        }

    }

    let mut union: Vec<ChangeHash> = target_heads.clone();

    union.extend(candidate.iter().copied());

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

    let heads = loaded.state.heads();

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

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

    let head_set: BTreeSet<ChangeHash> = heads.iter().copied().collect();

    let mut added: Vec<(ChangeHash, oxy_core::state::ChangeMeta)> =

        loaded.state.changes().filter(|(h, _)| !target_loaded.state.contains(h)).map(|(h, m)| (*h, m.clone())).collect();

    // Dependency order, oldest first: a change after everything it depends on.

    added.sort_by(|a, b| a.1.hlc.cmp(&b.1.hlc).then(a.0.cmp(&b.0)));

    let hashes: Vec<ChangeHash> = added.iter().map(|(h, _)| *h).collect();

    let changes: Vec<ChangeView> = added.iter().map(|(h, m)| view::change_view_pub(repo, h, m, head_set.contains(h), &labels)).collect();

    let conflicted = loaded.snapshot.is_conflicted();

    let conflicts = if conflicted { view::conflicts_in(repo, &loaded, "projected") } else { vec![] };

    let (files, bases) = crate::render::diff::snapshot_diff(&target_loaded.snapshot, &loaded.snapshot);

    let state = StateObject::new(heads.clone()).hash();

    let target_state = StateObject::new(target_heads.clone()).hash();

    Ok(Projection { target_heads, target_state, heads, state, changes, hashes, conflicted, conflicts, files, bases, loaded })

}

/// The atom at line `new_no` (1-based) of `path` in the projected state.

pub fn atom_at(loaded: &Loaded, path: &str, new_no: usize) -> Option<(ChangeHash, u32)> {

    let f = loaded.snapshot.files.get(path)?;

    if !matches!(f.content, FileContent::Text { .. }) {

        return None;

    }

    let lines = loaded.state.live_lines(&f.node);

    lines.get(new_no.checked_sub(1)?).map(|((h, i), _)| (*h, *i))

}

/// The current line (1-based) of an atom in `path`, if it is still live.

pub fn line_of(loaded: &Loaded, path: &str, atom: (ChangeHash, u32)) -> Option<usize> {

    let f = loaded.snapshot.files.get(path)?;

    let lines = loaded.state.live_lines(&f.node);

    lines.iter().position(|((h, i), _)| (*h, *i) == atom).map(|p| p + 1)

}

/// Keys that have sealed every one of `hashes` with a valid seal.

pub fn sealing_keys(repo: &Repo, hashes: &[ChangeHash]) -> Result<Vec<KeyId>> {

    if hashes.is_empty() {

        return Ok(vec![]);

    }

    let mut counts: HashMap<KeyId, usize> = HashMap::new();

    for h in hashes {

        let mut keys_here: BTreeSet<KeyId> = BTreeSet::new();

        for seal_ref in repo.store().seals_for(h)? {

            let attest = repo.store().get_attest(&seal_ref)?;

            let oxy_core::attest::AttestBody::Seal { hashes: covered } = &attest.body else { continue };

            if !covered.contains(h) {

                continue;

            }

            for sig in repo.store().signatures(&seal_ref)? {

                if let Ok(id) = repo.store().get_identity(&sig.key) {

                    if oxy_core::identity::verify(&id, &sig, oxy_core::identity::Domain::Attest, &seal_ref).is_ok() {

                        keys_here.insert(sig.key);

                    }

                }

            }

        }

        for k in keys_here {

            *counts.entry(k).or_default() += 1;

        }

    }

    Ok(counts.into_iter().filter(|(_, n)| *n == hashes.len()).map(|(k, _)| k).collect())

}

/// `.oxyowners` in the target state (CODEOWNERS syntax): the owners of

/// every path the proposal touches.

pub fn owners_for(target: &Loaded, touched: &[String]) -> Vec<String> {

    let Some(f) = target.snapshot.files.get(".oxyowners") else { return vec![] };

    let FileContent::Text { bytes, .. } = &f.content else { return vec![] };

    let text = String::from_utf8_lossy(bytes);

    let rules: Vec<(String, Vec<String>)> = text

        .lines()

        .map(str::trim)

        .filter(|l| !l.is_empty() && !l.starts_with('#'))

        .filter_map(|l| {

            let mut parts = l.split_whitespace();

            let pattern = parts.next()?.to_string();

            let owners: Vec<String> = parts.map(|o| o.trim_start_matches('@').to_string()).collect();

            Some((pattern, owners))

        })

        .collect();

    let mut out: BTreeSet<String> = BTreeSet::new();

    for path in touched {

        // The last matching rule wins, as in CODEOWNERS.

        if let Some((_, owners)) = rules.iter().rev().find(|(pattern, _)| owner_pattern_matches(pattern, path)) {

            out.extend(owners.iter().cloned());

        }

    }

    out.into_iter().collect()

}

fn owner_pattern_matches(pattern: &str, path: &str) -> bool {

    let p = pattern.trim_start_matches('/');

    if p == "*" {

        return true;

    }

    if let Some(dir) = p.strip_suffix('/') {

        return path.starts_with(&format!("{dir}/"));

    }

    if let Some(ext) = p.strip_prefix("*.") {

        return path.ends_with(&format!(".{ext}"));

    }

    if let Some(prefix) = p.strip_suffix("/*") {

        return path.strip_prefix(&format!("{prefix}/")).is_some_and(|rest| !rest.contains('/'));

    }

    if let Some(prefix) = p.strip_suffix("/**") {

        return path.starts_with(&format!("{prefix}/"));

    }

    path == p || path.starts_with(&format!("{p}/"))

}

/// The union of two head lists as a state object reference, for landing.

pub fn state_ref(heads: &[ChangeHash]) -> ObjectRef {

    StateObject::new(heads.to_vec()).hash()

}

/// A proposal's changes as a `RefTarget`, for browsing its tree.

pub fn target_of(label: &str, heads: &[ChangeHash]) -> RefTarget {

    RefTarget { label: label.into(), kind: view::RefKind::Change, heads: heads.to_vec() }

}

#[cfg(test)]

mod tests {

    use super::*;

    #[test]

    fn owner_patterns() {

        assert!(owner_pattern_matches("*", "any/thing"));

        assert!(owner_pattern_matches("docs/", "docs/spec.md"));

        assert!(!owner_pattern_matches("docs/", "src/docs.rs"));

        assert!(owner_pattern_matches("*.rs", "src/main.rs"));

        assert!(owner_pattern_matches("src/*", "src/main.rs"));

        assert!(!owner_pattern_matches("src/*", "src/a/b.rs"));

        assert!(owner_pattern_matches("crates/**", "crates/hub/src/lib.rs"));

        assert!(owner_pattern_matches("Cargo.toml", "Cargo.toml"));

    }

}

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

}

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

    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 fail = |msg: &str, preview: Vec<ChangeView>| {

        Page(NewProposalPage {

            shell: shell.clone(),

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

            bookmarks: bookmarks.clone(),

            source: f.source.clone(),

            target: f.target.clone(),

            error: Some(msg.into()),

            preview,

            conflicted: false,

        })

        .into_response()

    };

    if f.title.trim().is_empty() {

        return Ok(fail("Give the proposal a title.", vec![]));

    }

    if !bookmarks.contains(&f.target) {

        return Ok(fail("Pick a target bookmark of this repository.", vec![]));

    }

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

        return Ok(fail("The source is a bookmark of this repository, or owner/name:bookmark of a fork.", vec![]));

    };

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

        return Ok(fail("The source and the target are the same bookmark.", vec![]));

    }

    let (preview, _) = preview_for(&app, &repo, &f.target, f.source.trim()).await.map_err(|e| Error::from_repo(shell.clone(), e))?;

    if preview.is_empty() {

        return Ok(fail("The source adds nothing to the target.", vec![]));

    }

    let source_repo_id = match &fork {

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

        None => None,

    };

    let created = pdb::create(

        &app.db,

        pdb::NewProposal {

            repo_id: row.id,

            title: f.title.trim(),

            body: f.body.trim(),

            author_id: Some(me.account.id),

            author: &me.account.username,

            draft: f.draft.is_some(),

            target: &f.target,

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

            source_repo_id,

            source_bookmark: &bookmark,

            source_changes: "",

        },

    )

    .await

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

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

    accounts::audit(&app.db, Some(&me.account), "proposal.opened", &format!("{owner}/{name}#{}", created.number), &f.title).await.ok();

    Ok(Redirect::to(&format!("/{owner}/{name}/proposal/{}", created.number)).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 requesting: Vec<&String> = latest.iter().filter(|(_, r)| r.verdict == "changes").map(|(who, _)| who).collect();

    if !requesting.is_empty() {

        blockers.push(format!("changes requested by {}", requesting.iter().map(|s| s.as_str()).collect::<Vec<_>>().join(", ")));

    }

    // Stacking: another open, earlier proposal whose changes this one includes.

    let mut depends_on = Vec::new();

    for other in pdb::list(&app.db, repo_id, &["open", "draft"]).await? {

        if other.id == loaded.row.id || other.number > loaded.row.number {

            continue;

        }

        let theirs = other.projected_changes();

        if !theirs.is_empty() && theirs.iter().all(|h| loaded.hashes.iter().any(|m| m.to_hex() == *h)) {

            depends_on.push(other.number);

        }

    }

    if !depends_on.is_empty() {

        blockers.push(format!("depends on {}", depends_on.iter().map(|n| format!("#{n}")).collect::<Vec<_>>().join(", ")));

    }

    Ok(Verdict { reviews, approvals, blockers, depends_on, requirements })

}

#[derive(Template)]

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

pub struct ProposalPage {

    shell: Shell,

    repo: RepoShell,

    p: pdb::ProposalRow,

    body_html: String,

    tab: String,

    changes: Vec<ChangeView>,

    files: Vec<FileRows>,

    conflicts: Vec<ConflictView>,

    conflicted: bool,

    comments: Vec<CommentView>,

    /// Anchored comments by (path, current line).

    placed: HashMap<(String, usize), Vec<usize>>,

    outdated: Vec<usize>,

    reviews: Vec<ReviewView>,

    approvals: Vec<Approval>,

    blockers: Vec<String>,

    depends_on: Vec<i64>,

    events: Vec<pdb::EventRow>,

    owners: Vec<String>,

    requirements: pdb::Requirements,

    landed_already: bool,

    can_edit: bool,

    can_land: bool,

    hub_can_land: bool,

    notice: Option<String>,

    error: Option<String>,

    heads: Vec<String>,

    state_hash: String,

    source_label: String,

    api_url: String,

}

#[derive(Deserialize)]

pub struct DetailQuery {

    tab: Option<String>,

}

/// The page assembler every action ends in; its arguments are the route

/// plus what to say, and a struct would only rename them.

#[allow(clippy::too_many_arguments)]

async fn detail(

    app: &Shared,

    shell: Shell,

    viewer: &Viewer,

    owner: &str,

    name: &str,

    number: i64,

    tab: String,

    notice: Option<String>,

    error: Option<String>,

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

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

    let p = pdb::get(&app.db, row.id, number)

        .await

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

        .ok_or_else(|| Error::not_found(shell.clone()))?;

    let loaded = load(app, &repo, p).await.map_err(|e| Error::from_repo(shell.clone(), e))?;

    // A proposal whose changes all reached the target landed by another route.

    if loaded.landed_already && loaded.row.is_open() {

        pdb::set_state(&app.db, loaded.row.id, "landed", &loaded.target_state).await.ok();

        pdb::add_event(&app.db, loaded.row.id, "", "landed", "every change reached the target").await.ok();

    }

    let p = pdb::get(&app.db, row.id, number).await.map_err(|e| Error::from_db(shell.clone(), e))?.unwrap_or(loaded.row.clone());

    let v = verdict(app, &loaded, row.id).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    let comment_rows = pdb::comments(&app.db, loaded.row.id).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    let events = pdb::events(&app.db, loaded.row.id).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    // Place anchored comments at their atom's current line.

    let mut by_atom: HashMap<(String, String, u32), usize> = HashMap::new();

    for ((path, line), (h, i)) in &loaded.atoms {

        by_atom.insert((path.clone(), h.clone(), *i), *line);

    }

    let mut comments = Vec::new();

    let mut placed: HashMap<(String, usize), Vec<usize>> = HashMap::new();

    let mut outdated = Vec::new();

    for (idx, c) in comment_rows.into_iter().enumerate() {

        let line = if c.anchor_change.is_empty() {

            None

        } else {

            by_atom.get(&(c.path.clone(), c.anchor_change.clone(), c.anchor_index as u32)).copied()

        };

        if !c.anchor_change.is_empty() {

            match line {

                Some(l) => placed.entry((c.path.clone(), l)).or_default().push(idx),

                None => outdated.push(idx),

            }

        }

        comments.push(CommentView { body_html: render::markdown::render(&c.body, "/", "/"), row: c, line });

    }

    let mut changes = loaded.changes.clone();

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

    let me = viewer.account();

    let can_edit = me.is_some_and(|a| Some(a.id) == p.author_id || role >= Role::Maintain);

    let can_land = role >= Role::Write && p.is_open() && v.blockers.is_empty();

    let hub_can_land = app.repos.read(&repo, |r, _| Ok(r.current_policy()?.is_none())).await.unwrap_or(false);

    let source_label = match p.source_kind.as_str() {

        "fork" => format!(

            "fork {}",

            db::repos::get_by_id(&app.db, p.source_repo_id.unwrap_or(0))

                .await

                .ok()

                .flatten()

                .map(|r| format!("{}:{}", r.slug(), p.source_bookmark))

                .unwrap_or_default()

        ),

        "changes" => format!("{} changes", p.source_changes().len()),

        _ => p.source_bookmark.clone(),

    };

    Ok(Page(ProposalPage {

        shell,

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

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

        p,

        tab,

        changes,

        files: loaded.files,

        conflicts: loaded.conflicts,

        conflicted: loaded.conflicted,

        comments,

        placed,

        outdated,

        reviews: v.reviews,

        approvals: v.approvals,

        blockers: v.blockers,

        depends_on: v.depends_on,

        events,

        owners: loaded.owners,

        requirements: v.requirements,

        landed_already: loaded.landed_already,

        can_edit,

        can_land,

        hub_can_land,

        notice,

        error,

        heads: loaded.heads.iter().map(|h| h.to_hex()).collect(),

        state_hash: loaded.state,

        source_label,

        api_url: format!("{}/api/v1/repos/{owner}/{name}/proposals/{number}", app.config.base_url()),

    }))

}

pub async fn show(

    State(app): State<Shared>,

    viewer: Viewer,

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

    Query(q): Query<DetailQuery>,

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

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

    detail(&app, shell, &viewer, &owner, &name, number, q.tab.unwrap_or_else(|| "conversation".into()), None, None).await

}

// ---------------------------------------------------------------- actions

#[derive(Deserialize)]

pub struct CommentForm {

    #[serde(rename = "_csrf")]

    csrf_token: String,

    body: String,

    #[serde(default)]

    path: String,

    #[serde(default)]

    line: Option<usize>,

}

pub async fn comment(

    State(app): State<Shared>,

    viewer: Viewer,

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

    Form(f): Form<CommentForm>,

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

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

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

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

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

    let p = pdb::get(&app.db, row.id, number)

        .await

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

        .ok_or_else(|| Error::not_found(shell.clone()))?;

    if f.body.trim().is_empty() {

        return detail(

            &app,

            shell,

            &viewer,

            &owner,

            &name,

            number,

            "conversation".into(),

            None,

            Some("An empty comment says nothing.".into()),

        )

        .await;

    }

    let anchor = match (f.path.trim(), f.line) {

        ("", _) | (_, None) => None,

        (path, Some(line)) => {

            let loaded = load(&app, &repo, p.clone()).await.map_err(|e| Error::from_repo(shell.clone(), e))?;

            loaded.atoms.get(&(path.to_string(), line)).cloned()

        }

    };

    let tab = if anchor.is_some() { "files" } else { "conversation" };

    pdb::add_comment(

        &app.db,

        p.id,

        Some(me.account.id),

        &me.account.username,

        f.body.trim(),

        f.path.trim(),

        anchor.as_ref().map(|(h, i)| (h.as_str(), *i as i64)),

    )

    .await

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

    detail(&app, shell, &viewer, &owner, &name, number, tab.into(), None, None).await

}

#[derive(Deserialize)]

pub struct ReviewForm {

    #[serde(rename = "_csrf")]

    csrf_token: String,

    verdict: String,

    #[serde(default)]

    body: String,

}

pub async fn review(

    State(app): State<Shared>,

    viewer: Viewer,

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

    Form(f): Form<ReviewForm>,

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

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

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

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

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

    let p = pdb::get(&app.db, row.id, number)

        .await

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

        .ok_or_else(|| Error::not_found(shell.clone()))?;

    if !matches!(f.verdict.as_str(), "comment" | "changes" | "approve") {

        return Err(Error::bad(shell, "a review is comment, changes or approve"));

    }

    if f.verdict == "approve" && Some(me.account.id) == p.author_id {

        return detail(

            &app,

            shell,

            &viewer,

            &owner,

            &name,

            number,

            "conversation".into(),

            None,

            Some("You cannot approve your own proposal.".into()),

        )

        .await;

    }

    pdb::add_review(&app.db, p.id, me.account.id, &me.account.username, &f.verdict, f.body.trim())

        .await

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

    pdb::add_event(&app.db, p.id, &me.account.username, &format!("review.{}", f.verdict), "").await.ok();

    let notice = if f.verdict == "approve" {

        Some(format!(

            "Approval recorded. It counts once you seal the changes: oxy seal --proposal {}/{owner}/{name}/proposal/{number}",

            app.config.base_url()

        ))

    } else {

        None

    };

    detail(&app, shell, &viewer, &owner, &name, number, "conversation".into(), notice, None).await

}

#[derive(Deserialize)]

pub struct EditForm {

    #[serde(rename = "_csrf")]

    csrf_token: String,

    title: String,

    #[serde(default)]

    body: String,

    target: String,

}

pub async fn edit(

    State(app): State<Shared>,

    viewer: Viewer,

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

    Form(f): Form<EditForm>,

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