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

use super::{History, repo::Provider as _, validate};
use crate::{
    clock::DateTime,
    event::{Broadcaster, Event, repo::Provider as _},
    name::Name,
    password::{Password, StoredHash},
};

#[must_use = "dropping a user creation attempt is likely a mistake"]
pub struct Create<'a> {
    name: &'a Name,
    password: &'a Password,
    created_at: &'a DateTime,
}

impl<'a> Create<'a> {
    pub fn begin(name: &'a Name, password: &'a Password, created_at: &'a DateTime) -> Self {
        Self {
            name,
            password,
            created_at,
        }
    }

    pub fn validate(self) -> Result<Validated<'a>, Error> {
        let Self {
            name,
            password,
            created_at,
        } = self;

        if !validate::name(name) {
            return Err(Error::InvalidName(name.clone()));
        }

        let password_hash = password.hash()?;

        Ok(Validated {
            name,
            password_hash,
            created_at,
        })
    }
}

#[must_use = "dropping a user creation attempt is likely a mistake"]
pub struct Validated<'a> {
    name: &'a Name,
    password_hash: StoredHash,
    created_at: &'a DateTime,
}

impl Validated<'_> {
    pub async fn store(self, tx: &mut Transaction<'_, Sqlite>) -> Result<Stored, sqlx::Error> {
        let Self {
            name,
            password_hash,
            created_at,
        } = self;

        let created = tx.sequence().next(created_at).await?;
        let user = tx.users().create(name, &password_hash, &created).await?;

        Ok(Stored { user })
    }
}

#[must_use = "dropping a user creation attempt is likely a mistake"]
pub struct Stored {
    user: History,
}

impl Stored {
    pub fn publish(self, events: &Broadcaster) {
        let Self { user } = self;

        events.broadcast(user.events().map(Event::from).collect::<Vec<_>>());
    }

    pub fn user(&self) -> &History {
        &self.user
    }
}

#[derive(Debug, thiserror::Error)]
pub enum Error {
    #[error("invalid user name: {0}")]
    InvalidName(Name),
    #[error(transparent)]
    PasswordHash(#[from] password_hash::Error),
}