Merge pull request 'Fsrs' (#12) from fsrs into master

Reviewed-on: https://gitea.micialware.ru/micialware/jap_learn/pulls/12

Cargo.lock

@@ -1003,7 +1003,7 @@ dependencies = [
  "ciborium",
  "clap",
  "criterion-plot",
- "itertools",
+ "itertools 0.13.0",
  "num-traits",
  "oorandom",
  "page_size",
@@ -1023,7 +1023,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d8d80a2f4f5b554395e47b5d8305bc3d27813bacb73493eb1001e8f76dae29ea"
 dependencies = [
  "cast",
- "itertools",
+ "itertools 0.13.0",
 ]
 
 [[package]]
@@ -1066,7 +1066,7 @@ dependencies = [
  "cosmic-text",
  "etagere",
  "lru",
- "rustc-hash 2.1.3",
+ "rustc-hash 2.1.1",
  "wgpu",
 ]
 
@@ -1529,6 +1529,23 @@ version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "42703706b716c37f96a77aea830392ad231f44c9e9a67872fa5548707e11b11c"
 
+[[package]]
+name = "fsrs"
+version = "6.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8a99ea3dec9af37c9ed3835463ff6820a578a0026a8e370b4c1c0db48dfab3f"
+dependencies = [
+ "itertools 0.14.0",
+ "log",
+ "ndarray",
+ "priority-queue",
+ "rand",
+ "rayon",
+ "serde",
+ "snafu",
+ "strum",
+]
+
 [[package]]
 name = "futures"
 version = "0.3.31"
@@ -2074,7 +2091,7 @@ dependencies = [
  "lilt",
  "log",
  "num-traits",
- "rustc-hash 2.1.3",
+ "rustc-hash 2.1.1",
  "smol_str",
  "thiserror 2.0.18",
  "web-time",
@@ -2100,7 +2117,7 @@ dependencies = [
  "futures",
  "iced_core",
  "log",
- "rustc-hash 2.1.3",
+ "rustc-hash 2.1.1",
  "tokio",
  "wasm-bindgen-futures",
  "wasmtimer",
@@ -2120,7 +2137,7 @@ dependencies = [
  "iced_futures",
  "log",
  "raw-window-handle",
- "rustc-hash 2.1.3",
+ "rustc-hash 2.1.1",
  "thiserror 2.0.18",
  "unicode-segmentation",
 ]
@@ -2174,7 +2191,7 @@ dependencies = [
  "kurbo 0.10.4",
  "log",
  "resvg",
- "rustc-hash 2.1.3",
+ "rustc-hash 2.1.1",
  "softbuffer",
  "tiny-skia",
 ]
@@ -2195,7 +2212,7 @@ dependencies = [
  "iced_graphics",
  "log",
  "resvg",
- "rustc-hash 2.1.3",
+ "rustc-hash 2.1.1",
  "thiserror 2.0.18",
  "wgpu",
 ]
@@ -2210,7 +2227,7 @@ dependencies = [
  "log",
  "num-traits",
  "ouroboros",
- "rustc-hash 2.1.3",
+ "rustc-hash 2.1.1",
  "thiserror 2.0.18",
  "unicode-segmentation",
 ]
@@ -2225,7 +2242,7 @@ dependencies = [
  "iced_program",
  "log",
  "mundy",
- "rustc-hash 2.1.3",
+ "rustc-hash 2.1.1",
  "thiserror 2.0.18",
  "tracing",
  "wasm-bindgen-futures",
@@ -2411,6 +2428,15 @@ dependencies = [
  "either",
 ]
 
+[[package]]
+name = "itertools"
+version = "0.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b192c782037fadd9cfa75548310488aabdbf3d2da73885b31bd0abd03351285"
+dependencies = [
+ "either",
+]
+
 [[package]]
 name = "itoa"
 version = "1.0.17"
@@ -2425,6 +2451,7 @@ dependencies = [
  "criterion",
  "dirs",
  "env_logger",
+ "fsrs",
  "hashbrown 0.17.1",
  "hex",
  "iced",
@@ -2439,7 +2466,6 @@ dependencies = [
  "rhai",
  "rodio",
  "rusqlite",
- "rustc-hash 2.1.3",
  "serde_json",
  "sha2",
  "tokio",
@@ -2776,6 +2802,16 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "matrixmultiply"
+version = "0.3.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f607c237553f086e7043417a51df26b2eb899d3caff94e6a67592ff992fedc7"
+dependencies = [
+ "autocfg",
+ "rawpointer",
+]
+
 [[package]]
 name = "memchr"
 version = "2.8.0"
@@ -2912,6 +2948,21 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "ndarray"
+version = "0.17.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "520080814a7a6b4a6e9070823bb24b4531daac8c4627e08ba5de8c5ef2f2752d"
+dependencies = [
+ "matrixmultiply",
+ "num-complex",
+ "num-integer",
+ "num-traits",
+ "portable-atomic",
+ "portable-atomic-util",
+ "rawpointer",
+]
+
 [[package]]
 name = "ndk"
 version = "0.9.0"
@@ -2961,6 +3012,15 @@ dependencies = [
  "num-traits",
 ]
 
+[[package]]
+name = "num-complex"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "73f88a1307638156682bada9d7604135552957b7818057dcef22705b4d509495"
+dependencies = [
+ "num-traits",
+]
+
 [[package]]
 name = "num-conv"
 version = "0.2.2"
@@ -3773,6 +3833,17 @@ dependencies = [
  "syn 2.0.114",
 ]
 
+[[package]]
+name = "priority-queue"
+version = "2.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93980406f12d9f8140ed5abe7155acb10bb1e69ea55c88960b9c2f117445ef96"
+dependencies = [
+ "equivalent",
+ "indexmap",
+ "serde",
+]
+
 [[package]]
 name = "proc-macro-crate"
 version = "3.4.0"
@@ -3836,7 +3907,7 @@ dependencies = [
  "pin-project-lite",
  "quinn-proto",
  "quinn-udp",
- "rustc-hash 2.1.3",
+ "rustc-hash 2.1.1",
  "rustls",
  "socket2",
  "thiserror 2.0.18",
@@ -3858,7 +3929,7 @@ dependencies = [
  "rand",
  "rand_pcg",
  "ring",
- "rustc-hash 2.1.3",
+ "rustc-hash 2.1.1",
  "rustls",
  "rustls-pki-types",
  "slab",
@@ -3951,6 +4022,12 @@ version = "0.6.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "20675572f6f24e9e76ef639bc5552774ed45f1c30e2951e1e99c59888861c539"
 
+[[package]]
+name = "rawpointer"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "60a357793950651c4ed0f3f52338f53b2f809f32d83a07f72909fa13e4c6c1e3"
+
 [[package]]
 name = "rayon"
 version = "1.12.0"
@@ -4257,9 +4334,9 @@ checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
 
 [[package]]
 name = "rustc-hash"
-version = "2.1.3"
+version = "2.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6b1e7f9a428571be2dc5bc0505c13fb6bf936822b894ec87abf8a08a4e51742d"
+checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d"
 
 [[package]]
 name = "rustc_version"
@@ -4716,6 +4793,27 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "snafu"
+version = "0.9.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e45cb604038abb7b926b679887b3226d8d0f23874b66623625a0454be425a4b7"
+dependencies = [
+ "snafu-derive",
+]
+
+[[package]]
+name = "snafu-derive"
+version = "0.9.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "287f59010008f0d7cf5e3b03196d666c1acc46c8d3e9cf34c28a1a7157601e72"
+dependencies = [
+ "heck 0.5.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.114",
+]
+
 [[package]]
 name = "socket2"
 version = "0.6.3"
@@ -4805,6 +4903,27 @@ dependencies = [
  "float-cmp",
 ]
 
+[[package]]
+name = "strum"
+version = "0.28.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9628de9b8791db39ceda2b119bbe13134770b56c138ec1d3af810d045c04f9bd"
+dependencies = [
+ "strum_macros",
+]
+
+[[package]]
+name = "strum_macros"
+version = "0.28.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab85eea0270ee17587ed4156089e10b9e6880ee688791d45a905f5b1ca36f664"
+dependencies = [
+ "heck 0.5.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.114",
+]
+
 [[package]]
 name = "subtle"
 version = "2.6.1"

Cargo.toml

@@ -26,23 +26,21 @@ rayon = "1.12.0"
 parking_lot = "0.12.5"
 env_logger = "0.11.11"
 log = "0.4.34"
+fsrs = "6.6.1"
 
 [profile.super-release]
 inherits = "release"
 codegen-units = 1
 lto = true
 opt-level = 3
-strip = true
+#strip = true
 panic = "abort"
 
 [dev-dependencies]
 criterion = { version = "0.8.2", features = ["html_reports"] }
-rustc-hash = "2.1.3"
 
 [[bench]]
 name = "map_bench"
 harness = false
 
-[[bench]]
+
-name = "repo_cache_bench"
-harness = false

benches/repo_cache_bench.rs

@@ -1,325 +0,0 @@
-use criterion::{BenchmarkId, Criterion, criterion_group, criterion_main};
-use hashbrown::HashMap as HashbrownMap;
-use rustc_hash::FxHashMap;
-use std::collections::{BTreeMap, HashMap};
-use std::hint::black_box;
-
-// Тестовая структура (аналог вашей сущности)
-#[derive(Debug, Clone)]
-struct Entity {
-    id: i64,
-    data: [u8; 64], // 64 байта данных для реалистичности
-}
-
-impl Entity {
-    fn new(id: i64) -> Self {
-        Self {
-            id,
-            data: [id as u8; 64],
-        }
-    }
-}
-
-// ========== ТЕСТОВЫЕ ФУНКЦИИ ==========
-
-fn bench_vec_insert_sorted(vec: &mut Vec<Entity>, entities: &[Entity]) {
-    vec.clear();
-    for entity in entities {
-        vec.push(entity.clone());
-    }
-    // Vec уже отсортирован, так как ID монотонно возрастают
-}
-
-fn bench_vec_search_separated<'a>(ids: &[i64], vec: &'a [Entity], id: i64) -> Option<&'a Entity> {
-    match ids.binary_search(&id) {
-        Ok(index) => Some(&vec[index]),
-        Err(_) => None,
-    }
-}
-
-fn bench_vec_search(vec: &Vec<Entity>, id: i64) -> Option<&Entity> {
-    match vec.binary_search_by(|probe| probe.id.cmp(&id)) {
-        Ok(index) => Some(&vec[index]),
-        Err(_) => None,
-    }
-}
-
-fn bench_btreemap_insert(map: &mut BTreeMap<i64, Entity>, entities: &[Entity]) {
-    map.clear();
-    for entity in entities {
-        map.insert(entity.id, entity.clone());
-    }
-}
-
-fn bench_btreemap_search(map: &BTreeMap<i64, Entity>, id: i64) -> Option<&Entity> {
-    map.get(&id)
-}
-
-fn bench_hashmap_insert(map: &mut HashMap<i64, Entity>, entities: &[Entity]) {
-    map.clear();
-    for entity in entities {
-        map.insert(entity.id, entity.clone());
-    }
-}
-
-fn bench_hashmap_search(map: &HashMap<i64, Entity>, id: i64) -> Option<&Entity> {
-    map.get(&id)
-}
-
-fn bench_hashbrown_insert(map: &mut HashbrownMap<i64, Entity>, entities: &[Entity]) {
-    map.clear();
-    for entity in entities {
-        map.insert(entity.id, entity.clone());
-    }
-}
-
-fn bench_hashbrown_search(map: &HashbrownMap<i64, Entity>, id: i64) -> Option<&Entity> {
-    map.get(&id)
-}
-
-fn bench_fxhashmap_insert(map: &mut FxHashMap<i64, Entity>, entities: &[Entity]) {
-    map.clear();
-    for entity in entities {
-        map.insert(entity.id, entity.clone());
-    }
-}
-
-fn bench_fxhashmap_search(map: &FxHashMap<i64, Entity>, id: i64) -> Option<&Entity> {
-    map.get(&id)
-}
-
-// ========== ГЕНЕРАЦИЯ ДАННЫХ ==========
-
-fn generate_entities(count: usize) -> Vec<Entity> {
-    (0..count).map(|i| Entity::new(i as i64)).collect()
-}
-
-fn generate_search_ids(count: usize, max_id: i64) -> Vec<i64> {
-    // 70% попаданий, 30% промахов (реалистичный сценарий)
-    let mut ids = Vec::with_capacity(count);
-    for i in 0..count {
-        if i % 10 < 7 {
-            // Попадание
-            ids.push((i as i64 * 13) % max_id);
-        } else {
-            // Промах (несуществующий ID)
-            ids.push(max_id + i as i64);
-        }
-    }
-    ids
-}
-
-// ========== БЕНЧМАРКИ ==========
-
-fn bench_insert(c: &mut Criterion) {
-    let mut group = c.benchmark_group("insert");
-
-    for size in [10_000, 100_000, 500_000] {
-        let entities = generate_entities(size);
-
-        group.bench_with_input(
-            BenchmarkId::new("Vec (sorted)", size),
-            &entities,
-            |b, entities| {
-                let mut vec = Vec::with_capacity(size);
-                b.iter(|| {
-                    bench_vec_insert_sorted(&mut vec, black_box(entities));
-                });
-            },
-        );
-
-        group.bench_with_input(
-            BenchmarkId::new("BTreeMap", size),
-            &entities,
-            |b, entities| {
-                let mut map = BTreeMap::new();
-                b.iter(|| {
-                    bench_btreemap_insert(&mut map, black_box(entities));
-                });
-            },
-        );
-
-        group.bench_with_input(
-            BenchmarkId::new("HashMap (std)", size),
-            &entities,
-            |b, entities| {
-                let mut map = HashMap::new();
-                b.iter(|| {
-                    bench_hashmap_insert(&mut map, black_box(entities));
-                });
-            },
-        );
-
-        group.bench_with_input(
-            BenchmarkId::new("HashMap (hashbrown)", size),
-            &entities,
-            |b, entities| {
-                let mut map = HashbrownMap::new();
-                b.iter(|| {
-                    bench_hashbrown_insert(&mut map, black_box(entities));
-                });
-            },
-        );
-
-        group.bench_with_input(
-            BenchmarkId::new("FxHashMap", size),
-            &entities,
-            |b, entities| {
-                let mut map = FxHashMap::default();
-                b.iter(|| {
-                    bench_fxhashmap_insert(&mut map, black_box(entities));
-                });
-            },
-        );
-    }
-
-    group.finish();
-}
-
-fn bench_search(c: &mut Criterion) {
-    let mut group = c.benchmark_group("search");
-
-    for size in [10_000, 100_000, 500_000] {
-        let entities = generate_entities(size);
-        let entity_ids = entities.iter().map(|entity| entity.id).collect::<Vec<_>>();
-        let search_ids = generate_search_ids(1000, size as i64);
-
-        // Подготовка коллекций
-        let mut vec = Vec::with_capacity(size);
-        bench_vec_insert_sorted(&mut vec, &entities);
-
-        let mut btreemap = BTreeMap::new();
-        bench_btreemap_insert(&mut btreemap, &entities);
-
-        let mut hashmap = HashMap::new();
-        bench_hashmap_insert(&mut hashmap, &entities);
-
-        let mut hashbrown = HashbrownMap::new();
-        bench_hashbrown_insert(&mut hashbrown, &entities);
-
-        let mut fxhashmap = FxHashMap::default();
-        bench_fxhashmap_insert(&mut fxhashmap, &entities);
-
-        group.bench_with_input(
-            BenchmarkId::new("Vec (binary search)", size),
-            &search_ids,
-            |b, ids| {
-                b.iter(|| {
-                    for &id in ids {
-                        black_box(bench_vec_search_separated(&entity_ids, &vec, black_box(id)));
-                    }
-                });
-            },
-        );
-
-        group.bench_with_input(
-            BenchmarkId::new("Vec (binary search) separated", size),
-            &search_ids,
-            |b, ids| {
-                b.iter(|| {
-                    for &id in ids {
-                        black_box(bench_vec_search(&vec, black_box(id)));
-                    }
-                });
-            },
-        );
-
-        group.bench_with_input(BenchmarkId::new("BTreeMap", size), &search_ids, |b, ids| {
-            b.iter(|| {
-                for &id in ids {
-                    black_box(bench_btreemap_search(&btreemap, black_box(id)));
-                }
-            });
-        });
-
-        group.bench_with_input(
-            BenchmarkId::new("HashMap (std)", size),
-            &search_ids,
-            |b, ids| {
-                b.iter(|| {
-                    for &id in ids {
-                        black_box(bench_hashmap_search(&hashmap, black_box(id)));
-                    }
-                });
-            },
-        );
-
-        group.bench_with_input(
-            BenchmarkId::new("HashMap (hashbrown)", size),
-            &search_ids,
-            |b, ids| {
-                b.iter(|| {
-                    for &id in ids {
-                        black_box(bench_hashbrown_search(&hashbrown, black_box(id)));
-                    }
-                });
-            },
-        );
-
-        group.bench_with_input(
-            BenchmarkId::new("FxHashMap", size),
-            &search_ids,
-            |b, ids| {
-                b.iter(|| {
-                    for &id in ids {
-                        black_box(bench_fxhashmap_search(&fxhashmap, black_box(id)));
-                    }
-                });
-            },
-        );
-    }
-
-    group.finish();
-}
-
-fn bench_memory_efficiency(c: &mut Criterion) {
-    let mut group = c.benchmark_group("memory_efficiency");
-
-    let size = 100_000;
-    let entities = generate_entities(size);
-
-    group.bench_function("Vec memory", |b| {
-        b.iter(|| {
-            let mut vec = Vec::with_capacity(size);
-            bench_vec_insert_sorted(&mut vec, black_box(&entities));
-            black_box(vec);
-        });
-    });
-
-    group.bench_function("BTreeMap memory", |b| {
-        b.iter(|| {
-            let mut map = BTreeMap::new();
-            bench_btreemap_insert(&mut map, black_box(&entities));
-            black_box(map);
-        });
-    });
-
-    group.bench_function("HashMap (std) memory", |b| {
-        b.iter(|| {
-            let mut map = HashMap::new();
-            bench_hashmap_insert(&mut map, black_box(&entities));
-            black_box(map);
-        });
-    });
-
-    group.bench_function("HashMap (hashbrown) memory", |b| {
-        b.iter(|| {
-            let mut map = HashbrownMap::new();
-            bench_hashbrown_insert(&mut map, black_box(&entities));
-            black_box(map);
-        });
-    });
-
-    group.bench_function("FxHashMap memory", |b| {
-        b.iter(|| {
-            let mut map = FxHashMap::default();
-            bench_fxhashmap_insert(&mut map, black_box(&entities));
-            black_box(map);
-        });
-    });
-
-    group.finish();
-}
-
-criterion_group!(benches, bench_insert, bench_search, bench_memory_efficiency);
-criterion_main!(benches);

sql/decks.sql

@@ -1,4 +1,4 @@
-create table card_set
+create table decks
 (
     id       INTEGER
         primary key autoincrement,

sql/history.sql

@@ -0,0 +1,12 @@
+create table history
+(
+    id INTEGER
+        primary key autoincrement,
+    set_id INTEGER not null references decks on delete cascade,
+    stat_id INTEGER not null references states on delete cascade,
+    timestamp INTEGER not null,
+    answer INTEGER not null,
+    before INTEGER not null,
+    after INTEGER not null,
+    fsrs INTEGER not null
+);

sql/states.sql

@@ -1,4 +1,4 @@
-create table card_stats
+create table states
 (
     id          INTEGER
         primary key autoincrement,
@@ -6,8 +6,11 @@ create table card_stats
         references words
             on delete cascade,
     set_id      INTEGER              not null
-        references card_set
+        references decks
             on delete cascade,
     score       INTEGER default 1 not null,
-    last_opened INTEGER           not null
+    last_opened INTEGER           not null,
+    fsrs_opened INTEGER not null,
+    fsrs_memory INTEGER not null,
+    fsrs_open_day INTEGER not null
 );

sql/word_groups.sql

@@ -1,4 +1,4 @@
-create table word_group
+create table word_groups
 (
     id   INTEGER
         primary key autoincrement,

sql/words.sql

@@ -7,7 +7,7 @@ create table words
     tags     TEXT              not null,
     more     TEXT,
     group_id integer default 1 not null
-        constraint words_word_group_id_fk
+        constraint words_word_groups_id_fk
-            references word_group
+            references word_groups
             on update cascade on delete cascade
 );

src/app.rs

@@ -1,7 +1,7 @@
 use crate::data::Id;
 use crate::data::entities::DeckSettings;
 use crate::data::entities::{WordData, WordGroup};
-use crate::data_provider::card_sets::load_sets;
+use crate::data_provider::decks::load_sets;
 use crate::data_provider::settings::get_setting;
 use crate::data_provider::sqlite::default_connection;
 use crate::data_provider::words::{load_word_groups, load_words};

src/core/deck.rs

@@ -1,10 +1,11 @@
 use crate::app::AppState;
+use crate::core::srs::OrderModule::{Fsrs, RandomSRS, SemiRandomSRS, WorstWordsSRS};
 use crate::core::srs::{
-    OrderMode, OrderModule, RandomSRSModule, SRSModule, SemiRandomSRSModule, WordOpenMode,
+    FsrsModule, OrderMode, OrderModule, RandomSRSModule, SRSModule, SemiRandomSRSModule,
-    WorstWordsSRSModule,
+    WordOpenMode, WorstWordsSRSModule,
 };
 use crate::data::entities::*;
-use crate::data_provider::card_stats::{load_stats_of_deck, update_stat_score};
+use crate::data_provider::card_states::{load_stats_of_deck, update_stat_score};
 use crate::data_provider::history::push_note;
 use crate::notification::{MaybeError, NotificationData};
 use chrono::Utc;
@@ -18,6 +19,7 @@ pub struct DeckData {
     current_word_index: Option<usize>,
     state: Arc<Mutex<AppState>>,
     order_module: OrderModule,
+    open_mode: OrderMode,
     settings: DeckSettings,
 }
 impl DeckData {
@@ -46,32 +48,34 @@ impl DeckData {
             words,
             current_word_index: None,
             state: state_for,
-            order_module: match settings.open_mode {
+            order_module: Fsrs(FsrsModule::new()),
-                OrderMode::Default => OrderModule::SemiRandomSRS(SemiRandomSRSModule::new()),
+            open_mode: settings.open_mode,
-                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) => {
+            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())
                 }
@@ -90,15 +94,28 @@ 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
+                && 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,14 +1,16 @@
 use crate::data::entities::CardStatistics;
+use chrono::{Local, TimeDelta};
+use fsrs::FSRS;
 use rand::distr::weighted::WeightedIndex;
 use rand::prelude::ThreadRng;
 use rand::prelude::{Distribution, SliceRandom};
-use rand::rng;
+use rand::{RngExt, rng};
 
 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,112 @@ 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, _: &[CardStatistics]) -> usize {
+        if self.current_group.is_empty() {
+            self.fill_partial_pool();
+        }
+
+        if self.queue.is_empty() {
+            self.fill_queue();
+            self.queue.shuffle(&mut self.rng);
+        }
+
+        self.queue.pop().unwrap_or(0)
+    }
+
+    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();
+
+        let memory = self
+            .fsrs
+            .next_states(updated_word.fsrs_memory, 0.9, delta_days as u32)
+            .expect("Wrong next stage calculation");
+
+        let next = match status {
+            WordOpenMode::Easy => memory.easy,
+            WordOpenMode::Ok => memory.good,
+            WordOpenMode::Hard => memory.hard,
+            WordOpenMode::None => memory.again,
+        };
+
+        let mut next_day = today + TimeDelta::days(next.interval.round() as i64);
+        if (next_day - today).num_days() >= 5 {
+            let offset = ((rng().random::<f32>() - 0.5) * 3.0).round() as i32;
+            next_day += TimeDelta::days(offset as i64);
+        }
+        updated_word.fsrs_memory = Some(next.memory);
+        updated_word.fsrs_open_day = next_day;
+        updated_word.fsrs_opened = updated_word.last_open.date_naive();
+
+        if updated_word.fsrs_open_day != today {
+            self.solved.push(index);
+            let index = self.current_group.iter().position(|x| *x == index).unwrap();
+            self.current_group.remove(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.extend(
+            self.today_set
+                .iter()
+                .filter(|x| !self.solved.contains(*x))
+                .take(PARTIAL_POOL_SIZE),
+        );
+
+        self.queue.clear();
+        self.queue.extend(self.current_group.clone());
+    }
+
+    fn fill_queue(&mut self) {
+        self.queue.extend(self.current_group.clone());
+    }
+
+    pub fn finished(&self) -> bool {
+        self.today_set.len() == self.solved.len()
+    }
+}
+
 #[derive(Clone, Copy)]
 pub enum WordOpenMode {
     Easy,

src/data.rs

@@ -1,5 +1,4 @@
 pub mod entities;
-pub mod repositories;
 
 use rusqlite::ToSql;
 use rusqlite::types::{FromSql, FromSqlError, FromSqlResult, ToSqlOutput, ValueRef};

src/data/entities.rs

@@ -1,14 +1,12 @@
 use crate::app::AppState;
 use crate::core::srs::{FADE_PER_DAY, MAX_SCORE, OrderMode, WordOpenMode};
 use crate::data::{INVALID_ID, Id};
-use crate::notification::MaybeError;
+use chrono::{DateTime, NaiveDate, Utc};
-use chrono::{DateTime, Utc};
+use fsrs::MemoryState;
 use log::info;
 use rayon::prelude::*;
 use rhai::{Engine, Scope};
-use std::cmp::Ordering;
 use std::collections::HashMap;
-use std::marker::PhantomData;
 use std::time::Instant;
 
 #[derive(Clone, Debug)]
@@ -20,17 +18,6 @@ pub struct WordData {
     pub additional: HashMap<String, String>,
     pub group_id: Id,
 }
-
-impl EntityData for WordData {
-    fn id(&self) -> Id {
-        self.id
-    }
-
-    fn set_id(&mut self, id: Id) {
-        self.id = id;
-    }
-}
-
 #[derive(Clone)]
 pub struct WordGroup {
     pub id: Id,
@@ -151,6 +138,9 @@ pub struct CardStatistics {
     pub set_id: Id,
     pub last_open: DateTime<Utc>,
     pub score: u8,
+    pub fsrs_opened: NaiveDate,
+    pub fsrs_memory: Option<MemoryState>,
+    pub fsrs_open_day: NaiveDate,
 }
 impl CardStatistics {
     pub fn update(&mut self, status: WordOpenMode) {
@@ -178,75 +168,3 @@ impl CardStatistics {
         (self.score as f32 * multiplier).max(1.0)
     }
 }
-
-#[derive(Copy)]
-pub struct EntityHandle<E> {
-    pub(crate) id: Id,
-    index: i32,
-    pub(crate) _phantom: PhantomData<E>,
-}
-
-impl<T> Clone for EntityHandle<T> {
-    fn clone(&self) -> Self {
-        EntityHandle {
-            id: self.id,
-            index: self.index,
-            _phantom: Default::default(),
-        }
-    }
-}
-impl<T> EntityHandle<T> {
-    pub fn new(id: Id, index: usize, real: bool) -> Self {
-        Self {
-            id,
-            index: index as i32 | (!real as i32) << 31,
-            _phantom: Default::default(),
-        }
-    }
-    pub fn index(&self) -> usize {
-        (self.index << 1 >> 1) as usize
-    }
-
-    pub fn set_index(&mut self, index: usize) {
-        self.index = self.index >> 31 << 31 | index as i32;
-    }
-
-    pub fn real(&self) -> bool {
-        (self.index >> 31) == 0
-    }
-
-    pub fn set_real(&mut self, value: bool) {
-        self.index = self.index << 1 >> 1 | (!value as i32) << 31;
-    }
-}
-impl<T> Eq for EntityHandle<T> {}
-
-impl<T> PartialEq<Self> for EntityHandle<T> {
-    fn eq(&self, other: &Self) -> bool {
-        self.real() == other.real() && self.id == other.id
-    }
-}
-impl<T> PartialOrd<Self> for EntityHandle<T> {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        Some(self.cmp(other))
-    }
-}
-
-impl<T> Ord for EntityHandle<T> {
-    fn cmp(&self, other: &Self) -> Ordering {
-        if self.real() && !other.real() {
-            return Ordering::Less;
-        }
-
-        if !self.real() && other.real() {
-            return Ordering::Greater;
-        }
-
-        self.id.cmp(&other.id)
-    }
-}
-
-pub trait EntityData {
-    fn id(&self) -> Id;
-    fn set_id(&mut self, id: Id);
-}

src/data/repositories.rs

@@ -1,531 +0,0 @@
-use crate::data::Id;
-use crate::data::entities::{EntityData, EntityHandle};
-use crate::helpers::into_result;
-use crate::notification::{MaybeError, NotificationData};
-use parking_lot::{Mutex, RwLock};
-use rayon::iter::IndexedParallelIterator;
-use rayon::iter::IntoParallelRefIterator;
-use rayon::iter::ParallelIterator;
-use rusqlite::Connection;
-use std::marker::PhantomData;
-use std::ops::Deref;
-use std::sync::Arc;
-
-pub trait Repository<T, D>
-where
-    D: DbLayer<T>,
-{
-    fn get(&self, handle: &mut EntityHandle<T>) -> Option<T>;
-    fn get_ref(&self, handle: &mut EntityHandle<T>) -> Option<&T>;
-    fn get_mut(&mut self, handle: &mut EntityHandle<T>) -> Option<&mut T>;
-    fn handle_by_id(&self, id: Id) -> EntityHandle<T>;
-    fn create(&mut self, new: T) -> EntityHandle<T>;
-    fn save(&mut self, entity: &mut EntityHandle<T>) -> MaybeError;
-    fn delete(&mut self, handle: EntityHandle<T>) -> MaybeError;
-    fn init(&mut self) -> MaybeError;
-    fn reload(&mut self) -> MaybeError;
-}
-
-struct QueryManger<T, R, D>
-where
-    R: Repository<T, D>,
-    D: DbLayer<T>,
-{
-    queries: Vec<Arc<Mutex<Query<T, R, D>>>>,
-}
-
-impl<T, R, D> QueryManger<T, R, D>
-where
-    R: Repository<T, D>,
-    D: DbLayer<T>,
-    T: EntityData,
-{
-    pub(crate) fn handle_save(&self, old: EntityHandle<T>, new: &mut EntityHandle<T>, data: &T) {
-        return;
-        if old.real() && new.real() {
-            return;
-        }
-
-        let affected = self.get_affected_queries(data);
-        for q in affected {
-            let mut query = self.queries[q].lock();
-            let index = query.cache.binary_search(&old).unwrap();
-            query.cache.remove(index);
-            let real_end = query.cache.iter().rposition(|r| r.real()).unwrap() + 1;
-            query.cache.insert(real_end, new.clone());
-        }
-    }
-    pub(crate) fn handle_delete(&self, handle: &EntityHandle<T>, data: &T) {
-        return;
-        let affected = self.get_affected_queries(data);
-        for q in affected {
-            let mut query = self.queries[q].lock();
-            let slice = query.cache.as_slice();
-            if let Ok(index) = slice.binary_search(&handle) {
-                query.cache.remove(index);
-            }
-        }
-    }
-
-    fn get_affected_queries(&self, data: &T) -> Vec<usize> {
-        self.queries
-            .iter()
-            .enumerate()
-            .filter(|(_, q)| {
-                let query = q.lock();
-                let rule = &query.rule;
-                return rule(data);
-
-                false
-            })
-            .map(|(i, _)| i)
-            .collect()
-    }
-
-    fn reload_queries(&mut self, data_repository: impl Repository<T, D>) {
-        for q in &self.queries {
-            let mut query = q.lock();
-            query.cache.clear();
-        }
-    }
-}
-pub struct Query<T, R, D>
-where
-    R: Repository<T, D>,
-    D: DbLayer<T>,
-{
-    cache: Vec<EntityHandle<T>>,
-    rule: Box<dyn Fn(&T) -> bool + Send + Sync>,
-    parallel: bool,
-    _marker: PhantomData<(R, D)>,
-    shift_stamp: u16,
-}
-
-impl<T: EntityData + Clone, R: Repository<T, D>, D: DbLayer<T>> Query<T, R, D> {
-    pub fn iter<'a>(&mut self, data_repository_inner: &'a R) -> impl Iterator<Item = &'a T>
-    where
-        T: 'a,
-    {
-        self.cache
-            .iter_mut()
-            .filter_map(move |e| data_repository_inner.get_ref(e))
-    }
-
-    pub fn for_each_mut<F>(&mut self, repo: &mut R, mut f: F)
-    where
-        F: FnMut(&mut T),
-    {
-        for handle in &mut self.cache {
-            if let Some(entity) = repo.get_mut(handle) {
-                f(entity);
-            }
-        }
-    }
-
-    pub fn load(&mut self, data_repository: &DataRepositoryInner<T, D>)
-    where
-        T: Send + Sync,
-    {
-        self.cache.clear();
-        if self.parallel {
-            self.cache = data_repository
-                .cache
-                .par_iter()
-                .enumerate()
-                .filter(|(_, entity)| (self.rule)(entity))
-                .map(|(i, entity)| EntityHandle::new(entity.id(), i, true))
-                .collect();
-        } else {
-            self.cache = data_repository
-                .cache
-                .iter()
-                .enumerate()
-                .filter(|(_, entity)| (self.rule)(entity))
-                .map(|(i, entity)| EntityHandle::new(entity.id(), i, true))
-                .collect();
-        }
-
-        self.cache.extend(
-            data_repository
-                .temporal
-                .iter()
-                .enumerate()
-                .filter(|(_, entity)| (self.rule)(entity))
-                .map(|(i, entity)| EntityHandle::new(entity.id(), i, false))
-                .collect::<Vec<_>>(),
-        );
-    }
-}
-
-pub trait BatchedRepository<T, D>
-where
-    D: BatchedDbLayer<T>,
-    T: EntityData,
-{
-    fn save_many(&mut self, handles: &mut [EntityHandle<T>]) -> MaybeError;
-    fn delete_many(&mut self, handles: &mut [EntityHandle<T>]) -> MaybeError;
-}
-
-pub trait DbLayer<T> {
-    fn write_entity(&self, entity: &T, connection: &Connection) -> MaybeError;
-    fn add_entity(&mut self, entity: &mut T, connection: &Connection) -> MaybeError;
-    fn delete_entity(&mut self, id: Id, connection: &Connection) -> MaybeError;
-    fn load_all(&self, storage: &mut Vec<T>, connection: &Connection) -> MaybeError;
-}
-
-pub trait BatchedDbLayer<T>
-where
-    T: EntityData,
-{
-    fn delete_many_entities(&mut self, ids: &[Id], connection: &Connection) -> MaybeError;
-    fn add_many_entities(&mut self, entity: &mut [T], connection: &Connection) -> MaybeError;
-}
-
-#[derive(Clone)]
-pub struct DataRepository<T: std::clone::Clone + EntityData, D: DbLayer<T>> {
-    inner: Arc<RwLock<DataRepositoryInner<T, D>>>,
-}
-
-pub struct DataRepositoryInner<T: std::clone::Clone + EntityData, D: DbLayer<T>> {
-    cache: Vec<T>,
-    temporal: Vec<T>,
-    next_temporal: u32,
-    connection: Arc<RwLock<Connection>>,
-    data_layer: D,
-    query_manger: QueryManger<T, Self, D>,
-    version: u16,
-    shifts: u16,
-}
-
-impl<T: std::clone::Clone + EntityData, D: DbLayer<T>> Deref for DataRepository<T, D> {
-    type Target = Arc<RwLock<DataRepositoryInner<T, D>>>;
-
-    fn deref(&self) -> &Self::Target {
-        &self.inner
-    }
-}
-
-impl<T: EntityData + Clone, D: DbLayer<T>> DataRepositoryInner<T, D> {
-    pub fn query_par(
-        &self,
-        rule: Box<dyn Fn(&T) -> bool + Send + Sync>,
-    ) -> Query<T, DataRepositoryInner<T, D>, D>
-    where
-        T: Send + Sync,
-    {
-        let mut cache: Vec<EntityHandle<T>> = self
-            .cache
-            .par_iter()
-            .enumerate()
-            .filter(|(_, entity)| rule(entity))
-            .map(|(i, entity)| EntityHandle::new(entity.id(), i, true))
-            .collect();
-
-        cache.extend(
-            self.temporal
-                .iter()
-                .enumerate()
-                .filter(|(_, entity)| rule(entity))
-                .map(|(i, entity)| EntityHandle::new(entity.id(), i, false))
-                .collect::<Vec<_>>(),
-        );
-
-        Query {
-            cache,
-            rule,
-            parallel: true,
-            _marker: PhantomData,
-            shift_stamp: self.shifts,
-        }
-    }
-
-    pub fn query(
-        &self,
-        rule: Box<dyn Fn(&T) -> bool + Send + Sync>,
-    ) -> Query<T, DataRepositoryInner<T, D>, D>
-    where
-        T: Send + Sync,
-    {
-        let mut cache: Vec<EntityHandle<T>> = self
-            .cache
-            .iter()
-            .enumerate()
-            .filter(|(_, entity)| rule(entity))
-            .map(|(i, entity)| EntityHandle::new(entity.id(), i, true))
-            .collect();
-
-        cache.extend(
-            self.temporal
-                .iter()
-                .enumerate()
-                .filter(|(_, entity)| rule(entity))
-                .map(|(i, entity)| EntityHandle::new(entity.id(), i, false))
-                .collect::<Vec<_>>(),
-        );
-
-        Query {
-            cache,
-            rule,
-            parallel: false,
-            _marker: PhantomData,
-            shift_stamp: self.shifts,
-        }
-    }
-}
-
-impl<T: EntityData + Clone, D: DbLayer<T>> Repository<T, D> for DataRepositoryInner<T, D> {
-    fn get(&self, handle: &mut EntityHandle<T>) -> Option<T> {
-        let slice = if handle.real() {
-            self.cache.as_slice()
-        } else {
-            self.temporal.as_slice()
-        };
-        let index = fast_position_of(slice, handle)?;
-        Some(slice[index].clone())
-    }
-
-    fn get_ref(&self, handle: &mut EntityHandle<T>) -> Option<&T> {
-        let slice = if handle.real() {
-            self.cache.as_slice()
-        } else {
-            self.temporal.as_slice()
-        };
-        let index = fast_position_of(slice, handle)?;
-        Some(&slice[index])
-    }
-
-    fn get_mut(&mut self, handle: &mut EntityHandle<T>) -> Option<&mut T> {
-        let slice = if handle.real() {
-            self.cache.as_mut_slice()
-        } else {
-            self.temporal.as_mut_slice()
-        };
-        let index = fast_position_of(slice, handle)?;
-        Some(&mut slice[index])
-    }
-
-    fn handle_by_id(&self, id: Id) -> EntityHandle<T> {
-        EntityHandle::new(id, id.0 as usize, true)
-    }
-
-    fn create(&mut self, mut new: T) -> EntityHandle<T> {
-        let next_temporal = self.next_temporal;
-        self.next_temporal += 1;
-        let entity = EntityHandle::new(next_temporal.into(), self.temporal.len(), false);
-        new.set_id(entity.id);
-        self.temporal.push(new);
-        entity
-    }
-
-    fn save(&mut self, entity: &mut EntityHandle<T>) -> MaybeError {
-        let original_state = entity.clone();
-        if entity.real() {
-            let data = self.get_ref(entity).unwrap();
-            self.data_layer
-                .write_entity(data, &self.connection.read())?;
-        } else {
-            let index = fast_position_of(self.temporal.as_slice(), entity).unwrap();
-            let mut data = self.temporal.remove(index);
-            self.data_layer
-                .add_entity(&mut data, &self.connection.read())?;
-            entity.set_real(true);
-            entity.id = data.id();
-            entity.set_index(self.cache.len());
-            self.query_manger.handle_save(original_state, entity, &data);
-
-            self.cache.push(data);
-            self.shifts += 1;
-        }
-
-        Ok(())
-    }
-
-    fn delete(&mut self, mut handle: EntityHandle<T>) -> MaybeError {
-        let vec = if handle.real() {
-            self.data_layer
-                .delete_entity(handle.id, &self.connection.read())?;
-            &mut self.cache
-        } else {
-            &mut self.temporal
-        };
-
-        let index = into_result(
-            fast_position_of(vec.as_slice(), &mut handle),
-            NotificationData::DbSaveError,
-        )?;
-        let value = vec.remove(index);
-        self.query_manger.handle_delete(&handle, &value);
-        self.shifts += 1;
-        Ok(())
-    }
-
-    fn init(&mut self) -> MaybeError {
-        self.data_layer
-            .load_all(&mut self.cache, &self.connection.read())?;
-        self.version += 1;
-        Ok(())
-    }
-
-    fn reload(&mut self) -> MaybeError {
-        self.cache.clear();
-        self.temporal.clear();
-        self.init()?;
-        Ok(())
-    }
-}
-impl<T: EntityData + Clone, D: BatchedDbLayer<T> + DbLayer<T>> BatchedRepository<T, D>
-    for DataRepositoryInner<T, D>
-{
-    fn save_many(&mut self, handles: &mut [EntityHandle<T>]) -> MaybeError {
-        let mut temp = Vec::with_capacity(handles.len() / 2);
-        let mut cached = Vec::with_capacity(handles.len() / 2);
-        handles.sort_by_key(|a| a.id);
-        handles.iter_mut().for_each(|handle| {
-            if handle.real() {
-                cached.push(handle)
-            } else {
-                temp.push(handle)
-            }
-        });
-
-        let mut temp_values = Vec::with_capacity(temp.len());
-        let mut cell = 0;
-        let len = temp.len();
-        self.temporal.retain(|x| {
-            if cell == len {
-                return true;
-            }
-            let find = temp[cell].id;
-            let remove = x.id() == find;
-            if remove {
-                cell += 1;
-                temp_values.push(x.clone());
-            }
-            !remove
-        });
-
-        self.data_layer
-            .add_many_entities(&mut temp_values, &self.connection.read())?;
-
-        let start = self.cache.len();
-
-        for (i, (handle, data)) in temp.into_iter().zip(&mut temp_values).enumerate() {
-            let old = handle.clone();
-            handle.id = data.id();
-            handle.set_index(start + i);
-            handle.set_real(true);
-            self.query_manger.handle_save(old, handle, data);
-        }
-
-        self.cache.extend(temp_values);
-
-        for handle in cached.into_iter() {
-            let h = handle;
-            let idx = fast_position_of(self.cache.as_slice(), h).unwrap();
-            self.data_layer
-                .write_entity(&self.cache[idx], &self.connection.read())?;
-        }
-        self.shifts += 1;
-
-        Ok(())
-    }
-
-    fn delete_many(&mut self, handles: &mut [EntityHandle<T>]) -> MaybeError {
-        let (cached, temp) = split_temp_real(handles, |e| e.id);
-
-        let mut cell = 0;
-        let len = temp.len();
-        self.temporal.retain(|x| {
-            if cell == len {
-                return true;
-            }
-            let find = temp[cell];
-            let remove = x.id() == find;
-            if remove {
-                cell += 1;
-            }
-            !remove
-        });
-        self.data_layer
-            .delete_many_entities(cached.as_slice(), &self.connection.read())?;
-        let len = cached.len();
-        cell = 0;
-        self.cache.retain(|x| {
-            if cell == len {
-                return true;
-            }
-            let find = cached[cell];
-            let remove = x.id() == find;
-            if remove {
-                cell += 1;
-            }
-
-            !remove
-        });
-        self.shifts += 1;
-
-        Ok(())
-    }
-}
-
-fn split_temp_real<T, F, V>(handles: &mut [EntityHandle<T>], getter: F) -> (Vec<V>, Vec<V>)
-where
-    F: Fn(&EntityHandle<T>) -> V,
-{
-    let mut temp = Vec::with_capacity(handles.len() / 2);
-    let mut cached = Vec::with_capacity(handles.len() / 2);
-    handles.sort_by(|a, b| a.id.cmp(&b.id));
-    handles.iter().for_each(|handle| {
-        if handle.real() {
-            cached.push(getter(handle))
-        } else {
-            temp.push(getter(handle))
-        }
-    });
-    (cached, temp)
-}
-
-pub fn fast_position_of<E: EntityData>(
-    storage: &[E],
-    handle: &mut EntityHandle<E>,
-) -> Option<usize> {
-    if storage.is_empty() {
-        return None;
-    }
-
-    let max_idx = storage.len() - 1;
-    let upper = (handle.index()).min(max_idx);
-    let peek = storage[upper].id();
-
-    if peek == handle.id {
-        handle.set_index(upper);
-        return Some(upper);
-    }
-
-    if peek.0 < handle.id.0 {
-        return None;
-    }
-
-    let target_id_val = handle.id.0 as i64;
-    let peek_val = peek.0 as i64;
-    let delta = peek_val - target_id_val;
-
-    let new_index = (upper as i64 - delta).max(0) as usize;
-
-    if storage[new_index].id() == handle.id {
-        handle.set_index(new_index);
-        return Some(new_index);
-    }
-
-    if new_index == upper {
-        return None;
-    }
-
-    let index = storage[new_index..upper]
-        .binary_search_by(|e| e.id().cmp(&handle.id))
-        .ok()?
-        + new_index;
-
-    handle.set_index(index);
-    Some(index)
-}

src/data_provider/card_states.rs

@@ -1,6 +1,8 @@
 use crate::data::entities::{CardStatistics, DeckSettings};
 use crate::notification::NotificationData::{DbLoadError, DbSaveError};
 use crate::notification::{MaybeError, NotificationData};
+use chrono::NaiveDate;
+use fsrs::MemoryState;
 use log::info;
 use rusqlite::{Connection, params};
 use std::time::Instant;
@@ -10,7 +12,7 @@ pub fn load_stats_of_deck(
     connection: &Connection,
 ) -> Result<Vec<CardStatistics>, NotificationData> {
     let mut stmt = connection
-        .prepare("SELECT id, word_id, score, last_opened FROM card_stats WHERE set_id = ?1")
+        .prepare("SELECT id, word_id, score, last_opened, fsrs_opened, fsrs_memory, fsrs_open_day FROM states WHERE set_id = ?1")
         .expect("Failed to prepare state query");
     let iter = stmt
         .query_map((set.id,), |row| {
@@ -19,7 +21,12 @@ pub fn load_stats_of_deck(
                 word_id: row.get(1)?,
                 set_id: set.id,
                 score: row.get(2)?,
+                fsrs_opened: NaiveDate::from_epoch_days(row.get::<usize, i32>(4)?)
+                    .expect("Incorrect date encoding"),
+                fsrs_memory: Some(get_memory(row.get(5)?)),
                 last_open: row.get(3)?,
+                fsrs_open_day: NaiveDate::from_epoch_days(row.get::<usize, i32>(6)?)
+                    .expect("Incorrect date encoding"),
             })
         })
         .map_err(|_| DbLoadError)?;
@@ -30,6 +37,17 @@ pub fn load_stats_of_deck(
     Ok(buffer)
 }
 
+fn get_memory(value: i64) -> MemoryState {
+    MemoryState {
+        stability: f32::from_bits(value as u32),
+        difficulty: f32::from_bits((value >> 32) as u32),
+    }
+}
+
+fn memory_to_i64(value: &MemoryState) -> i64 {
+    value.stability.to_bits() as i64 | ((value.difficulty.to_bits() as i64) << 32)
+}
+
 pub fn add_stat_list(stats: &mut [CardStatistics], connection: &mut Connection) -> MaybeError {
     let time = Instant::now();
     let tx = connection
@@ -40,7 +58,7 @@ pub fn add_stat_list(stats: &mut [CardStatistics], connection: &mut Connection)
     {
         let mut stmt = tx
             .prepare(
-                "INSERT INTO card_stats (word_id, set_id, score, last_opened) VALUES (?1, ?2, ?3, ?4)",
+                "INSERT INTO states (word_id, set_id, score, last_opened, fsrs_opened, fsrs_memory, fsrs_open_day) VALUES (?1, ?2, ?3, ?4)",
             )
             .expect("Failed to prepare state query");
 
@@ -49,7 +67,13 @@ pub fn add_stat_list(stats: &mut [CardStatistics], connection: &mut Connection)
                 stat.word_id,
                 stat.set_id,
                 stat.score,
-                stat.last_open.timestamp()
+                stat.last_open.timestamp(),
+                stat.fsrs_opened.to_epoch_days(),
+                memory_to_i64(&stat.fsrs_memory.unwrap_or(MemoryState {
+                    difficulty: 0.0,
+                    stability: 0.0
+                })),
+                stat.fsrs_open_day.to_epoch_days()
             ])
             .map_err(|_| DbSaveError)?;
         }
@@ -73,7 +97,7 @@ pub fn update_stat_score(stat: &CardStatistics, connection: &Connection) -> Mayb
 
     connection
         .execute(
-            "UPDATE card_stats SET score = ?1, last_opened = ?2 WHERE id = ?3",
+            "UPDATE states SET score = ?1, last_opened = ?2 WHERE id = ?3",
             (&stat.score, &stat.last_open.timestamp(), &stat.id),
         )
         .map_err(|_| DbSaveError)?;
@@ -92,7 +116,7 @@ pub fn delete_stats(stat: &[CardStatistics], connection: &Connection) -> MaybeEr
         .join(", ");
     connection
         .execute(
-            format!("DELETE FROM card_stats WHERE id in ({ids})").as_str(),
+            format!("DELETE FROM states WHERE id in ({ids})").as_str(),
             (),
         )
         .map_err(|_| DbSaveError)?;

src/data_provider/decks.rs

@@ -1,5 +1,4 @@
 use crate::core::srs::OrderMode;
-
 use crate::data::entities::DeckSettings;
 use crate::notification::NotificationData::{DbLoadError, DbSaveError};
 use crate::notification::{MaybeError, NotificationData};
@@ -7,7 +6,7 @@ use rusqlite::Connection;
 
 pub fn load_sets(connection: &Connection) -> Result<Vec<DeckSettings>, NotificationData> {
     let mut stmt = connection
-        .prepare("SELECT id, name, forward, backward, filter FROM card_set")
+        .prepare("SELECT id, name, forward, backward, filter FROM decks")
         .expect("Failed to prepare state query");
     let iter = stmt
         .query_map([], |row| {
@@ -31,7 +30,7 @@ pub fn load_sets(connection: &Connection) -> Result<Vec<DeckSettings>, Notificat
 pub fn add_set(set: &mut DeckSettings, connection: &Connection) -> MaybeError {
     let index : u32 = connection
         .query_row(
-            "INSERT INTO card_set (name, forward, backward, filter) VALUES (?1, ?2, ?3, ?4) RETURNING id",
+            "INSERT INTO decks (name, forward, backward, filter) VALUES (?1, ?2, ?3, ?4) RETURNING id",
             (
                 &set.name,
                 &set.forward,
@@ -52,7 +51,7 @@ pub fn update_deck(set: &mut DeckSettings, connection: &Connection) -> MaybeErro
     } else {
         connection
             .execute(
-                "UPDATE card_set SET name = ?1, forward = ?2, backward = ?3, filter = ?4 WHERE id = ?5",
+                "UPDATE decks SET name = ?1, forward = ?2, backward = ?3, filter = ?4 WHERE id = ?5",
                 (
                     &set.name,
                     &set.forward,
@@ -71,7 +70,7 @@ pub fn delete_set(set: &DeckSettings, connection: &Connection) -> MaybeError {
         return Err(DbSaveError);
     }
     connection
-        .execute("DELETE FROM card_set WHERE id = ?1", (&set.id,))
+        .execute("DELETE FROM decks WHERE id = ?1", (&set.id,))
         .map_err(|_| DbSaveError)?;
     Ok(())
 }

src/data_provider/history.rs

@@ -4,12 +4,20 @@ use crate::data::entities::HistoryItem;
 use crate::fs::*;
 use crate::notification::NotificationData::PermissionDenied;
 use crate::notification::{MaybeError, NotificationData};
-use chrono::DateTime;
+use chrono::{DateTime, NaiveDate};
+use rusqlite::Connection;
 use std::fs::{File, OpenOptions};
 use std::io::Write;
 use std::io::{BufRead, BufReader};
 use std::path::PathBuf;
 
+pub fn get_open_count_of_set(
+    id: Id,
+    connection: &Connection,
+) -> Result<Vec<(NaiveDate, u32)>, NotificationData> {
+    todo!()
+}
+
 pub fn get_history_of_set(id: Id) -> Result<Vec<HistoryItem>, NotificationData> {
     let app_dir = history_dir()?;
     let head = app_dir.clone().join(format!("set_{}_history.csv", id));

src/data_provider/mod.rs

@@ -1,5 +1,5 @@
-pub(crate) mod card_sets;
+pub(crate) mod card_states;
-pub(crate) mod card_stats;
+pub(crate) mod decks;
 pub(crate) mod history;
 pub(crate) mod import;
 pub(crate) mod settings;

src/data_provider/sqlite.rs

@@ -20,6 +20,7 @@ fn create_tables(conn: &Connection) {
     make_word_group(conn).expect("Failed to init table");
     make_words(conn).expect("Failed to init table");
     make_card_stats(conn).expect("Failed to init table");
+    make_history(conn).expect("Failed to init table");
 }
 
 fn make_settings(conn: &Connection) -> Result<(), rusqlite::Error> {
@@ -29,15 +30,15 @@ fn make_settings(conn: &Connection) -> Result<(), rusqlite::Error> {
 }
 
 fn make_card_set(conn: &Connection) -> Result<(), rusqlite::Error> {
-    let query = include_str!("../../sql/card_set.sql");
+    let query = include_str!("../../sql/decks.sql");
     conn.execute(query, ())?;
     Ok(())
 }
 
 fn make_word_group(conn: &Connection) -> Result<(), rusqlite::Error> {
-    let query = include_str!("../../sql/word_group.sql");
+    let query = include_str!("../../sql/word_groups.sql");
     conn.execute(query, ())?;
-    conn.execute("insert into word_group (name) values (\"Слова\");", ())?;
+    conn.execute("insert into word_groups (name) values (\"Слова\");", ())?;
     Ok(())
 }
 fn make_words(conn: &Connection) -> Result<(), rusqlite::Error> {
@@ -46,7 +47,13 @@ fn make_words(conn: &Connection) -> Result<(), rusqlite::Error> {
     Ok(())
 }
 fn make_card_stats(conn: &Connection) -> Result<(), rusqlite::Error> {
-    let query = include_str!("../../sql/card_stats.sql");
+    let query = include_str!("../../sql/states.sql");
+    conn.execute(query, ())?;
+    Ok(())
+}
+
+fn make_history(conn: &Connection) -> Result<(), rusqlite::Error> {
+    let query = include_str!("../../sql/history.sql");
     conn.execute(query, ())?;
     Ok(())
 }

src/data_provider/words.rs

@@ -116,7 +116,7 @@ pub fn load_words(connection: &Connection) -> Result<Vec<WordData>, Notification
 
 pub fn load_word_groups(connection: &Connection) -> Result<Vec<WordGroup>, NotificationData> {
     let mut stmt = connection
-        .prepare("SELECT id, name FROM word_group")
+        .prepare("SELECT id, name FROM word_groups")
         .expect("Failed to prepare statement");
     let group_iter = stmt
         .query_map([], |row| {
@@ -138,7 +138,7 @@ pub fn load_word_groups(connection: &Connection) -> Result<Vec<WordGroup>, Notif
 pub fn add_group(group: &mut WordGroup, connection: &Connection) -> MaybeError {
     let index: u32 = connection
         .query_row(
-            "INSERT INTO word_group (name) VALUES (?1) RETURNING id",
+            "INSERT INTO word_groups (name) VALUES (?1) RETURNING id",
             (&group.name,),
             |row| row.get(0),
         )
@@ -154,7 +154,7 @@ pub fn update_group(group: &mut WordGroup, connection: &Connection) -> MaybeErro
     } else {
         connection
             .execute(
-                "UPDATE word_group SET name = ?1 WHERE id = ?2",
+                "UPDATE word_groups SET name = ?1 WHERE id = ?2",
                 (&group.name, &group.id),
             )
             .map_err(|_| DbSaveError)?;
@@ -167,7 +167,7 @@ pub fn delete_group(group: &WordGroup, connection: &Connection) -> MaybeError {
         return Err(DbSaveError);
     }
     connection
-        .execute("DELETE FROM word_group WHERE id = ?1", (&group.id,))
+        .execute("DELETE FROM word_groups WHERE id = ?1", (&group.id,))
         .map_err(|_| DbSaveError)?;
     Ok(())
 }

src/main.rs

@@ -9,7 +9,6 @@ mod navigation;
 pub mod notification;
 mod pages;
 mod styling;
-pub mod tests;
 
 use crate::app::start;
 use mimalloc::MiMalloc;

src/pages/repetition_settings.rs

@@ -1,7 +1,7 @@
 use crate::app::AppState;
 use crate::data::entities::DeckSettings;
-use crate::data_provider::card_sets::{delete_set, update_deck};
+use crate::data_provider::card_states::{delete_stats, load_stats_of_deck};
-use crate::data_provider::card_stats::{delete_stats, load_stats_of_deck};
+use crate::data_provider::decks::{delete_set, update_deck};
 use crate::navigation::Page::PreviousPage;
 use crate::navigation::{NavigatedPage, Page, RootMessage};
 use crate::notification::MaybeError;

src/pages/repetitions.rs

@@ -2,8 +2,8 @@ use crate::app::AppState;
 use crate::core::srs::{AppendMode, OrderMode};
 use crate::data::Id;
 use crate::data::entities::{CardStatistics, DeckSettings};
-use crate::data_provider::card_sets::update_deck;
+use crate::data_provider::card_states::{add_stat_list, load_stats_of_deck};
-use crate::data_provider::card_stats::{add_stat_list, load_stats_of_deck};
+use crate::data_provider::decks::update_deck;
 use crate::navigation::Page::{History, PreviousPage, Repetition, RepetitionSettings};
 use crate::navigation::{NavigatedPage, Page, RootMessage};
 use crate::notification::{MaybeError, NotificationRequest};
@@ -590,7 +590,10 @@ impl RepetitionsState {
                     word_id: word.id,
                     last_open: Utc::now(),
                     score: 1,
+                    fsrs_opened: Utc::now().date_naive(),
+                    fsrs_memory: None,
                     set_id: deck.id,
+                    fsrs_open_day: Utc::now().date_naive(),
                 }
             })
             .collect::<Vec<_>>();

src/tests.rs

@@ -1,123 +0,0 @@
-#[cfg(test)]
-mod mod_tests {
-    use crate::data::Id;
-    use crate::data::entities::{EntityData, EntityHandle};
-    use crate::data::repositories::fast_position_of;
-
-    struct ProtoEntity {
-        id: Id,
-        _data: i128,
-    }
-    impl EntityData for ProtoEntity {
-        fn id(&self) -> Id {
-            self.id
-        }
-
-        fn set_id(&mut self, id: Id) {
-            self.id = id;
-        }
-    }
-
-    impl ProtoEntity {
-        fn new(n: i128) -> Self {
-            Self {
-                id: (n as u32).into(),
-                _data: n,
-            }
-        }
-    }
-
-    #[test]
-    fn search_direct() {
-        let mut entity = EntityHandle::new(8.into(), 3, true);
-        assert_eq!(
-            fast_position_of(&[1, 2, 3, 8, 9, 12].map(ProtoEntity::new), &mut entity),
-            Some(3)
-        );
-    }
-
-    #[test]
-    fn search_0() {
-        let mut entity = EntityHandle::new(8.into(), 4, true);
-        assert_eq!(
-            fast_position_of(&[1, 2, 3, 8, 9, 12].map(ProtoEntity::new), &mut entity),
-            Some(3)
-        );
-    }
-
-    #[test]
-    fn search_1() {
-        let mut entity = EntityHandle::new(9.into(), 5, true);
-        assert_eq!(
-            fast_position_of(&[1, 2, 3, 8, 9, 12].map(ProtoEntity::new), &mut entity),
-            Some(4)
-        );
-    }
-
-    #[test]
-    fn search_2() {
-        let mut entity = EntityHandle::new(106.into(), 25, true);
-        assert_eq!(
-            fast_position_of(
-                &[
-                    1, 2, 3, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 20, 21, 22, 23, 105, 106, 107,
-                    108, 109, 110
-                ]
-                .map(ProtoEntity::new),
-                &mut entity
-            ),
-            Some(18)
-        );
-    }
-
-    #[test]
-    fn id_0() {
-        let entity: EntityHandle<ProtoEntity> = EntityHandle::new(8.into(), 25, true);
-        assert_eq!(entity.real(), true)
-    }
-
-    #[test]
-    fn id_1() {
-        let entity: EntityHandle<ProtoEntity> = EntityHandle::new(8.into(), 25, false);
-        assert_eq!(entity.real(), false)
-    }
-
-    #[test]
-    fn id_3() {
-        let entity: EntityHandle<ProtoEntity> = EntityHandle::new(8.into(), 25, true);
-        assert_eq!(entity.index(), 25)
-    }
-
-    #[test]
-    fn id_4() {
-        let entity: EntityHandle<ProtoEntity> = EntityHandle::new(8.into(), 25, false);
-        assert_eq!(entity.index(), 25)
-    }
-    #[test]
-    fn id_5() {
-        let mut entity: EntityHandle<ProtoEntity> = EntityHandle::new(8.into(), 25, true);
-        entity.set_real(true);
-        assert_eq!(entity.real(), true)
-    }
-
-    #[test]
-    fn id_6() {
-        let mut entity: EntityHandle<ProtoEntity> = EntityHandle::new(8.into(), 25, false);
-        entity.set_real(true);
-        assert_eq!(entity.real(), true)
-    }
-
-    #[test]
-    fn id_7() {
-        let mut entity: EntityHandle<ProtoEntity> = EntityHandle::new(8.into(), 25, true);
-        entity.set_index(0);
-        assert_eq!(entity.index(), 0)
-    }
-
-    #[test]
-    fn id_8() {
-        let mut entity: EntityHandle<ProtoEntity> = EntityHandle::new(8.into(), 25, false);
-        entity.set_index(0);
-        assert_eq!(entity.index(), 0)
-    }
-}