jap_learn/src/core/deck.rs

use std::sync::Arc;
use std::time::Instant;
use chrono::Utc;
use crate::app::AppState;
use crate::core::srs::OrderModule::{Fsrs, RandomSRS, SemiRandomSRS, WorstWordsSRS};
use crate::core::srs::{
    OrderMode, OrderModule, RandomSRSModule, SRSModule, SemiRandomSRSModule,
    WordOpenMode, WorstWordsSRSModule,
};
use crate::data::entities::*;
use crate::data_provider::card_states::{CardStateRepositoryInner};
use crate::notification::{MaybeError, NotificationData};
use log::info;
use rhai::{Engine, Scope};
use crate::data::repositories::Repository;

#[derive(Clone)]
pub struct DeckData {
    pub(crate) words: Vec<EntityHandle<WordData>>,
    pub(crate) set: Vec<EntityHandle<CardState>>,
    current_word_index: Option<usize>,
    state: AppState,
    order_module: OrderModule,
    open_mode: OrderMode,
    settings: DeckSettings,
}
impl DeckData {
    pub fn new(
        settings: &DeckSettings,
        state: AppState,
    ) -> Result<Self, NotificationData> {
        todo!()
        // let state_for = state.clone();
        //
        // let stats = state (settings, &state.connection.read())?;
        // let words = stats
        //     .iter()
        //     .map(|stat| {
        //         state
        //             .dictionary
        //             .binary_search_by_key(&stat.word_id, |w| w.id)
        //             .expect("No word found in dictionary")
        //     })
        //     .map(|index| &state.dictionary[index])
        //     .cloned()
        //     .collect();
        //
        // Ok(Self {
        //     set: stats,
        //     words,
        //     current_word_index: None,
        //     state: state_for,
        //     order_module: Fsrs(FsrsModule::new()),
        //     open_mode: settings.open_mode,
        //     settings: settings.clone(),
        // })
    }

    pub fn next(&mut self) -> (EntityHandle<WordData>, EntityHandle<CardState>) {
        let repo = self.state.card_states.read();
        let links = Self::set_links(self.set.as_slice(), &repo);
        let index = match self.order_module {
            SemiRandomSRS(ref mut module) => {
                if !module.initialized {
                    module.init(links.as_slice());
                }
                module.next(links.as_slice())
            }

            RandomSRS(ref mut module) => {
                if !module.initialized {
                    module.init(links.as_slice())
                }
                module.next(links.as_slice())
            }
            WorstWordsSRS(ref mut module) => {
                if !module.initialized {
                    module.init(links.as_slice())
                }
                module.next(links.as_slice())
            }
            Fsrs(ref mut module) => {
                if !module.initialized {
                    module.init(links.as_slice())
                }
                module.next(links.as_slice())
            }
        };

        self.current_word_index = Some(index);
        (self.words[index].clone(), self.set[index].clone())
    }

    fn set_links<'a>(set: &[EntityHandle<CardState>], repo: &'a CardStateRepositoryInner) -> Vec<&'a CardState>  {
        set.iter().map(|h| repo.get_ref_static(*h).unwrap()).collect::<Vec<_>>()
    }

    pub fn open(&mut self, status: WordOpenMode) -> MaybeError {
        if let Some(index) = self.current_word_index {
            let mut repo = self.state.card_states.write();
            let card_state_handle = &mut self.set[index];
            let card_state = repo.get_mut(card_state_handle).unwrap();
            let old_score = card_state.score;
            card_state.update(status);
            let new_score = card_state.score;

            let mut fsrs = false;
            match self.order_module {
                SemiRandomSRS(ref mut module) => {
                    module.open(status, index, card_state);
                }
                RandomSRS(ref mut module) => {
                    module.open(status, index, card_state);
                }
                WorstWordsSRS(ref mut module) => {
                    module.open(status, index, card_state);
                }
                Fsrs(ref mut module) => {
                    module.open(status, index, card_state);
                    fsrs = true;
                }
            }

            if let Fsrs(ref fsrs) = self.order_module
                && fsrs.finished()
            {
                self.order_module = match self.open_mode {
                    OrderMode::Default => SemiRandomSRS(SemiRandomSRSModule::new()),
                    OrderMode::TrainWorstFirst => WorstWordsSRS(WorstWordsSRSModule::new()),
                    OrderMode::FullRandom => RandomSRS(RandomSRSModule::new()),
                }
            }

            let word_id = card_state.word_id;
            repo.save(card_state_handle)?;

            let mut history = self.state.history.write();
            history.create_now(HistoryNote {
                id: Default::default(),
                timestamp: Utc::now(),
                set_id: self.settings.id,
                word_id,
                answer: status.clone(),
                before: old_score,
                after: new_score,
                fsrs,
            })?;
            todo!("Implement history pushing")
            // let _ = push_note(
            //     self.settings.id,
            //     HistoryNote {
            //         timestamp: Utc::now(),
            //         word_id: word.word_id,
            //         answer: status,
            //         before: old_score,
            //         after: new_score,
            //     },
            // );
        }

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

    pub fn list(deck: &DeckSettings, state: &AppState) -> Vec<EntityHandle<WordData>> {
        let time = Instant::now();
        let list = vec![];
        let engine = Engine::new();

        let ast = engine.compile(&deck.filter);
        if let Ok(ast) = ast {
            let groups = state.word_groups.read().iter().cloned().collect::<Vec<_>>();
            let dictionary = &state.dictionary.read();
            let query = dictionary.query_par(Arc::new(move |word| {
                let mut more = rhai::Map::new();
                for iced in &word.additional {
                    more.insert(iced.0.clone().into(), iced.1.clone().into());
                }
                let mut scope = Scope::new();
                let group_name = groups[groups.binary_search_by_key(&word.group_id, |g| g.id).unwrap()].name.clone();
                scope
                    .push_constant("id", word.id.0 as i64)
                    .push_constant("key", word.key.clone())
                    .push_constant("value", word.value.clone())
                    .push_constant("tags", word.tags.clone())
                    .push_constant("more", more)
                    .push_constant(
                        "group",
                        group_name,
                    );

                let result = engine.eval_ast_with_scope::<bool>(&mut scope, &ast);
                if let Ok(result) = result {
                    return result;
                }
                false
            }));

            info!("Collecting available words is {:?}", time.elapsed());
            let handles =query.handles().collect();
            drop(query);
            handles
        } else {
            list
        }
    }
}