jap_learn/src/core/deck.rs

use crate::app::AppState;
use crate::core::srs::{
    OrderMode, OrderModule, RandomSRSModule, SRSModule, SemiRandomSRSModule, WordOpenMode,
    WorstWordsSRSModule,
};
use crate::data::entities::*;
use crate::data_provider::card_stats::{load_stats_of_deck, update_stat_score};
use crate::data_provider::history::push_note;
use crate::notification::{MaybeError, NotificationData};
use chrono::{Local, Utc};
use parking_lot::Mutex;
use std::sync::Arc;

#[derive(Clone)]
pub struct DeckData {
    pub(crate) words: Vec<WordData>,
    pub(crate) set: Vec<CardStatistics>,
    current_word_index: Option<usize>,
    fsrs_indices: Vec<usize>,
    state: Arc<Mutex<AppState>>,
    order_module: OrderModule,
    settings: DeckSettings,
}
impl DeckData {
    pub fn new(
        settings: &DeckSettings,
        state: Arc<Mutex<AppState>>,
    ) -> Result<Self, NotificationData> {
        let state_for = state.clone();
        let state_locked = state.lock();

        let stats = load_stats_of_deck(settings, &state_locked.connection)?;
        let words = stats
            .iter()
            .map(|stat| {
                state_locked
                    .dictionary
                    .binary_search_by_key(&stat.word_id, |w| w.id)
                    .expect("No word found in dictionary")
            })
            .map(|index| &state_locked.dictionary[index])
            .cloned()
            .collect();

        let today = Local::now().date_naive();
        Ok(Self {
            fsrs_indices: stats
                .iter()
                .enumerate()
                .filter(|(_, c)| c.fsrs_open_day == today)
                .map(|(i, _)| i)
                .collect(),
            set: stats,
            words,
            current_word_index: None,
            state: state_for,
            order_module: match settings.open_mode {
                OrderMode::Default => OrderModule::SemiRandomSRS(SemiRandomSRSModule::new()),
                OrderMode::TrainWorstFirst => {
                    OrderModule::WorstWordsSRS(WorstWordsSRSModule::new())
                }
                OrderMode::FullRandom => OrderModule::RandomSRS(RandomSRSModule::new()),
            },
            settings: settings.clone(),
        })
    }

    pub fn next(&mut self) -> (WordData, CardStatistics) {
        let index = match self.order_module {
            OrderModule::SemiRandomSRS(ref mut module) => {
                if !module.initialized {
                    module.init(self.set.as_slice())
                }
                module.next(self.set.as_slice())
            }
            OrderModule::RandomSRS(ref mut module) => {
                if !module.initialized {
                    module.init(self.set.as_slice())
                }
                module.next(self.set.as_slice())
            }
            OrderModule::WorstWordsSRS(ref mut module) => {
                if !module.initialized {
                    module.init(self.set.as_slice())
                }
                module.next(self.set.as_slice())
            }
        };

        self.current_word_index = Some(index);
        (self.words[index].clone(), self.set[index].clone())
    }
    pub fn open(&mut self, status: WordOpenMode) -> MaybeError {
        if let Some(index) = self.current_word_index {
            let word: &mut CardStatistics = &mut self.set[index];
            let old_score = word.score;
            word.update(status);
            let new_score = word.score;

            match self.order_module {
                OrderModule::SemiRandomSRS(ref mut module) => {
                    module.open(status, index, word);
                }
                OrderModule::RandomSRS(ref mut module) => {
                    module.open(status, index, word);
                }
                OrderModule::WorstWordsSRS(ref mut module) => {
                    module.open(status, index, word);
                }
            }
            update_stat_score(word, &self.state.lock().connection)?;
            let _ = push_note(
                self.settings.id,
                HistoryItem {
                    timestamp: Utc::now(),
                    word_id: word.word_id,
                    mode: status,
                    before: old_score,
                    after: new_score,
                },
            );
        }

        Ok(())
    }
    pub fn len(&self) -> usize {
        self.set.len()
    }
}