rename tables

src/core/deck.rs

@@ -1,13 +1,14 @@
 use crate::app::AppState;
+use crate::core::srs::OrderModule::{WorstWordsSRS, FSRS, RandomSRS, SemiRandomSRS};
 use crate::core::srs::{
-    OrderMode, OrderModule, RandomSRSModule, SRSModule, SemiRandomSRSModule, WordOpenMode,
-    WorstWordsSRSModule,
+    FsrsModule, 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 chrono::Utc;
 use parking_lot::Mutex;
 use std::sync::Arc;
 
@@ -16,9 +17,9 @@ 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,
+    open_mode: OrderMode,
     settings: DeckSettings,
 }
 impl DeckData {
@@ -41,45 +42,40 @@ impl DeckData {
             .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()),
-            },
+            order_module: FSRS(FsrsModule::new()),
+            open_mode: settings.open_mode,
             settings: settings.clone(),
         })
     }
 
     pub fn next(&mut self) -> (WordData, CardStatistics) {
         let index = match self.order_module {
-            OrderModule::SemiRandomSRS(ref mut module) => {
+            SemiRandomSRS(ref mut module) => {
                 if !module.initialized {
                     module.init(self.set.as_slice())
                 }
                 module.next(self.set.as_slice())
             }
-            OrderModule::RandomSRS(ref mut module) => {
+            
+            RandomSRS(ref mut module) => {
                 if !module.initialized {
                     module.init(self.set.as_slice())
                 }
                 module.next(self.set.as_slice())
             }
-            OrderModule::WorstWordsSRS(ref mut module) => {
+            WorstWordsSRS(ref mut module) => {
+                if !module.initialized {
+                    module.init(self.set.as_slice())
+                }
+                module.next(self.set.as_slice())
+            }
+            FSRS(ref mut module) => {
                 if !module.initialized {
                     module.init(self.set.as_slice())
                 }
@@ -98,15 +94,32 @@ impl DeckData {
             let new_score = word.score;
 
             match self.order_module {
-                OrderModule::SemiRandomSRS(ref mut module) => {
+                SemiRandomSRS(ref mut module) => {
                     module.open(status, index, word);
                 }
-                OrderModule::RandomSRS(ref mut module) => {
+                RandomSRS(ref mut module) => {
                     module.open(status, index, word);
                 }
-                OrderModule::WorstWordsSRS(ref mut module) => {
+                WorstWordsSRS(ref mut module) => {
                     module.open(status, index, word);
                 }
+                FSRS(ref mut module) => {
+                    module.open(status, index, word);
+                }
+            }
+
+            if let FSRS(ref fsrs) = self.order_module {
+                if fsrs.finished() {
+                    self.order_module = match self.open_mode {
+                        OrderMode::Default => {
+                            SemiRandomSRS(SemiRandomSRSModule::new())
+                        }
+                        OrderMode::TrainWorstFirst => {
+                            WorstWordsSRS(WorstWordsSRSModule::new())
+                        }
+                        OrderMode::FullRandom => RandomSRS(RandomSRSModule::new()),
+                    }
+                }
             }
             update_stat_score(word, &self.state.lock().connection)?;
             let _ = push_note(