use sqlx::sqlite::SqlitePool;

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

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, sqlx::Error> {
        let mut tx = self.db.begin().await?;
        let resume_point = tx.sequence().current().await?;

        let logins = tx.logins().all(resume_point.into()).await?;
        let channels = tx.channels().all(resume_point.into()).await?;
        let messages = tx.messages().all(resume_point.into()).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,
        })
    }
}