//! Controlled vocabularies and terms.

use domain::{LocalizedLabel, NewTerm, Term, TermId, TermRef, Vocabulary, VocabularyId};
use sqlx::Row;

/// Labels aggregated per row as JSON, to read a term and its labels in one query.
const LABELS_JSON: &str = "COALESCE(json_agg(json_build_object('lang', tl.lang, 'label', tl.label) \
     ORDER BY tl.lang) FILTER (WHERE tl.term_id IS NOT NULL), '[]'::json)";

/// Create a vocabulary with the given key.
pub async fn create_vocabulary<'e, E>(executor: E, key: &str) -> Result<Vocabulary, sqlx::Error>
where
    E: sqlx::PgExecutor<'e>,
{
    let id = VocabularyId::new();

    sqlx::query("INSERT INTO vocabulary (id, key) VALUES ($1, $2)")
        .bind(id.to_uuid())
        .bind(key)
        .execute(executor)
        .await?;

    Ok(Vocabulary {
        id,
        key: key.to_owned(),
    })
}

/// List all vocabularies, ordered by key.
pub async fn list_vocabularies<'e, E>(executor: E) -> Result<Vec<Vocabulary>, sqlx::Error>
where
    E: sqlx::PgExecutor<'e>,
{
    let rows = sqlx::query("SELECT id, key FROM vocabulary ORDER BY key")
        .fetch_all(executor)
        .await?;

    rows.into_iter().map(map_vocabulary).collect()
}

/// Look up a vocabulary by its key.
pub async fn vocabulary_by_key<'e, E>(
    executor: E,
    key: &str,
) -> Result<Option<Vocabulary>, sqlx::Error>
where
    E: sqlx::PgExecutor<'e>,
{
    let row = sqlx::query("SELECT id, key FROM vocabulary WHERE key = $1")
        .bind(key)
        .fetch_optional(executor)
        .await?;

    row.map(map_vocabulary).transpose()
}

/// Insert a term and its labels. Multiple statements — pass a transaction
/// connection (`&mut *tx`) so the term and its labels commit atomically.
pub async fn add_term(conn: &mut sqlx::PgConnection, new: &NewTerm) -> Result<TermId, sqlx::Error> {
    let id = TermId::new();

    sqlx::query("INSERT INTO term (id, vocabulary_id, external_uri) VALUES ($1, $2, $3)")
        .bind(id.to_uuid())
        .bind(new.vocabulary_id.to_uuid())
        .bind(new.external_uri.as_deref())
        .execute(&mut *conn)
        .await?;

    for label in &new.labels {
        sqlx::query("INSERT INTO term_label (term_id, lang, label) VALUES ($1, $2, $3)")
            .bind(id.to_uuid())
            .bind(&label.lang)
            .bind(&label.label)
            .execute(&mut *conn)
            .await?;
    }

    Ok(id)
}

/// Fetch one term (with its labels).
pub async fn term_by_id<'e, E>(executor: E, id: TermId) -> Result<Option<Term>, sqlx::Error>
where
    E: sqlx::PgExecutor<'e>,
{
    let sql = format!(
        "SELECT t.id, t.vocabulary_id, t.external_uri, {LABELS_JSON} AS labels \
         FROM term t LEFT JOIN term_label tl ON tl.term_id = t.id \
         WHERE t.id = $1 GROUP BY t.id"
    );

    let row = sqlx::query(&sql)
        .bind(id.to_uuid())
        .fetch_optional(executor)
        .await?;

    row.map(map_term).transpose()
}

/// List all terms in a vocabulary (with labels), ordered by id.
pub async fn list_terms<'e, E>(
    executor: E,
    vocabulary_id: VocabularyId,
) -> Result<Vec<Term>, sqlx::Error>
where
    E: sqlx::PgExecutor<'e>,
{
    let sql = format!(
        "SELECT t.id, t.vocabulary_id, t.external_uri, {LABELS_JSON} AS labels \
         FROM term t LEFT JOIN term_label tl ON tl.term_id = t.id \
         WHERE t.vocabulary_id = $1 GROUP BY t.id ORDER BY t.id"
    );

    let rows = sqlx::query(&sql)
        .bind(vocabulary_id.to_uuid())
        .fetch_all(executor)
        .await?;

    rows.into_iter().map(map_term).collect()
}

/// Resolve a term to a [`TermRef`], confirming it belongs to `vocabulary_id`.
pub async fn resolve_term<'e, E>(
    executor: E,
    vocabulary_id: VocabularyId,
    term_id: TermId,
) -> Result<Option<TermRef>, sqlx::Error>
where
    E: sqlx::PgExecutor<'e>,
{
    let found =
        sqlx::query_scalar::<_, i32>("SELECT 1 FROM term WHERE id = $1 AND vocabulary_id = $2")
            .bind(term_id.to_uuid())
            .bind(vocabulary_id.to_uuid())
            .fetch_optional(executor)
            .await?;

    Ok(found.map(|_| TermRef::new(term_id, vocabulary_id)))
}

fn map_vocabulary(row: sqlx::postgres::PgRow) -> Result<Vocabulary, sqlx::Error> {
    Ok(Vocabulary {
        id: VocabularyId::from_uuid(row.try_get("id")?),
        key: row.try_get("key")?,
    })
}

fn map_term(row: sqlx::postgres::PgRow) -> Result<Term, sqlx::Error> {
    let labels: sqlx::types::Json<Vec<LocalizedLabel>> = row.try_get("labels")?;

    Ok(Term {
        id: TermId::from_uuid(row.try_get("id")?),
        vocabulary_id: VocabularyId::from_uuid(row.try_get("vocabulary_id")?),
        external_uri: row.try_get("external_uri")?,
        labels: labels.0,
    })
}