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

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

use crate::repos::view;

use crate::{db, Shared};

use askama::Template;

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

#[derive(Template)]

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

pub struct BookmarksPage {

    shell: Shell,

    repo: RepoShell,

    bookmarks: Vec<view::BookmarkView>,

}

pub async fn bookmarks(State(app): State<Shared>, Path((owner, name)): Path<(String, String)>) -> Result<Page<BookmarksPage>, Error> {

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

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

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

    Ok(Page(BookmarksPage { shell, repo: RepoShell::new(&app, &row, "bookmarks"), bookmarks }))

}

#[derive(Template)]

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

pub struct TagsPage {

    shell: Shell,

    repo: RepoShell,

    tags: Vec<view::TagView>,

}

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

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

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

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

    Ok(Page(TagsPage { shell, repo: RepoShell::new(&app, &row, "tags"), tags }))

}

#[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>, Path((owner, name)): Path<(String, String)>) -> Result<Page<ConflictsPage>, Error> {

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

    let (repo, row) = lookup(&app, &shell, &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"), 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>, Path((owner, name)): Path<(String, String)>) -> Result<Page<TrustPage>, Error> {

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

    let (repo, row) = lookup(&app, &shell, &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"), 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>, Path((owner, name)): Path<(String, String)>) -> Result<Page<PushesPage>, Error> {

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

    let (_, row) = lookup(&app, &shell, &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"), pushes }))

}