//! Bookmarks, tags, conflicts, trust and pushes pages.

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

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

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

use crate::repos::view;

use crate::{db, Shared};

use askama::Template;

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

use serde::Deserialize;

#[derive(Template)]

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

pub struct BookmarksPage {

    shell: Shell,

    repo: RepoShell,

    bookmarks: Vec<view::BookmarkView>,

    /// Whether the viewer may create and delete bookmarks (write access).

    can_delete: bool,

    /// Whether the viewer may run the pipeline of a bookmark.

    can_run: bool,

    notice: Option<String>,

    error: Option<String>,

}

async fn bookmarks_page(

    app: &Shared,

    shell: Shell,

    repo: crate::repos::RepoName,

    row: db::repos::RepoRow,

    role: Role,

    notice: Option<String>,

    error: Option<String>,

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

    let default = row.default_bookmark.clone();

    let bookmarks =

        app.repos.read(&repo, move |r, cache| view::bookmarks(r, cache, &default)).await.map_err(|e| Error::from_repo(shell.clone(), e))?;

    let can_delete = shell.user.is_some() && role >= Role::Write;

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

    Ok(Page(BookmarksPage {

        shell,

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

        bookmarks,

        can_delete,

        can_run,

        notice,

        error,

    }))

}

pub async fn bookmarks(

    State(app): State<Shared>,

    viewer: Viewer,

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

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

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

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

    bookmarks_page(&app, shell, repo, row, role, None, None).await

}

#[derive(Deserialize)]

pub struct DeleteBookmarkForm {

    #[serde(rename = "_csrf")]

    csrf_token: String,

    bookmark: String,

}

/// Delete a bookmark from the web (hub spec §6.4): what `oxy push --delete`

/// does, through the same checks. Never the default bookmark; refused under

/// a trust policy, which needs a signed attestation only a client can make.

pub async fn delete_bookmark(

    State(app): State<Shared>,

    viewer: Viewer,

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

    Form(f): Form<DeleteBookmarkForm>,

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

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

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

    let (repo, row, role) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Write).await?;

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

    let bookmark = f.bookmark.trim().to_string();

    if bookmark == row.default_bookmark {

        let msg = format!("{bookmark} is the default bookmark; choose another default in Settings first.");

        return bookmarks_page(&app, shell, repo, row, role, None, Some(msg)).await;

    }

    let target = bookmark.clone();

    let outcome = app

        .repos

        .write(&repo, move |r, _| {

            let Some(state) = r.view()?.bookmarks.get(&target).copied() else {

                return Ok(Err(format!("There is no bookmark {target}.")));

            };

            let update = oxy_core::protocol::RefUpdate {

                name: target.clone(),

                old_state: state,

                new_state: oxy_core::hash::ObjectRef::ZERO,

                force: true,

                attestation: None,

            };

            let report = r.receive_push_report(Default::default(), vec![update], None, vec![])?;

            Ok(match report.results.first() {

                Some(res) if res.ok => Ok(state.to_hex()),

                Some(res) => Err(res.reason.clone()),

                None => Err("nothing happened".into()),

            })

        })

        .await

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

    let old_state = match outcome {

        Ok(s) => s,

        Err(msg) => return bookmarks_page(&app, shell, repo, row, role, None, Some(format!("Could not delete {bookmark}: {msg}"))).await,

    };

    let result = db::repos::PushOutcome {

        reference: bookmark.clone(),

        ok: true,

        reason: "deleted on the web".into(),

        old_state: old_state.clone(),

        new_state: oxy_core::hash::ObjectRef::ZERO.to_hex(),

        heads: 0,

        changes: 0,

    };

    db::repos::record_push(&app.db, row.id, Some((me.account.id, &me.account.username)), &[result]).await.ok();

    crate::hooks::emit(

        &app,

        &row,

        "push",

        &me.account.username,

        serde_json::json!({ "updates": [{ "reference": bookmark, "old_state": old_state, "new_state": oxy_core::hash::ObjectRef::ZERO.to_hex(), "heads": 0, "changes": 0, "deleted": true }], "via": "web" }),

    )

    .await;

    db::accounts::audit(&app.db, Some(&me.account), "bookmark.deleted", &format!("{owner}/{name}"), &bookmark).await.ok();

    bookmarks_page(

        &app,

        shell,

        repo,

        row,

        role,

        Some(format!("Deleted {bookmark}. Its changes stay while anything else reaches them.")),

        None,

    )

    .await

}

#[derive(Deserialize)]

pub struct CreateBookmarkForm {

    #[serde(rename = "_csrf")]

    csrf_token: String,

    name: String,

    /// A bookmark, tag or change; the default bookmark when empty.

    #[serde(default)]

    from: String,

}

/// Create a bookmark from the web at the heads of a bookmark, tag or change:

/// what pushing a new bookmark does, signed by the hub key as the user's

/// delegate, as the web's other changes to bookmarks are.

pub async fn create_bookmark(

    State(app): State<Shared>,

    viewer: Viewer,

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

    Form(f): Form<CreateBookmarkForm>,

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

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

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

    let (repo, row, role) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Write).await?;

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

    let bookmark = f.name.trim().to_string();

    let from = match f.from.trim() {

        "" => row.default_bookmark.clone(),

        s => s.to_string(),

    };

    if bookmark.is_empty() || bookmark.chars().any(char::is_whitespace) {

        return bookmarks_page(&app, shell, repo, row, role, None, Some("A bookmark's name has no spaces.".into())).await;

    }

    let (wanted, spec) = (bookmark.clone(), from.clone());

    let found = app

        .repos

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

            if r.view()?.bookmarks.contains_key(&wanted) {

                return Ok(Err(format!("{wanted} is a bookmark already.")));

            }

            Ok(view::resolve(r, cache, &spec).map(|t| t.heads).map_err(|e| e.to_string()))

        })

        .await

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

    let heads = match found {

        Ok(heads) if !heads.is_empty() => heads,

        Ok(_) => return bookmarks_page(&app, shell, repo, row, role, None, Some(format!("{from} holds no changes to start from."))).await,

        Err(msg) => return bookmarks_page(&app, shell, repo, row, role, None, Some(msg)).await,

    };

    let made = set_bookmark(&app, &repo, me.account.id, &bookmark, heads.clone()).await;

    if let Err(e) = made {

        return bookmarks_page(&app, shell, repo, row, role, None, Some(format!("Could not create {bookmark}: {e}"))).await;

    }

    let made = bookmark.clone();

    let new_state = app

        .repos

        .read(&repo, move |r, _| Ok(r.view()?.bookmarks.get(&made).map(|s| s.to_hex()).unwrap_or_default()))

        .await

        .unwrap_or_default();

    let result = db::repos::PushOutcome {

        reference: bookmark.clone(),

        ok: true,

        reason: format!("created on the web from {from}"),

        old_state: oxy_core::hash::ObjectRef::ZERO.to_hex(),

        new_state: new_state.clone(),

        heads: heads.len() as i64,

        changes: 0,

    };

    db::repos::record_push(&app.db, row.id, Some((me.account.id, &me.account.username)), &[result]).await.ok();

    crate::hooks::emit(

        &app,

        &row,

        "push",

        &me.account.username,

        serde_json::json!({ "updates": [{ "reference": bookmark, "old_state": oxy_core::hash::ObjectRef::ZERO.to_hex(), "new_state": new_state, "heads": heads.len(), "changes": 0, "created": true }], "via": "web" }),

    )

    .await;

    db::accounts::audit(&app.db, Some(&me.account), "bookmark.created", &format!("{owner}/{name}"), &format!("{bookmark} from {from}"))

        .await

        .ok();

    let notice = format!("Created {bookmark} from {from}. Propose changes into it, or make it the default in Settings.");

    bookmarks_page(&app, shell, repo, row, role, Some(notice), None).await

}

/// Move (or make) `bookmark` at `heads` from the web: as the user's

/// delegate when they have one, otherwise unsigned, which a repository

/// without a trust policy takes, as a push without one. `Err` says why not.

pub async fn set_bookmark(

    app: &Shared,

    repo: &crate::repos::RepoName,

    account_id: i64,

    bookmark: &str,

    heads: Vec<oxy_core::hash::ChangeHash>,

) -> Result<(), String> {

    match super::edit::signer_for(app, account_id).await {

        Ok(signer) => crate::repos::edits::move_bookmark(&app.repos, repo, bookmark.to_string(), heads, signer)

            .await

            .map(|_| ())

            .map_err(|e| e.to_string()),

        Err(why) => {

            let target = bookmark.to_string();

            let unsigned = app

                .repos

                .write(repo, move |r, _| {

                    let update = r.host_ref_update(&target, &heads, None)?;

                    let report = r.receive_push_report(Default::default(), vec![update], None, vec![])?;

                    Ok(match report.results.first() {

                        Some(res) if res.ok => Ok(()),

                        Some(res) => Err(res.reason.clone()),

                        None => Err("nothing happened".to_string()),

                    })

                })

                .await

                .map_err(|e| e.to_string())

                .and_then(|r| r);

            unsigned.map_err(|refused| format!("{refused}. {why}"))

        }

    }

}

#[derive(Template)]

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

pub struct TagsPage {

    shell: Shell,

    repo: RepoShell,

    tags: Vec<view::TagView>,

    withdrawn: Vec<view::WithdrawnView>,

    /// Tags a release uses (not withdrawn while it does).

    released: Vec<String>,

    can_create: bool,

    can_withdraw: bool,

    notice: Option<String>,

    error: Option<String>,

}

impl TagsPage {

    fn released(&self, tag: &str) -> bool {

        self.released.iter().any(|t| t == tag)

    }

}

async fn tags_page(

    app: &Shared,

    shell: Shell,

    repo: crate::repos::RepoName,

    row: db::repos::RepoRow,

    role: Role,

    notice: Option<String>,

    error: Option<String>,

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

    let (tags, withdrawn) = app

        .repos

        .read(&repo, |r, _| Ok((view::tags(r)?, view::withdrawn_tags(r)?)))

        .await

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

    let released = db::releases::list(&app.db, row.id).await.unwrap_or_default().into_iter().map(|r| r.tag).collect();

    let signed_in = shell.user.is_some();

    Ok(Page(TagsPage {

        shell,

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

        tags,

        withdrawn,

        released,

        can_create: signed_in && role >= Role::Write,

        can_withdraw: signed_in && role >= Role::Maintain,

        notice,

        error,

    }))

}

pub async fn tags(State(app): State<Shared>, viewer: Viewer, Path((owner, name)): Path<(String, String)>) -> Result<Page<TagsPage>, Error> {

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

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

    tags_page(&app, shell, repo, row, role, None, None).await

}

#[derive(Deserialize)]

pub struct CreateTagForm {

    #[serde(rename = "_csrf")]

    csrf_token: String,

    name: String,

    #[serde(default)]

    target: String,

    #[serde(default)]

    message: String,

}

/// Create a tag from the web (#295): signed by the hub key as the user's

/// delegate, under the policy, as `oxy tag create` and a push would be.

pub async fn create_tag(

    State(app): State<Shared>,

    viewer: Viewer,

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

    Form(f): Form<CreateTagForm>,

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

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

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

    let (repo, row, role) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Write).await?;

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

    match crate::tags::create(&app, &row, &repo, &me.account, &f.name, &f.target, &f.message).await {

        Ok(t) => {

            let notice = format!(

                "Tagged {} ({} head{}). Start a release from it under Releases.",

                t.name,

                t.heads.len(),

                if t.heads.len() == 1 { "" } else { "s" }

            );

            tags_page(&app, shell, repo, row, role, Some(notice), None).await

        }

        Err(e) => tags_page(&app, shell, repo, row, role, None, Some(format!("Could not create the tag: {e}"))).await,

    }

}

#[derive(Deserialize)]

pub struct WithdrawTagForm {

    #[serde(rename = "_csrf")]

    csrf_token: String,

    tag: String,

    #[serde(default)]

    reason: String,

}

/// Withdraw a tag from the web (#301), as `oxy push --delete tags/NAME`

/// does: a signed withdrawal, kept and logged. Maintainers only; never

/// while a release uses the tag.

pub async fn withdraw_tag(

    State(app): State<Shared>,

    viewer: Viewer,

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

    Form(f): Form<WithdrawTagForm>,

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

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

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

    let (repo, row, role) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Maintain).await?;

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

    match crate::tags::withdraw(&app, &row, &repo, &me.account, &f.tag, &f.reason).await {

        Ok(t) => {

            let notice = format!("Withdrew {}. Clones drop it on their next fetch; the name is not used again.", t.name);

            tags_page(&app, shell, repo, row, role, Some(notice), None).await

        }

        Err(e) => tags_page(&app, shell, repo, row, role, None, Some(format!("Could not withdraw {}: {e}", f.tag.trim()))).await,

    }

}

#[derive(Template)]

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

pub struct ConflictsPage {

    shell: Shell,

    repo: RepoShell,

    conflicts: Vec<view::ConflictView>,

}

pub async fn conflicts(

    State(app): State<Shared>,

    viewer: Viewer,

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

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

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

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

    let conflicts = app.repos.read(&repo, view::conflicts).await.map_err(|e| Error::from_repo(shell.clone(), e))?;

    Ok(Page(ConflictsPage { shell, repo: RepoShell::new(&app, &row, "conflicts").with_role(role).with_sky(&app, &row).await, conflicts }))

}

#[derive(Template)]

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

pub struct TrustPage {

    shell: Shell,

    repo: RepoShell,

    t: view::Trust,

}

pub async fn trust(

    State(app): State<Shared>,

    viewer: Viewer,

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

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

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

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

    let key = app.hub_key.key;

    let t = app.repos.read(&repo, move |r, cache| view::trust(r, cache, &key)).await.map_err(|e| Error::from_repo(shell.clone(), e))?;

    Ok(Page(TrustPage { shell, repo: RepoShell::new(&app, &row, "trust").with_role(role), t }))

}

#[derive(Template)]

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

pub struct PushesPage {

    shell: Shell,

    repo: RepoShell,

    pushes: Vec<db::repos::PushRow>,

}

pub async fn pushes(

    State(app): State<Shared>,

    viewer: Viewer,

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

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

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

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

    let pushes = db::repos::pushes(&app.db, row.id, 200).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    Ok(Page(PushesPage { shell, repo: RepoShell::new(&app, &row, "pushes").with_role(role), pushes }))

}