use std::fmt;

use sqlx::{sqlite::Sqlite, SqliteConnection, Transaction};

pub trait Provider {
    fn sequence(&mut self) -> Sequences;
}

impl<'c> Provider for Transaction<'c, Sqlite> {
    fn sequence(&mut self) -> Sequences {
        Sequences(self)
    }
}

pub struct Sequences<'t>(&'t mut SqliteConnection);

impl<'c> Sequences<'c> {
    pub async fn next(&mut self) -> Result<Sequence, sqlx::Error> {
        let next = sqlx::query_scalar!(
            r#"
                update event_sequence
                set last_value = last_value + 1
                returning last_value as "next_value: Sequence"
            "#,
        )
        .fetch_one(&mut *self.0)
        .await?;

        Ok(next)
    }

    pub async fn current(&mut self) -> Result<Sequence, sqlx::Error> {
        let next = sqlx::query_scalar!(
            r#"
                select last_value as "last_value: Sequence"
                from event_sequence
            "#,
        )
        .fetch_one(&mut *self.0)
        .await?;

        Ok(next)
    }
}

#[derive(
    Clone,
    Copy,
    Debug,
    Eq,
    Ord,
    PartialEq,
    PartialOrd,
    serde::Deserialize,
    serde::Serialize,
    sqlx::Type,
)]
#[serde(transparent)]
#[sqlx(transparent)]
pub struct Sequence(i64);

impl fmt::Display for Sequence {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let Self(value) = self;
        value.fmt(f)
    }
}