use sqlx::sqlite::SqlitePool;

use super::Snapshot;
use crate::{
    channel::{self, repo::Provider as _},
    event::repo::Provider as _,
    login::{self, repo::Provider as _},
    message::repo::Provider as _,
    name,
};

pub struct Boot<'a> {
    db: &'a SqlitePool,
}

impl<'a> Boot<'a> {
    pub const fn new(db: &'a SqlitePool) -> Self {
        Self { db }
    }

    pub async fn snapshot(&self) -> Result<Snapshot, Error> {
        let mut tx = self.db.begin().await?;
        let resume_point = tx.sequence().current().await?;

        let logins = tx.logins().all(resume_point).await?;
        let channels = tx.channels().all(resume_point).await?;
        let messages = tx.messages().all(resume_point).await?;

        tx.commit().await?;

        let logins = logins
            .into_iter()
            .filter_map(|login| login.as_of(resume_point))
            .collect();

        let channels = channels
            .into_iter()
            .filter_map(|channel| channel.as_of(resume_point))
            .collect();

        let messages = messages
            .into_iter()
            .filter_map(|message| message.as_of(resume_point))
            .collect();

        Ok(Snapshot {
            resume_point,
            logins,
            channels,
            messages,
        })
    }
}

#[derive(Debug, thiserror::Error)]
#[error(transparent)]
pub enum Error {
    Name(#[from] name::Error),
    Database(#[from] sqlx::Error),
}

impl From<login::repo::LoadError> for Error {
    fn from(error: login::repo::LoadError) -> Self {
        use login::repo::LoadError;
        match error {
            LoadError::Name(error) => error.into(),
            LoadError::Database(error) => error.into(),
        }
    }
}

impl From<channel::repo::LoadError> for Error {
    fn from(error: channel::repo::LoadError) -> Self {
        use channel::repo::LoadError;
        match error {
            LoadError::Name(error) => error.into(),
            LoadError::Database(error) => error.into(),
        }
    }
}