pub mod records;
mod sqlite;

use miette::{Diagnostic, Result};
use sqlite::SQLiteStore;
use thiserror::Error;

use records::{EquityChangeEvent, EquitySymbol, FiduciaryAccount};

pub enum Context {
    SQLite(SQLiteStore),
}

#[derive(Debug, Diagnostic, Error)]
pub enum ContextError {
    #[error("Data storage error")]
    DataError(#[from] ::sqlite::Error),
    #[error("Migration error")]
    MigrationError(#[from] crate::db::MigrationError),
    #[error("Int conversion error")]
    IntConversionError(#[from] std::num::TryFromIntError),
    #[error("Timestamp conversion error")]
    ChronoConversionError(#[from] chrono::ParseError),
    #[error("BigDecimal conversion error")]
    DecimalConversionError(#[from] bigdecimal::ParseBigDecimalError),
    #[error("Enum not translatable error")]
    EnumTranslationError(String),
    #[error("Item not found error")]
    ItemNotFoundError(),
}

impl Default for Context {
    fn default() -> Self {
        Context::SQLite(SQLiteStore::default())
    }
}

pub struct AppContext {
    context: Context,
    accounts: Vec<FiduciaryAccount>,
    symbols: Vec<EquitySymbol>,
    events: Vec<EquityChangeEvent>,
}

impl Default for AppContext {
    fn default() -> Self {
        AppContext {
            context: Context::default(),
            accounts: vec![],
            symbols: vec![],
            events: vec![],
        }
    }
}

pub trait Store {
    fn init(&mut self) -> Result<(), ContextError>;
    fn get_counter(&self) -> Result<u8, ContextError>;
    fn set_counter(&mut self, new_count: u8) -> Result<u8, ContextError>;
}

impl AppContext {
    pub fn unwrap_store(&mut self) -> &mut impl Store {
        match &mut self.context {
            Context::SQLite(store) => store,
        }
    }

    pub fn get_store(&self) -> &impl Store {
        match &self.context {
            Context::SQLite(store) => store,
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn context_default() {
        let context = Context::default();

        let res = match context {
            Context::SQLite(_) => true,
        };
        assert!(res);
    }
}