//! The front page, explore, owner pages and small endpoints.

use super::{filters, Error, Page, Shell};
use crate::auth::Viewer;
use crate::{db, Shared};
use askama::Template;
use axum::extract::{Path, State};
use axum::http::header;
use axum::response::{IntoResponse, Response};
use hub_api::Visibility;

#[derive(Template)]
#[template(path = "home.html")]
pub struct HomePage {
    shell: Shell,
    description: String,
    repos: Vec<db::repos::RepoRow>,
    owner: Option<String>,
}

pub async fn index(State(app): State<Shared>, viewer: Viewer) -> Result<Page<HomePage>, Error> {
    let shell = Shell::new(&app, "/", &viewer);
    let repos = visible(&app, &shell, &viewer, db::repos::list(&app.db).await.map_err(|e| Error::from_db(shell.clone(), e))?).await?;
    Ok(Page(HomePage { description: app.config.site.description.clone(), shell, repos, owner: None }))
}

pub async fn explore(State(app): State<Shared>, viewer: Viewer) -> Result<Page<HomePage>, Error> {
    let mut page = index(State(app.clone()), viewer.clone()).await?;
    page.0.shell = Shell::new(&app, "/explore", &viewer);
    Ok(page)
}

pub async fn owner(State(app): State<Shared>, viewer: Viewer, Path(owner): Path<String>) -> Result<Page<HomePage>, Error> {
    let shell = Shell::new(&app, &format!("/{owner}"), &viewer);
    if !crate::repos::names::valid_owner(&owner) {
        return Err(Error::not_found(shell));
    }
    let repos =
        visible(&app, &shell, &viewer, db::repos::list_by_owner(&app.db, &owner).await.map_err(|e| Error::from_db(shell.clone(), e))?)
            .await?;
    let known = db::accounts::account_by_name(&app.db, &owner).await.map_err(|e| Error::from_db(shell.clone(), e))?.is_some()
        || db::accounts::org_by_name(&app.db, &owner).await.map_err(|e| Error::from_db(shell.clone(), e))?.is_some();
    if repos.is_empty() && !known {
        return Err(Error::not_found(shell));
    }
    Ok(Page(HomePage { description: String::new(), shell, repos, owner: Some(owner) }))
}

/// The repositories among `rows` the viewer may see: public ones, internal
/// ones when signed in, and those the viewer owns or collaborates on.
async fn visible(app: &Shared, shell: &Shell, viewer: &Viewer, rows: Vec<db::repos::RepoRow>) -> Result<Vec<db::repos::RepoRow>, Error> {
    let mine: Vec<i64> = match viewer.account() {
        Some(a) if a.is_admin => rows.iter().map(|r| r.id).collect(),
        Some(a) => db::accounts::visible_repo_ids(&app.db, a.id).await.map_err(|e| Error::from_db(shell.clone(), e))?,
        None => vec![],
    };
    let signed_in = viewer.signed_in();
    Ok(rows
        .into_iter()
        .filter(|r| match r.visibility() {
            Visibility::Public => true,
            Visibility::Internal => signed_in,
            Visibility::Private => mine.contains(&r.id),
        })
        .collect())
}

pub async fn health(State(app): State<Shared>) -> Response {
    let body = serde_json::json!({
        "ok": true,
        "version": env!("CARGO_PKG_VERSION"),
        "uptime_s": app.started.elapsed().as_secs(),
    });
    axum::Json(body).into_response()
}

/// The hub delegate identity object (hub spec §15.5), as `oxy identity
/// export` writes one, so policy holders can admit it.
pub async fn hub_key(State(app): State<Shared>) -> Response {
    (
        [(header::CONTENT_TYPE, "application/oxy-identity"), (header::CONTENT_DISPOSITION, "attachment; filename=\"hub.identity\"")],
        app.hub_key.bytes.clone(),
    )
        .into_response()
}