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(

src/core/srs.rs

@@ -1,4 +1,6 @@
 use crate::data::entities::CardStatistics;
+use chrono::Local;
+use fsrs::FSRS;
 use rand::distr::weighted::WeightedIndex;
 use rand::prelude::ThreadRng;
 use rand::prelude::{Distribution, SliceRandom};
@@ -8,7 +10,7 @@ const MAX_HISTORY_LEN: usize = 20;
 const MAX_HISTORY_LEN_PART: f32 = 0.33;
 pub const MAX_SCORE: u8 = 25;
 pub const FADE_PER_DAY: f32 = 0.95;
-
+const PARTIAL_POOL_SIZE: usize = 10;
 #[derive(Clone, PartialEq, Copy, Eq)]
 pub enum OrderMode {
     Default,
@@ -26,10 +28,11 @@ pub enum OrderModule {
     SemiRandomSRS(SemiRandomSRSModule),
     RandomSRS(RandomSRSModule),
     WorstWordsSRS(WorstWordsSRSModule),
+    FSRS(FsrsModule),
 }
 pub trait SRSModule {
     fn next(&mut self, set: &[CardStatistics]) -> usize;
-    fn open(&mut self, status: WordOpenMode, index: usize, updated_word: &CardStatistics);
+    fn open(&mut self, status: WordOpenMode, index: usize, updated_word: &mut CardStatistics);
     fn init(&mut self, set: &[CardStatistics]);
 }
 #[derive(Clone)]
@@ -57,7 +60,7 @@ impl SRSModule for RandomSRSModule {
         }
     }
 
-    fn open(&mut self, _: WordOpenMode, _: usize, _: &CardStatistics) {}
+    fn open(&mut self, _: WordOpenMode, _: usize, _: &mut CardStatistics) {}
 
     fn init(&mut self, set: &[CardStatistics]) {
         self.initialized = true;
@@ -97,7 +100,7 @@ impl SRSModule for SemiRandomSRSModule {
 
         index
     }
-    fn open(&mut self, _: WordOpenMode, index: usize, word: &CardStatistics) {
+    fn open(&mut self, _: WordOpenMode, index: usize, word: &mut CardStatistics) {
         let new_weight = (100.0 / word.calculated_score()).powf(2.0);
         self.last_weights
             .update_weights(&[(index, &new_weight)])
@@ -143,7 +146,7 @@ impl SRSModule for WorstWordsSRSModule {
         }
     }
 
-    fn open(&mut self, _: WordOpenMode, _: usize, _: &CardStatistics) {}
+    fn open(&mut self, _: WordOpenMode, _: usize, _: &mut CardStatistics) {}
 
     fn init(&mut self, _: &[CardStatistics]) {
         self.initialized = true;
@@ -153,7 +156,7 @@ impl WorstWordsSRSModule {
     pub(crate) fn new() -> WorstWordsSRSModule {
         WorstWordsSRSModule {
             initialized: false,
-            pool_size: 15,
+            pool_size: PARTIAL_POOL_SIZE,
             rounds_count: 2,
             rounds_remaining: 0,
             pool: vec![],
@@ -172,6 +175,91 @@ impl WorstWordsSRSModule {
     }
 }
 
+#[derive(Clone)]
+pub struct FsrsModule {
+    today_set: Vec<usize>,
+    solved: Vec<usize>,
+    current_group: Vec<usize>,
+    queue: Vec<usize>,
+    rng: ThreadRng,
+    fsrs: FSRS,
+    pub(crate) initialized: bool
+}
+
+impl SRSModule for FsrsModule {
+    fn next(&mut self, set: &[CardStatistics]) -> usize {
+        if self.solved.len() == self.current_group.len() {
+            self.fill_partial_pool();
+        }
+
+        if self.queue.is_empty() {
+            self.fill_queue();
+            self.queue.shuffle(&mut self.rng);
+        }
+
+        self.queue.pop().expect("empty queue")
+    }
+
+    fn open(&mut self, status: WordOpenMode, index: usize, updated_word: &mut CardStatistics) {
+        let today = Local::now().date_naive();
+        let delta = today - updated_word.fsrs_opened;
+        let delta_days = delta.num_days();
+        
+        if updated_word.fsrs_open_day != today{ 
+            self.solved.push(index);
+        }
+    }
+
+    fn init(&mut self, set: &[CardStatistics]) {
+        self.rng = rng();
+        let today = Local::now().date_naive();
+        self.today_set = set
+            .iter()
+            .enumerate()
+            .filter(|(_, c)| c.fsrs_open_day <= today)
+            .map(|(index, _)| index)
+            .collect();
+        self.today_set.shuffle(&mut self.rng);
+        self.fill_partial_pool();
+        self.initialized = true;
+    }
+}
+
+impl FsrsModule {
+    pub fn new() -> Self{
+        Self{
+            today_set: vec![],
+            current_group: vec![],
+            queue: vec![],
+            solved: vec![],
+            rng: Default::default(),
+            fsrs: FSRS::default(),
+            initialized: false,
+        }
+    }
+    fn fill_partial_pool(&mut self) {
+        self.current_group.clear();
+        self.current_group
+            .extend(self.today_set.iter().take(PARTIAL_POOL_SIZE));
+        self.current_group.iter().for_each(|_| {
+            self.today_set.remove(0);
+        });
+        self.queue.clear();
+        self.queue
+            .extend(self.current_group.clone());
+        self.solved.clear();
+    }
+
+    fn fill_queue(&mut self) {
+        self.queue.clear();
+        self.queue.extend(self.current_group.iter().filter(|c| !self.today_set.contains(*c)));
+    }
+
+    pub fn finished(&self) -> bool {
+        self.today_set.len() == self.solved.len()
+    }
+}
+
 #[derive(Clone, Copy)]
 pub enum WordOpenMode {
     Easy,