pub mod models;

use crate::models::Event;
use serenity::prelude::TypeMapKey;
use sled::{open, Db, IVec, Result};
use std::path::Path;
use std::sync::Arc;

pub struct Database {
    db: Db,
}

impl Database {
    /// Open the database
    pub fn new(db_path: &Path) -> Result<Database> {
        let db = open(db_path)?;

        Ok(Self { db })
    }

    /// DB iterator
    fn db_iter(&self) -> sled::Iter {
        self.db.iter()
    }

    /// Get events by a filter
    pub fn filter_events<F>(&self, filter: F) -> Vec<Event>
    where
        F: Fn(&String, &Event) -> bool,
    {
        self.db_iter()
            .filter_map(|pair| {
                if let Ok((message_id, event)) = pair {
                    let event: Event = event.into();
                    let message_id: String = String::from_utf8(message_id.to_vec()).unwrap();
                    if filter(&message_id, &event) {
                        Some(event)
                    } else {
                        None
                    }
                } else {
                    None
                }
            })
            .collect()
    }

    /// Insert an event into the database
    pub fn insert_event(&self, event: &Event) -> Result<()> {
        let msg_id = &event.message_id;
        let event: IVec = event.into();
        self.db.insert(msg_id, event)?;

        Ok(())
    }

    /// Remove event from database
    pub fn remove_event(&self, event: &Event) -> Result<()> {
        self.db.remove(event.message_id.clone())?;

        Ok(())
    }

    /// Get event by name
    pub fn get_event_by_name(&self, event_name: &str) -> Option<Event> {
        self.filter_events(|_, e| e.event_name.as_str() == event_name)
            .pop()
    }

    /// Get all events
    pub fn get_all_events(&self) -> Vec<Event> {
        self.filter_events(|_, _| true)
    }

    /// Get event my discord msg id
    pub fn get_event_by_msg_id(&self, target_msg_id: &str) -> Option<Event> {
        self.filter_events(|msg_id, _| msg_id.as_str() == target_msg_id)
            .pop()
    }
}

impl TypeMapKey for Database {
    type Value = Arc<Database>;
}