use itertools::Itertools as _;
use sqlx::sqlite::SqlitePool;

use super::Snapshot;
use crate::{
    channel::{self, repo::Provider as _},
    event::{Event, Sequence, repo::Provider as _},
    message::{self, repo::Provider as _},
    name,
    user::{self, 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, Error> {
        let mut tx = self.db.begin().await?;
        let resume_point = tx.sequence().current().await?;

        let user_histories = tx.users().all(resume_point).await?;
        let channel_histories = tx.channels().all(resume_point).await?;
        let message_histories = tx.messages().all(resume_point).await?;

        tx.commit().await?;

        let users = user_histories
            .iter()
            .filter_map(|user| user.as_of(resume_point))
            .collect();

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

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

        let user_events = user_histories
            .iter()
            .map(user::History::events)
            .kmerge_by(Sequence::merge)
            .filter(Sequence::up_to(resume_point))
            .map(Event::from);

        let channel_events = channel_histories
            .iter()
            .map(channel::History::events)
            .kmerge_by(Sequence::merge)
            .filter(Sequence::up_to(resume_point))
            .map(Event::from);

        let message_events = message_histories
            .iter()
            .map(message::History::events)
            .kmerge_by(Sequence::merge)
            .filter(Sequence::up_to(resume_point))
            .map(Event::from);

        let events = user_events
            .merge_by(channel_events, Sequence::merge)
            .merge_by(message_events, Sequence::merge)
            .collect();

        Ok(Snapshot {
            resume_point,
            users,
            channels,
            messages,
            events,
        })
    }
}

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

impl From<user::repo::LoadError> for Error {
    fn from(error: user::repo::LoadError) -> Self {
        use user::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(),
        }
    }
}