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

use crate::{
    clock::DateTime,
    event::{Instant, Sequence},
    login::{self, password::StoredHash, History, Login},
};

pub trait Provider {
    fn auth(&mut self) -> Auth;
}

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

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

impl<'t> Auth<'t> {
    pub async fn for_name(&mut self, name: &str) -> Result<(History, StoredHash), sqlx::Error> {
        let found = sqlx::query!(
            r#"
				select
					id as "id: login::Id",
					name,
					password_hash as "password_hash: StoredHash",
                    created_sequence as "created_sequence: Sequence",
                    created_at as "created_at: DateTime"
				from login
				where name = $1
			"#,
            name,
        )
        .map(|row| {
            (
                History {
                    login: Login {
                        id: row.id,
                        name: row.name,
                    },
                    created: Instant {
                        at: row.created_at,
                        sequence: row.created_sequence,
                    },
                },
                row.password_hash,
            )
        })
        .fetch_one(&mut *self.0)
        .await?;

        Ok(found)
    }
}