//! 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))
}

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| view::bookmarks(r, &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, view::tags).await?;
    Ok(Json(list.into_iter().map(|t| Tag { name: t.name, heads: t.heads, message: t.message, signer: t.signer }).collect()))
}