//! The JSON API (hub spec §12.1) under `/api/v1`. Milestone 0.1 exposes
//! repositories, bookmarks and tags; the rest follows the pages.

use crate::repos::{view, RepoError, RepoName};
use crate::{db, Shared};
use axum::extract::{Path, State};
use axum::http::StatusCode;
use axum::response::{IntoResponse, Response};
use axum::routing::get;
use axum::{Json, Router};
use hub_api::{Bookmark, Problem, Repository, Tag};

pub fn router() -> Router<Shared> {
    Router::new()
        .route("/repos", get(list_repos))
        .route("/repos/{owner}/{name}", get(get_repo))
        .route("/repos/{owner}/{name}/bookmarks", get(bookmarks))
        .route("/repos/{owner}/{name}/tags", get(tags))
        .route("/repos/{owner}/{name}/proposals", get(proposals))
        .route("/repos/{owner}/{name}/proposals/{number}", get(proposal))
}

/// The account a bearer token resolves to, for API calls that must see
/// what the caller may see.
async fn caller(app: &Shared, headers: &axum::http::HeaderMap) -> Result<Option<db::accounts::Account>, ApiError> {
    let Some(t) = oxy_server::bearer_token(headers) else { return Ok(None) };
    if app.config.auth.push_tokens.iter().any(|x| crate::auth::mac_equal(x, t)) {
        // A site token acts as an administrator.
        return Ok(db::accounts::accounts(&app.db).await?.into_iter().find(|a| a.is_admin));
    }
    let token = db::accounts::token_by_hash(&app.db, &crate::auth::token_hash(t)).await?;
    match token {
        Some(tok) if !tok.expired(db::now_ms()) => Ok(db::accounts::account_by_id(&app.db, tok.account_id).await?),
        _ => Err(ApiError(StatusCode::UNAUTHORIZED, "unknown or expired token".into())),
    }
}

async fn readable(
    app: &Shared,
    headers: &axum::http::HeaderMap,
    owner: &str,
    name: &str,
) -> Result<(RepoName, db::repos::RepoRow), ApiError> {
    let repo = RepoName::new(owner, name).ok_or(ApiError(StatusCode::NOT_FOUND, "no such repository".into()))?;
    let row = db::repos::get(&app.db, owner, name).await?.ok_or(ApiError(StatusCode::NOT_FOUND, "no such repository".into()))?;
    let account = caller(app, headers).await?;
    let role = crate::auth::roles::role_for(&app.db, account.as_ref(), &row).await?;
    if !crate::auth::roles::allows(role, crate::auth::Access::Read) {
        return Err(ApiError(StatusCode::NOT_FOUND, "no such repository".into()));
    }
    Ok((repo, row))
}

async fn proposals(
    State(app): State<Shared>,
    headers: axum::http::HeaderMap,
    Path((owner, name)): Path<(String, String)>,
) -> Result<Json<Vec<hub_api::Proposal>>, ApiError> {
    let (repo, row) = readable(&app, &headers, &owner, &name).await?;
    let mut out = Vec::new();
    for p in db::proposals::list(&app.db, row.id, &["open", "draft"]).await? {
        let loaded = crate::web::proposals::load(&app, &repo, p).await?;
        let v = crate::web::proposals::verdict(&app, &loaded, row.id).await?;
        out.push(crate::web::proposals::to_api(&app, &owner, &name, &loaded, &v, None).await);
    }
    Ok(Json(out))
}

async fn proposal(
    State(app): State<Shared>,
    headers: axum::http::HeaderMap,
    Path((owner, name, number)): Path<(String, String, i64)>,
) -> Result<Json<hub_api::Proposal>, ApiError> {
    let (repo, row) = readable(&app, &headers, &owner, &name).await?;
    let p = db::proposals::get(&app.db, row.id, number).await?.ok_or(ApiError(StatusCode::NOT_FOUND, "no such proposal".into()))?;
    let source_url = match p.source_repo_id {
        Some(id) => db::repos::get_by_id(&app.db, id).await?.map(|r| format!("{}/{}", app.config.base_url(), r.slug())),
        None => None,
    };
    let loaded = crate::web::proposals::load(&app, &repo, p).await?;
    let v = crate::web::proposals::verdict(&app, &loaded, row.id).await?;
    Ok(Json(crate::web::proposals::to_api(&app, &owner, &name, &loaded, &v, source_url).await))
}

pub struct ApiError(StatusCode, String);

impl IntoResponse for ApiError {
    fn into_response(self) -> Response {
        let body = Problem { status: self.0.as_u16(), title: self.0.canonical_reason().unwrap_or("error").into(), detail: self.1 };
        (self.0, [("content-type", "application/problem+json")], Json(body)).into_response()
    }
}

impl From<RepoError> for ApiError {
    fn from(e: RepoError) -> ApiError {
        match e {
            RepoError::NotFound => ApiError(StatusCode::NOT_FOUND, "no such repository".into()),
            other => ApiError(StatusCode::INTERNAL_SERVER_ERROR, other.to_string()),
        }
    }
}

impl From<sqlx::Error> for ApiError {
    fn from(e: sqlx::Error) -> ApiError {
        ApiError(StatusCode::INTERNAL_SERVER_ERROR, e.to_string())
    }
}

fn repository(app: &Shared, r: &db::repos::RepoRow) -> Repository {
    Repository {
        owner: r.owner.clone(),
        name: r.name.clone(),
        description: r.description.clone(),
        default_bookmark: r.default_bookmark.clone(),
        visibility: r.visibility(),
        created_ms: r.created_ms,
        updated_ms: r.updated_ms,
        clone_url: format!("{}/{}/{}", app.config.base_url(), r.owner, r.name),
    }
}

async fn public_row(app: &Shared, owner: &str, name: &str) -> Result<(RepoName, db::repos::RepoRow), ApiError> {
    let repo = RepoName::new(owner, name).ok_or(ApiError(StatusCode::NOT_FOUND, "no such repository".into()))?;
    let row = db::repos::get(&app.db, owner, name).await?.filter(|r| r.visibility() == hub_api::Visibility::Public);
    Ok((repo, row.ok_or(ApiError(StatusCode::NOT_FOUND, "no such repository".into()))?))
}

async fn list_repos(State(app): State<Shared>) -> Result<Json<Vec<Repository>>, ApiError> {
    let rows = db::repos::list(&app.db).await?;
    Ok(Json(rows.iter().filter(|r| r.visibility() == hub_api::Visibility::Public).map(|r| repository(&app, r)).collect()))
}

async fn get_repo(State(app): State<Shared>, Path((owner, name)): Path<(String, String)>) -> Result<Json<Repository>, ApiError> {
    let (_, row) = public_row(&app, &owner, &name).await?;
    Ok(Json(repository(&app, &row)))
}

async fn bookmarks(State(app): State<Shared>, Path((owner, name)): Path<(String, String)>) -> Result<Json<Vec<Bookmark>>, ApiError> {
    let (repo, row) = public_row(&app, &owner, &name).await?;
    let default = row.default_bookmark.clone();
    let list = app.repos.read(&repo, move |r, cache| view::bookmarks(r, cache, &default)).await?;
    Ok(Json(list.into_iter().map(|b| Bookmark { name: b.name, heads: b.heads, changes: b.changes, default: b.default }).collect()))
}

async fn tags(State(app): State<Shared>, Path((owner, name)): Path<(String, String)>) -> Result<Json<Vec<Tag>>, ApiError> {
    let (repo, _) = public_row(&app, &owner, &name).await?;
    let list = app.repos.read(&repo, |r, _| view::tags(r)).await?;
    Ok(Json(list.into_iter().map(|t| Tag { name: t.name, heads: t.heads, message: t.message, signer: t.signer }).collect()))
}