Remove Option for vecs in repetitions

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

Cargo.lock

@@ -152,12 +152,56 @@ version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4b46cbb362ab8752921c97e041f5e366ee6297bd428a31275b9fcf1e380f7299"
 
+[[package]]
+name = "anstream"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "824a212faf96e9acacdbd09febd34438f8f711fb84e09a8916013cd7815ca28d"
+dependencies = [
+ "anstyle",
+ "anstyle-parse",
+ "anstyle-query",
+ "anstyle-wincon",
+ "colorchoice",
+ "is_terminal_polyfill",
+ "utf8parse",
+]
+
 [[package]]
 name = "anstyle"
 version = "1.0.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "940b3a0ca603d1eade50a4846a2afffd5ef57a9feac2c0e2ec2e14f9ead76000"
 
+[[package]]
+name = "anstyle-parse"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52ce7f38b242319f7cabaa6813055467063ecdc9d355bbb4ce0c68908cd8130e"
+dependencies = [
+ "utf8parse",
+]
+
+[[package]]
+name = "anstyle-query"
+version = "1.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "40c48f72fd53cd289104fc64099abca73db4166ad86ea0b4341abe65af83dadc"
+dependencies = [
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "anstyle-wincon"
+version = "3.0.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d"
+dependencies = [
+ "anstyle",
+ "once_cell_polyfill",
+ "windows-sys 0.61.2",
+]
+
 [[package]]
 name = "anyhow"
 version = "1.0.101"
@@ -728,6 +772,12 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3d7b894f5411737b7867f4827955924d7c254fc9f4d91a6aad6b097804b1018b"
 
+[[package]]
+name = "colorchoice"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d07550c9036bf2ae0c684c4297d503f838287c83c53686d05370d0e139ae570"
+
 [[package]]
 name = "combine"
 version = "4.6.7"
@@ -1068,6 +1118,37 @@ version = "0.1.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ac6b926516df9c60bfa16e107b21086399f8285a44ca9711344b9e553c5146e2"
 
+[[package]]
+name = "defmt"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2953bfe4f93bbd20cc71198842756f77d161884c99ebbabc41d80231ded88d1"
+dependencies = [
+ "bitflags 1.3.2",
+ "defmt-macros",
+]
+
+[[package]]
+name = "defmt-macros"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bad9c72e7ca2137e0dc3813245a0d282fd6daad32fd800af018306a9169b5fe8"
+dependencies = [
+ "defmt-parser",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.114",
+]
+
+[[package]]
+name = "defmt-parser"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "10d60334b3b2e7c9d91ef8150abfb6fa4c1c39ebbcf4a81c2e346aad939fee3e"
+dependencies = [
+ "thiserror 2.0.18",
+]
+
 [[package]]
 name = "deranged"
 version = "0.5.8"
@@ -1215,6 +1296,29 @@ dependencies = [
  "syn 2.0.114",
 ]
 
+[[package]]
+name = "env_filter"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "900d271a03799a1ee8d1ca9b19893b48ca674a9284fefcfb85f05e74ed314217"
+dependencies = [
+ "log",
+ "regex",
+]
+
+[[package]]
+name = "env_logger"
+version = "0.11.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "de671bd27a75a797dc9ae289ba1e77276e75e2026408aab65185384e2d5cd3f6"
+dependencies = [
+ "anstream",
+ "anstyle",
+ "env_filter",
+ "jiff",
+ "log",
+]
+
 [[package]]
 name = "equivalent"
 version = "1.0.2"
@@ -2292,6 +2396,12 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "is_terminal_polyfill"
+version = "1.70.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6cb138bb79a146c1bd460005623e142ef0181e3d0219cb493e02f7d08a35695"
+
 [[package]]
 name = "itertools"
 version = "0.13.0"
@@ -2314,10 +2424,12 @@ dependencies = [
  "chrono",
  "criterion",
  "dirs",
+ "env_logger",
  "hashbrown 0.17.1",
  "hex",
  "iced",
  "iced_core",
+ "log",
  "mimalloc",
  "parking_lot",
  "rand",
@@ -2334,6 +2446,42 @@ dependencies = [
  "zstd",
 ]
 
+[[package]]
+name = "jiff"
+version = "0.2.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "668b7183bd07af9a4885f5c35b0cc5c83c4607a913c16b7e17291832910d2dcc"
+dependencies = [
+ "defmt",
+ "jiff-core",
+ "jiff-static",
+ "log",
+ "portable-atomic",
+ "portable-atomic-util",
+ "serde_core",
+]
+
+[[package]]
+name = "jiff-core"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7feca88439efe53da3754500c1851dedf3cb36c524dd5cf8225cc0794de95d09"
+dependencies = [
+ "defmt",
+]
+
+[[package]]
+name = "jiff-static"
+version = "0.2.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3a69dcb3a21cfb32ce1cd056169337ca284af0766dd766e7878819b251a49204"
+dependencies = [
+ "jiff-core",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.114",
+]
+
 [[package]]
 name = "jni"
 version = "0.21.1"
@@ -2584,9 +2732,9 @@ dependencies = [
 
 [[package]]
 name = "log"
-version = "0.4.29"
+version = "0.4.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897"
+checksum = "f9f8bd3e56ce4dfc153cf470fffbfa98c7620958b312ca5c3a4b8d5181fd13c6"
 
 [[package]]
 name = "lru"
@@ -3309,6 +3457,12 @@ dependencies = [
  "portable-atomic",
 ]
 
+[[package]]
+name = "once_cell_polyfill"
+version = "1.70.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe"
+
 [[package]]
 name = "oorandom"
 version = "11.1.5"
@@ -5390,6 +5544,12 @@ version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"
 
+[[package]]
+name = "utf8parse"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
+
 [[package]]
 name = "uuid"
 version = "1.20.0"

Cargo.toml

@@ -24,6 +24,8 @@ mimalloc = "0.1.52"
 hashbrown = "0.17.1"
 rayon = "1.12.0"
 parking_lot = "0.12.5"
+env_logger = "0.11.11"
+log = "0.4.34"
 
 [profile.super-release]
 inherits = "release"

src/app.rs

@@ -0,0 +1,113 @@
+use chrono::NaiveDate;
+use hashbrown::HashMap;
+use iced::{keyboard, window, Subscription};
+use iced_core::{Font, Size, Theme};
+use iced_core::window::Position;
+#[cfg(target_os = "linux")]
+use iced_core::window::settings::PlatformSpecific;
+use log::info;
+use rusqlite::Connection;
+use crate::data::entities::DeckSettings;
+use crate::data_provider::card_sets::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};
+use crate::data::entities::{ WordData, WordGroup};
+use crate::data::Id;
+use crate::navigation::{AppSettings, RootMessage, ScreenState};
+use crate::navigation::RootMessage::Keyboard;
+pub const USER_FONT: Font = Font::with_name("Noto Sans JP");
+
+pub fn start() -> iced::Result {
+    info!("Welcome to JapLearn");
+    iced::application(ScreenState::boot, ScreenState::update, ScreenState::view)
+        .window(window_settings())
+        .subscription(subscription)
+        .title("JapLearn")
+        .settings(iced::Settings {
+            default_text_size: iced::Pixels(18.0),
+            ..iced::Settings::default()
+        })
+        .font(include_bytes!("../noto.ttf"))
+        .default_font(USER_FONT)
+        .theme(Theme::GruvboxDark)
+        .run()
+}
+
+#[allow(unused_mut)]
+fn window_settings() -> window::Settings {
+    let mut settings = window::Settings {
+        position: Position::Centered,
+        min_size: Some(Size::new(700.0_f32, 700.0_f32)),
+        ..Default::default()
+    };
+
+    #[cfg(target_os = "linux")]
+    {
+        settings.platform_specific = PlatformSpecific {
+            application_id: "JapLearn".to_string(),
+            override_redirect: false,
+        };
+    }
+
+    settings
+}
+
+fn subscription(_state: &ScreenState) -> Subscription<RootMessage> {
+    keyboard::listen().map(Keyboard)
+}
+
+pub struct AppState {
+    pub dictionary: Vec<WordData>,
+    pub decks: Vec<DeckSettings>,
+    pub word_groups: Vec<WordGroup>,
+    pub connection: Connection,
+    pub sync_data: AppSettings,
+    pub activity: HashMap<Id, Vec<(NaiveDate, u32)>>,
+}
+
+impl Default for AppState {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl AppState {
+    pub fn new() -> Self {
+        Self {
+            dictionary: vec![],
+            decks: vec![],
+            word_groups: vec![],
+            connection: default_connection(),
+            sync_data: AppSettings {
+                key: None,
+                auto_web_fetch: false,
+            },
+            activity: Default::default(),
+        }
+    }
+}
+
+pub fn fill_state(state: &mut AppState) {
+    let list = load_words(&state.connection);
+    let sets = load_sets(&state.connection);
+    let groups = load_word_groups(&state.connection);
+    let setting = load_settings(&state.connection);
+
+    state.dictionary = list;
+    state.decks = sets;
+    state.word_groups = groups;
+    state.sync_data = setting
+}
+
+fn load_settings(connection: &Connection) -> AppSettings {
+    let key = get_setting("SYNC_KEY".to_string(), connection);
+    let fetch = get_setting("AUTO_WEB_FETCH".to_string(), connection)
+        .unwrap_or("false".to_string())
+        .parse::<bool>()
+        .unwrap();
+    AppSettings {
+        key,
+        auto_web_fetch: fetch,
+    }
+}

src/core.rs

@@ -0,0 +1,3 @@
+pub mod kana_set;
+pub mod srs;
+pub mod deck;

src/core/deck.rs

@@ -0,0 +1,123 @@
+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 chrono::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>,
+    state: Arc<Mutex<AppState>>,
+    order_module: OrderModule,
+    settings: DeckSettings,
+}
+impl DeckData {
+    pub fn new(settings: &DeckSettings, state: Arc<Mutex<AppState>>) -> Self {
+        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)
+                    .unwrap()
+            })
+            .map(|index| &state_locked.dictionary[index])
+            .cloned()
+            .collect();
+
+        Self {
+            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.clone() {
+            OrderModule::SemiRandomSRS(mut module) => {
+                if !module.initialized {
+                    module.init(self)
+                }
+                let index = module.next(self);
+                self.order_module = OrderModule::SemiRandomSRS(module);
+                index
+            }
+            OrderModule::RandomSRS(mut module) => {
+                if !module.initialized {
+                    module.init(self)
+                }
+                let index = module.next(self);
+                self.order_module = OrderModule::RandomSRS(module);
+                index
+            }
+            OrderModule::WorstWordsSRS(mut module) => {
+                if !module.initialized {
+                    module.init(self)
+                }
+                let index = module.next(self);
+                self.order_module = OrderModule::WorstWordsSRS(module);
+                index
+            }
+        };
+
+        self.current_word_index = Some(index);
+        (self.words[index].clone(), self.set[index].clone())
+    }
+    pub fn open(&mut self, status: WordOpenMode) {
+        if self.current_word_index.is_none() {
+            return;
+        }
+        let index = self.current_word_index.unwrap();
+
+        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,
+            },
+        );
+    }
+    pub fn len(&self) -> usize {
+        self.set.len()
+    }
+}
+

src/core/kana_set.rs

@@ -0,0 +1,201 @@
+#[derive(Clone, Debug)]
+pub struct KanaSet {
+    name: String,
+    pub(crate) chars_type: KanaType,
+    pub(crate) dictionary: Vec<Vec<(String, String)>>,
+    pub(crate) include_map: [bool; 10],
+}
+#[derive(Clone, Debug)]
+pub enum KanaType {
+    Hiragana,
+    Katakana,
+}
+impl KanaSet {
+    pub fn hiragana() -> Self {
+        Self {
+            name: "Хирагана".to_string(),
+            chars_type: KanaType::Hiragana,
+            dictionary: vec![
+                vec![
+                    (String::from("ぁ"), String::from("a")),
+                    (String::from("ぃ"), String::from("i")),
+                    (String::from("ぅ"), String::from("u")),
+                    (String::from("ぇ"), String::from("e")),
+                    (String::from("ぉ"), String::from("o")),
+                ],
+                vec![
+                    (String::from("さ"), String::from("sa")),
+                    (String::from("し"), String::from("shi")),
+                    (String::from("す"), String::from("su")),
+                    (String::from("せ"), String::from("se")),
+                    (String::from("そ"), String::from("so")),
+                ],
+                vec![
+                    (String::from("か"), String::from("ka")),
+                    (String::from("き"), String::from("ki")),
+                    (String::from("く"), String::from("ku")),
+                    (String::from("け"), String::from("ke")),
+                    (String::from("こ"), String::from("ko")),
+                ],
+                // Ряд «та» (たちつてと)
+                vec![
+                    (String::from("た"), String::from("ta")),
+                    (String::from("ち"), String::from("chi")),
+                    (String::from("つ"), String::from("tsu")),
+                    (String::from("て"), String::from("te")),
+                    (String::from("と"), String::from("to")),
+                ],
+                // Ряд «на» (なにぬねの)
+                vec![
+                    (String::from("な"), String::from("na")),
+                    (String::from("に"), String::from("ni")),
+                    (String::from("ぬ"), String::from("nu")),
+                    (String::from("ね"), String::from("ne")),
+                    (String::from("の"), String::from("no")),
+                ],
+                // Ряд «ха» (はひふへほ)
+                vec![
+                    (String::from("は"), String::from("ha")),
+                    (String::from("ひ"), String::from("hi")),
+                    (String::from("ふ"), String::from("fu")),
+                    (String::from("へ"), String::from("he")),
+                    (String::from("ほ"), String::from("ho")),
+                ],
+                // Ряд «ма» (まみむめも)
+                vec![
+                    (String::from("ま"), String::from("ma")),
+                    (String::from("み"), String::from("mi")),
+                    (String::from("む"), String::from("mu")),
+                    (String::from("め"), String::from("me")),
+                    (String::from("も"), String::from("mo")),
+                ],
+                // Ряд «я» (やゆよ) — только 3 символа
+                vec![
+                    (String::from("や"), String::from("ya")),
+                    (String::from("ゆ"), String::from("yu")),
+                    (String::from("よ"), String::from("yo")),
+                ],
+                // Ряд «ра» (らりるれろ)
+                vec![
+                    (String::from("ら"), String::from("ra")),
+                    (String::from("り"), String::from("ri")),
+                    (String::from("る"), String::from("ru")),
+                    (String::from("れ"), String::from("re")),
+                    (String::from("ろ"), String::from("ro")),
+                ],
+                vec![
+                    (String::from("わ"), String::from("wa")),
+                    (String::from("を"), String::from("wo")),
+                    (String::from("ん"), String::from("n")),
+                ],
+            ],
+            include_map: [true; 10],
+        }
+    }
+
+    pub fn katakana() -> Self {
+        Self {
+            name: "Катакана".to_string(),
+            chars_type: KanaType::Katakana,
+            dictionary: vec![
+                vec![
+                    (String::from("ァ"), String::from("a")),
+                    (String::from("ィ"), String::from("i")),
+                    (String::from("ゥ"), String::from("u")),
+                    (String::from("ェ"), String::from("e")),
+                    (String::from("ォ"), String::from("o")),
+                ],
+                vec![
+                    (String::from("サ"), String::from("sa")),
+                    (String::from("シ"), String::from("shi")),
+                    (String::from("ス"), String::from("su")),
+                    (String::from("セ"), String::from("se")),
+                    (String::from("ソ"), String::from("so")),
+                ],
+                vec![
+                    (String::from("カ"), String::from("ka")),
+                    (String::from("キ"), String::from("ki")),
+                    (String::from("ク"), String::from("ku")),
+                    (String::from("ケ"), String::from("ke")),
+                    (String::from("コ"), String::from("ko")),
+                ],
+                // Ряд «та» (タチツテト)
+                vec![
+                    (String::from("タ"), String::from("ta")),
+                    (String::from("チ"), String::from("chi")),
+                    (String::from("ツ"), String::from("tsu")),
+                    (String::from("テ"), String::from("te")),
+                    (String::from("ト"), String::from("to")),
+                ],
+                // Ряд «на» (ナニヌネノ)
+                vec![
+                    (String::from("ナ"), String::from("na")),
+                    (String::from("ニ"), String::from("ni")),
+                    (String::from("ヌ"), String::from("nu")),
+                    (String::from("ネ"), String::from("ne")),
+                    (String::from("ノ"), String::from("no")),
+                ],
+                // Ряд «ха» (ハヒフヘホ)
+                vec![
+                    (String::from("ハ"), String::from("ha")),
+                    (String::from("ヒ"), String::from("hi")),
+                    (String::from("フ"), String::from("fu")),
+                    (String::from("ヘ"), String::from("he")),
+                    (String::from("ホ"), String::from("ho")),
+                ],
+                // Ряд «ма» (マミムメモ)
+                vec![
+                    (String::from("マ"), String::from("ma")),
+                    (String::from("ミ"), String::from("mi")),
+                    (String::from("ム"), String::from("mu")),
+                    (String::from("メ"), String::from("me")),
+                    (String::from("モ"), String::from("mo")),
+                ],
+                // Ряд «я» (ヤユヨ) — только 3 символа
+                vec![
+                    (String::from("ヤ"), String::from("ya")),
+                    (String::from("ユ"), String::from("yu")),
+                    (String::from("ヨ"), String::from("yo")),
+                ],
+                // Ряд «ра» (ラリルレロ)
+                vec![
+                    (String::from("ラ"), String::from("ra")),
+                    (String::from("リ"), String::from("ri")),
+                    (String::from("ル"), String::from("ru")),
+                    (String::from("レ"), String::from("re")),
+                    (String::from("ロ"), String::from("ro")),
+                ],
+                vec![
+                    (String::from("ワ"), String::from("wa")),
+                    (String::from("ヲ"), String::from("wo")),
+                    (String::from("ン"), String::from("n")),
+                ],
+            ],
+            include_map: [true; 10],
+        }
+    }
+
+    pub fn list(&self) -> Vec<(String, String)> {
+        let mut current_set: Vec<(String, String)> = Vec::new();
+
+        for i in 0..10 {
+            if self.include_map[i] {
+                self.dictionary[i].iter().for_each(|v| {
+                    current_set.push(v.clone());
+                });
+            }
+        }
+
+        current_set
+    }
+}
+impl Default for KanaSet {
+    fn default() -> Self {
+        KanaSet::hiragana()
+    }
+}
+impl PartialEq<Self> for KanaSet {
+    fn eq(&self, other: &Self) -> bool {
+        self.name == other.name
+    }
+}

src/core/srs.rs

@@ -0,0 +1,188 @@
+use crate::core::deck::DeckData;
+use rand::distr::weighted::WeightedIndex;
+use rand::prelude::ThreadRng;
+use rand::prelude::{Distribution, SliceRandom};
+use rand::rng;
+use crate::data::entities::CardStatistics;
+
+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;
+
+#[derive(Clone, PartialEq, Copy, Eq)]
+pub enum OrderMode {
+    Default,
+    TrainWorstFirst,
+    FullRandom,
+}
+#[derive(Clone, Copy, Eq, PartialEq, Default)]
+pub enum AppendMode {
+    Full,
+    #[default]
+    Manual,
+}
+#[derive(Clone)]
+pub enum OrderModule {
+    SemiRandomSRS(SemiRandomSRSModule),
+    RandomSRS(RandomSRSModule),
+    WorstWordsSRS(WorstWordsSRSModule),
+}
+pub trait SRSModule {
+    fn next(&mut self, set: &mut DeckData) -> usize;
+    fn open(&mut self, status: WordOpenMode, index: usize, updated_word: &CardStatistics);
+    fn init(&mut self, set: &mut DeckData);
+}
+#[derive(Clone)]
+pub struct RandomSRSModule {
+    basket: Vec<usize>,
+    pub(crate) initialized: bool,
+}
+impl RandomSRSModule {
+    pub(crate) fn new() -> RandomSRSModule {
+        Self {
+            basket: vec![],
+            initialized: false,
+        }
+    }
+}
+impl SRSModule for RandomSRSModule {
+    fn next(&mut self, set: &mut DeckData) -> usize {
+        match self.basket.pop() {
+            Some(index) => index,
+            None => {
+                self.basket = (0..set.words.len()).collect::<Vec<usize>>();
+                self.basket.shuffle(&mut rand::rng());
+                self.basket.pop().expect("empty basket")
+            }
+        }
+    }
+
+    fn open(&mut self, _: WordOpenMode, _: usize, _: &CardStatistics) {}
+
+    fn init(&mut self, set: &mut DeckData) {
+        self.initialized = true;
+        self.basket = (0..set.set.len()).collect::<Vec<usize>>();
+        self.basket.shuffle(&mut rand::rng())
+    }
+}
+#[derive(Clone)]
+pub struct SemiRandomSRSModule {
+    history: Vec<usize>,
+    last_weights: WeightedIndex<f32>,
+    generator: ThreadRng,
+    pub(crate) initialized: bool,
+}
+impl SemiRandomSRSModule {
+    pub(crate) fn new() -> SemiRandomSRSModule {
+        SemiRandomSRSModule {
+            history: vec![],
+            last_weights: WeightedIndex::new([1.0]).unwrap(),
+            generator: rng(),
+            initialized: false,
+        }
+    }
+}
+impl SRSModule for SemiRandomSRSModule {
+    fn next(&mut self, set: &mut DeckData) -> usize {
+        let index = self.last_weights.sample(&mut self.generator);
+
+        if self.history.contains(&index) && self.history.len() != 1 {
+            return self.next(set);
+        }
+
+        if self.history.len() == self.history_len(set) {
+            self.history.remove(0);
+        }
+        self.history.push(index);
+
+        index
+    }
+    fn open(&mut self, _: WordOpenMode, index: usize, word: &CardStatistics) {
+        let new_weight = (100.0 / word.calculated_score()).powf(2.0);
+        self.last_weights
+            .update_weights(&[(index, &new_weight)])
+            .expect("update weights error");
+    }
+    fn init(&mut self, set: &mut DeckData) {
+        self.initialized = true;
+        let weights = set
+            .set
+            .iter()
+            .map(|s| (100.0 / s.calculated_score()).powf(2.0) * 2.0)
+            .collect::<Vec<f32>>();
+        self.last_weights = WeightedIndex::new(weights).unwrap();
+    }
+}
+impl SemiRandomSRSModule {
+    fn history_len(&self, set: &DeckData) -> usize {
+        ((set.len() as f32 * MAX_HISTORY_LEN_PART) as usize).clamp(1, MAX_HISTORY_LEN)
+    }
+}
+#[derive(Clone)]
+pub struct WorstWordsSRSModule {
+    pub(crate) initialized: bool,
+    pool_size: usize,
+    rounds_remaining: u8,
+    pool: Vec<usize>,
+    queue: Vec<usize>,
+    rounds_count: u8,
+}
+impl SRSModule for WorstWordsSRSModule {
+    fn next(&mut self, set: &mut DeckData) -> usize {
+        if self.rounds_remaining == 0 {
+            self.fill_pool(set);
+            self.rounds_remaining = self.rounds_count;
+        }
+
+        match self.queue.pop() {
+            Some(index) => index,
+            None => {
+                self.queue.append(&mut self.pool.clone());
+                self.rounds_remaining -= 1;
+                self.queue.pop().expect("empty queue")
+            }
+        }
+    }
+
+    fn open(&mut self, _: WordOpenMode, _: usize, _: &CardStatistics) {}
+
+    fn init(&mut self, _: &mut DeckData) {
+        self.initialized = true;
+    }
+}
+impl WorstWordsSRSModule {
+    pub(crate) fn new() -> WorstWordsSRSModule {
+        WorstWordsSRSModule {
+            initialized: false,
+            pool_size: 15,
+            rounds_count: 2,
+            rounds_remaining: 0,
+            pool: vec![],
+            queue: vec![],
+        }
+    }
+    fn fill_pool(&mut self, set: &DeckData) {
+        let mut sorted = set
+            .set
+            .clone()
+            .into_iter()
+            .zip(0..set.set.len())
+            .collect::<Vec<_>>();
+        sorted.sort_by_key(|c| c.0.score);
+        let mut worst = sorted[0..self.pool_size]
+            .iter()
+            .map(|(_, index)| *index)
+            .collect::<Vec<usize>>();
+        worst.shuffle(&mut rand::rng());
+        self.pool = worst;
+    }
+}
+
+#[derive(Clone, Copy)]
+pub enum WordOpenMode {
+    Easy,
+    Ok,
+    Hard,
+    None,
+}

src/data.rs

@@ -0,0 +1,62 @@
+pub mod entities;
+
+use std::fmt::{Display, Formatter};
+use std::num::ParseIntError;
+use std::str::FromStr;
+use rusqlite::ToSql;
+use rusqlite::types::{FromSql, FromSqlError, FromSqlResult, ToSqlOutput, ValueRef};
+
+#[derive(Clone, PartialEq, Eq, Debug, Hash, Copy, Ord, PartialOrd)]
+pub struct Id(pub(crate) u32);
+pub const INVALID_ID: Id = Id(0);
+impl FromStr for Id {
+    type Err = ParseIntError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Ok(Id(s.parse::<u32>()?))
+    }
+}
+
+impl From<u32> for Id {
+    fn from(value: u32) -> Self {
+        Id(value)
+    }
+}
+
+impl From<Id> for u32 {
+    fn from(value: Id) -> Self {
+        value.0
+    }
+}
+impl Display for Id {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
+impl FromSql for Id {
+    fn column_result(value: ValueRef<'_>) -> FromSqlResult<Self> {
+        match value {
+            ValueRef::Integer(i) => Ok(Id(i as u32)),
+            _ => Err(FromSqlError::InvalidType),
+        }
+    }
+}
+
+impl ToSql for Id {
+    fn to_sql(&self) -> rusqlite::Result<ToSqlOutput<'_>> {
+        Ok(ToSqlOutput::from(self.0 as i64))
+    }
+}
+
+impl From<Id> for String {
+    fn from(value: Id) -> Self {
+        value.0.to_string()
+    }
+}
+
+impl Id {
+    pub(crate) fn is_valid(self) -> bool {
+        self.0 != 0
+    }
+}

src/data/entities.rs

@@ -0,0 +1,163 @@
+use crate::app::AppState;
+use crate::core::srs::{FADE_PER_DAY, MAX_SCORE, OrderMode, WordOpenMode};
+use crate::data::{INVALID_ID, Id};
+use chrono::{DateTime, Utc};
+use log::info;
+use rayon::prelude::*;
+use rhai::{Engine, Scope};
+use std::collections::HashMap;
+use std::time::Instant;
+
+#[derive(Clone, Debug)]
+pub struct WordData {
+    pub id: Id,
+    pub key: String,
+    pub value: String,
+    pub tags: String,
+    pub additional: HashMap<String, String>,
+    pub group_id: Id,
+}
+#[derive(Clone)]
+pub struct WordGroup {
+    pub id: Id,
+    pub name: String,
+}
+
+impl WordData {
+    pub fn new() -> Self {
+        Self {
+            id: INVALID_ID,
+            key: String::new(),
+            value: String::new(),
+            tags: String::new(),
+            additional: Default::default(),
+            group_id: 1.into(),
+        }
+    }
+}
+
+#[derive(Clone)]
+pub struct HistoryItem {
+    pub timestamp: DateTime<Utc>,
+    pub word_id: Id,
+    pub mode: WordOpenMode,
+    pub before: u8,
+    pub after: u8,
+}
+
+#[derive(Clone)]
+pub struct DeckSettings {
+    pub id: Id,
+    pub name: String,
+    pub forward: String,
+    pub backward: String,
+    pub filter: String,
+    pub count: Option<usize>,
+    pub open_mode: OrderMode,
+}
+impl DeckSettings {
+    pub(crate) fn with_name(name: String) -> DeckSettings {
+        DeckSettings {
+            id: 0.into(),
+            name,
+            forward: "".to_string(),
+            backward: "".to_string(),
+            filter: "true".to_string(),
+            count: None,
+            open_mode: OrderMode::Default,
+        }
+    }
+    pub fn check_filter(&self) -> bool {
+        let time = Instant::now();
+        let engine = Engine::new();
+        let ast = engine.compile(&self.filter);
+        info!("Compile time is {:?}", time.elapsed());
+        ast.is_ok()
+    }
+    pub fn get_word_list(&self, state: &AppState) -> Vec<usize> {
+        let time = Instant::now();
+        let mut list = vec![];
+        let engine = Engine::new();
+
+        let ast = engine.compile(&self.filter);
+        if let Ok(ast) = ast {
+            let groups = &state.word_groups;
+
+            list = state
+                .dictionary
+                .par_iter()
+                .enumerate()
+                .filter(|(_, 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();
+                    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",
+                            groups
+                                .iter()
+                                .find(|g| g.id == word.group_id)
+                                .cloned()
+                                .unwrap()
+                                .name,
+                        );
+
+                    let result = engine.eval_ast_with_scope::<bool>(&mut scope, &ast);
+                    result.is_ok() && result.unwrap()
+                })
+                .map(|(index, _)| index)
+                .collect();
+
+            info!("Collecting available words is {:?}", time.elapsed());
+
+            list
+        } else {
+            list
+        }
+    }
+    pub fn require_speech(&self) -> bool {
+        self.forward == "speech" || self.backward == "speech"
+    }
+}
+
+#[derive(Clone, PartialEq)]
+pub struct CardStatistics {
+    pub id: Id,
+    pub word_id: Id,
+    pub set_id: Id,
+    pub last_open: DateTime<Utc>,
+    pub score: u8,
+}
+impl CardStatistics {
+    pub fn update(&mut self, status: WordOpenMode) {
+        match status {
+            WordOpenMode::Easy => {
+                self.score = (self.calculated_score() + 5.0).round() as u8;
+            }
+            WordOpenMode::Ok => self.score = (self.calculated_score() + 2.0).round() as u8,
+            WordOpenMode::Hard => {
+                self.score = (self.calculated_score() * 0.75).round() as u8;
+            }
+            WordOpenMode::None => {
+                self.score = (self.calculated_score() * 0.4) as u8;
+            }
+        }
+
+        self.score = self.score.clamp(1, MAX_SCORE);
+        self.last_open = Utc::now();
+    }
+
+    pub fn calculated_score(&self) -> f32 {
+        let time = Utc::now() - self.last_open;
+        let days = time.num_days();
+        let multiplier = FADE_PER_DAY.powi(days as i32);
+        (self.score as f32 * multiplier).max(1.0)
+    }
+}

src/data_provider/card_sets.rs

@@ -1,5 +1,6 @@
-use crate::lang::{DeckSettings, OrderMode};
+use crate::core::srs::OrderMode;
 
+use crate::data::entities::DeckSettings;
 use rusqlite::Connection;
 
 pub fn load_sets(connection: &Connection) -> Vec<DeckSettings> {
@@ -15,7 +16,6 @@ pub fn load_sets(connection: &Connection) -> Vec<DeckSettings> {
                 backward: row.get(3)?,
                 filter: row.get(4)?,
                 count: None,
-                worst_words_list: None,
                 open_mode: OrderMode::Default,
             })
         })

src/data_provider/card_stats.rs

@@ -1,6 +1,7 @@
-use crate::lang::{CardStatistics, DeckSettings};
 use rusqlite::{Connection, params};
 use std::time::Instant;
+use log::info;
+use crate::data::entities::{CardStatistics, DeckSettings};
 
 pub fn load_stats_of_deck(set: &DeckSettings, connection: &Connection) -> Vec<CardStatistics> {
     let mut stmt = connection
@@ -58,7 +59,7 @@ pub fn add_stat_list(stats: &mut [CardStatistics], connection: &mut Connection)
         stats[index].id = id.into();
     }
 
-    println!("Added {} cards for {:?}", stats.len(), time.elapsed());
+    info!("Added {} cards for {:?}", stats.len(), time.elapsed());
 }
 
 pub fn update_stat_score(stat: &CardStatistics, connection: &Connection) {
@@ -70,7 +71,7 @@ pub fn update_stat_score(stat: &CardStatistics, connection: &Connection) {
             (&stat.score, &stat.last_open.timestamp(), &stat.id),
         )
         .unwrap();
-    println!("Updated stat: {}", time.elapsed().as_millis());
+    info!("Updated stat: {}", time.elapsed().as_millis());
 }
 
 pub fn delete_stats(stat: &[CardStatistics], connection: &Connection) {

src/data_provider/history.rs

@@ -1,20 +1,23 @@
-use crate::dictionary::app_data_dir;
+use crate::core::srs::WordOpenMode;
-use crate::lang::{Id, WordOpenMode};
+use crate::data::entities::HistoryItem;
-use chrono::{DateTime, Utc};
+use crate::data::Id;
-use std::fs;
+use crate::fs::*;
+use crate::notification::NotificationData;
+use crate::notification::NotificationData::PermissionDenied;
+use chrono::DateTime;
 use std::fs::{File, OpenOptions};
 use std::io::Write;
 use std::io::{BufRead, BufReader};
 use std::path::PathBuf;
 
-pub fn get_history_of_set(id: Id) -> Vec<HistoryItem> {
+pub fn get_history_of_set(id: Id) -> Result<Vec<HistoryItem>, NotificationData> {
-    let app_dir = history_dir();
+    let app_dir = history_dir()?;
     let head = app_dir.clone().join(format!("set_{}_history.csv", id));
     let mut lines = Vec::new();
 
     append_lines_if_exists(head, &mut lines);
     lines.reverse();
-    parse_history_items(lines)
+    Ok(parse_history_items(lines))
 }
 
 fn append_lines_if_exists(path: PathBuf, lines: &mut Vec<String>) {
@@ -56,15 +59,15 @@ fn parse_history_items(strings: Vec<String>) -> Vec<HistoryItem> {
     items
 }
 
-pub fn push_note(set_id: Id, item: HistoryItem) {
+pub fn push_note(set_id: Id, item: HistoryItem) -> Result<(), NotificationData> {
-    let app_dir = history_dir();
+    let app_dir = history_dir()?;
     let path = app_dir.clone().join(format!("set_{}_history.csv", set_id));
 
     let mut file = OpenOptions::new()
         .create(true)
         .append(true)
         .open(path)
-        .unwrap();
+        .map_err(|_| PermissionDenied)?;
     let line_str = format!(
         "{};{};{};{};{}",
         item.timestamp.timestamp(),
@@ -78,22 +81,8 @@ pub fn push_note(set_id: Id, item: HistoryItem) {
         item.before,
         item.after
     );
-    writeln!(&mut file, "{}", line_str).unwrap();
+    writeln!(&mut file, "{}", line_str).map_err(|_| PermissionDenied)?;
+    Ok(())
 }
 
-pub fn history_dir() -> PathBuf {
-    let directory = app_data_dir().join("history");
-    if !directory.exists() {
-        fs::create_dir(directory.clone()).unwrap();
-    }
-    directory
-}
 
-#[derive(Clone)]
-pub struct HistoryItem {
-    pub timestamp: DateTime<Utc>,
-    pub word_id: Id,
-    pub mode: WordOpenMode,
-    pub before: u8,
-    pub after: u8,
-}

src/data_provider/import.rs

@@ -1,4 +1,6 @@
+use crate::notification::NotificationData;
 use hashbrown::HashMap;
+use log::info;
 use rusqlite::Connection;
 use serde_json::Value;
 
@@ -21,58 +23,73 @@ pub struct ImportNote {
     pub fields: Vec<String>,
 }
 
-pub fn load_groups(connection: &Connection) -> ImportData {
+pub fn load_groups(connection: &Connection) -> Result<ImportData, NotificationData> {
     let json_models: String = connection
         .query_one("select models from col", (), |row| row.get(0))
-        .unwrap();
+        .map_err(|_| NotificationData::IncorrectAnkiFile)?;
-    let raw: Value = serde_json::from_str(json_models.as_str()).unwrap();
+    let raw: Value = serde_json::from_str(json_models.as_str())
-    let sets = raw.as_object().unwrap();
+        .map_err(|_| NotificationData::IncorrectAnkiFile)?;
-    let mut total_data = ImportData(vec![]);
+    let sets = raw.as_object();
+    if let Some(sets) = sets {
+        let mut total_data = ImportData(vec![]);
 
-    let mut count_stmt = connection
+        let mut count_stmt = connection
-        .prepare("select mid, count(id) from notes group by mid")
+            .prepare("select mid, count(id) from notes group by mid")
-        .unwrap();
+            .map_err(|_| NotificationData::IncorrectAnkiFile)?;
 
-    let counts = count_stmt
+        let counts = count_stmt
-        .query_map([], |row| Ok((row.get(0)?, row.get(1)?)))
+            .query_map([], |row| Ok((row.get(0)?, row.get(1)?)))
-        .unwrap()
+            .unwrap()
-        .map(|x| x.unwrap())
+            .map(|x| x.unwrap())
-        .collect::<Vec<(i64, i64)>>();
+            .collect::<Vec<(i64, i64)>>();
 
-    for (_, collection) in sets {
+        for (_, collection) in sets {
-        let fields_property = collection.get("fields");
+            let fields_property = collection.get("fields");
-        if let Some(fields_property) = fields_property {
+            if let Some(fields_property) = fields_property {
-            let fields = fields_property
+                let fields = fields_property
-                .as_array()
+                    .as_array()
-                .unwrap()
+                    .unwrap()
-                .iter()
+                    .iter()
-                .map(|x| x["name"].as_str().unwrap().to_string())
+                    .filter_map(|x| x.get("name"))
-                .collect();
+                    .map(|x| x.as_str().unwrap().to_string())
-            let mut group = ImportGroup {
+                    .collect();
-                id: collection["id"].as_u64().unwrap(),
+                let id = collection.get("id");
-                name: collection["name"].as_str().unwrap().to_string(),
+                if id.is_none() {
-                fields,
+                    return Err(NotificationData::IncorrectAnkiFile);
-                mapping: Default::default(),
+                }
-                length: 0,
+                let id = id.unwrap().as_u64().unwrap();
-                imported: false,
+                let name = collection.get("name");
-            };
+                if name.is_none() {
-            if let Some((_, count)) = counts.iter().find(|(id, _)| *id == group.id as i64) {
+                    return Err(NotificationData::IncorrectAnkiFile);
-                group.length = *count as u64
+                }
+                let name = name.unwrap().as_str().unwrap().to_string();
+
+                let mut group = ImportGroup {
+                    id,
+                    name,
+                    fields,
+                    mapping: Default::default(),
+                    length: 0,
+                    imported: false,
+                };
+                if let Some((_, count)) = counts.iter().find(|(id, _)| *id == group.id as i64) {
+                    group.length = *count as u64
+                }
+                info!("{:?}", group);
+                total_data.0.push(group);
             }
-            println!("{:?}", group);
-            total_data.0.push(group);
         }
-
+        return Ok(total_data)
     }
-    total_data
+    Err(NotificationData::IncorrectAnkiFile)
 }
 
-pub fn get_words_of_group(connection: &Connection, group_id: u64) -> Vec<ImportNote> {
+pub fn get_words_of_group(connection: &Connection, group_id: u64) -> Result<Vec<ImportNote>, NotificationData> {
     let mut count_stmt = connection
         .prepare("select tags, flds from notes where mid == ?1;")
-        .unwrap();
+        .map_err(|_| NotificationData::IncorrectAnkiFile)?;
 
-    count_stmt
+    Ok(count_stmt
         .query_map((group_id as i64,), |row| {
             Ok(ImportNote {
                 tags: row.get(0)?,
@@ -83,7 +100,7 @@ pub fn get_words_of_group(connection: &Connection, group_id: u64) -> Vec<ImportN
                     .collect(),
             })
         })
-        .unwrap()
+        .map_err(|_| NotificationData::IncorrectAnkiFile)?
         .map(|x| x.unwrap())
-        .collect::<Vec<ImportNote>>()
+        .collect::<Vec<ImportNote>>())
 }

src/data_provider/sqlite.rs

@@ -1,24 +1,17 @@
-use crate::dictionary::app_data_dir;
 use rusqlite::Connection;
+use crate::fs::*;
 
 pub fn create_db() {
-    let path = app_data_dir();
+    let db_file = db_path();
-    let db_file = path.join("data.db");
     if !db_file.exists() {
         std::fs::File::create(&db_file).unwrap();
         let connection = Connection::open(&db_file).unwrap();
         connection.execute("PRAGMA foreign_keys = ON;", []).unwrap();
 
         create_tables(&connection);
-    } else {
-        let connection = Connection::open(&db_file).unwrap();
-
-        ensure_db_schema(&connection);
     }
 }
 
-fn ensure_db_schema(_: &Connection) {}
-
 fn create_tables(conn: &Connection) {
     make_card_set(conn).unwrap();
     make_settings(conn).unwrap();
@@ -57,8 +50,7 @@ fn make_card_stats(conn: &Connection) -> Result<(), rusqlite::Error> {
 }
 
 pub fn default_connection() -> Connection {
-    let path = app_data_dir();
+    let db_file = db_path();
-    let db_file = path.join("data.db");
     let connection = Connection::open(db_file).unwrap();
     connection.execute("PRAGMA foreign_keys = ON;", []).unwrap();
     connection

src/data_provider/voice.rs

@@ -1,15 +1,14 @@
-use crate::dictionary::app_data_dir;
 use reqwest::Client;
 use sha2::{Digest, Sha256};
 use std::fs::File;
 use std::io::BufReader;
+use crate::fs::*;
+use crate::notification::NotificationData;
+use crate::notification::NotificationData::*;
+
+pub async fn get_voice(text: &str) -> Result<BufReader<File>, NotificationData> {
+    let mut path = voice_dir()?;
 
-pub async fn get_voice(text: &str) -> Result<BufReader<File>, ()> {
-    let mut path = app_data_dir();
-    path.push("voice");
-    if !path.exists() {
-        std::fs::create_dir(path.clone()).map_err(|_| ())?;
-    }
     let hash = format!("{}.wav", hex::encode(Sha256::digest(text.as_bytes())));
     path.push(hash);
     if !path.exists() {
@@ -20,7 +19,7 @@ pub async fn get_voice(text: &str) -> Result<BufReader<File>, ()> {
             .send()
             .await;
 
-        let query = query.map_err(|_| ())?.text().await.map_err(|_| ())?;
+        let query = query.map_err(|_| VoiceVoxUnavailable)?.text().await.map_err(|_| VoiceVoxUnavailable)?;
         // Synthesis
         let audio = client
             .post(format!("{engine_url}/synthesis?speaker=11"))
@@ -28,13 +27,13 @@ pub async fn get_voice(text: &str) -> Result<BufReader<File>, ()> {
             .body(query)
             .send()
             .await
-            .map_err(|_| ())?
+            .map_err(|_| VoiceVoxUnavailable)?
             .bytes()
             .await
-            .map_err(|_| ())?;
+            .map_err(|_| VoiceVoxUnavailable)?;
 
-        tokio::fs::write(&path, &audio).await.map_err(|_| ())?;
+        tokio::fs::write(&path, &audio).await.map_err(|_| PermissionDenied)?;
     }
 
-    Ok(BufReader::new(File::open(path).map_err(|_| ())?))
+    Ok(BufReader::new(File::open(path).map_err(|_| PermissionDenied)?))
 }

src/data_provider/web_api.rs

@@ -1,17 +1,18 @@
-use crate::dictionary::app_data_dir;
 use std::io;
-use reqwest::Error;
+use log::info;
 use tokio::fs::{File, OpenOptions};
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
 use zstd::{DEFAULT_COMPRESSION_LEVEL, Decoder, Encoder};
+use crate::fs::*;
+use crate::notification::NotificationData;
+use crate::notification::NotificationData::{PermissionDenied, WebApiUnavailable};
 
 // const API_URL: &str = "http://127.0.0.1:8089/";
 const API_URL: &str = "https://learning.micialware.ru/";
 
-pub async fn send_data(id: String) -> Result<(), ()> {
+pub async fn send_data(id: String) -> Result<(), NotificationData> {
-    let path = app_data_dir();
+    let db_file = db_path();
-    let db_file = path.join("data.db");
+    let data = tokio::fs::read(db_file).await.map_err(|_| WebApiUnavailable)?;
-    let data = tokio::fs::read(db_file).await.map_err(|_| ())?;
     let data = compress(data);
 
     let api_url = API_URL.to_string();
@@ -22,10 +23,10 @@ pub async fn send_data(id: String) -> Result<(), ()> {
         .post(&id_url)
         .body(data)
         .send()
-        .await.map_err(|_| ())?
+        .await.map_err(|_| WebApiUnavailable)?
         .text()
-        .await.map_err(|_| ())?;
+        .await.map_err(|_| WebApiUnavailable)?;
-    set_local_version(new_version.parse::<u32>().unwrap()).await;
+    set_local_version(new_version.parse::<u32>().unwrap_or_default()).await;
     Ok(())
 }
 
@@ -35,16 +36,16 @@ fn compress(data: Vec<u8>) -> Vec<u8> {
     encoder.finish().unwrap()
 }
 
-pub async fn load_data(id: String, temp: bool) -> Result<(), Error> {
+pub async fn load_data(id: String, temp: bool) -> Result<(), NotificationData> {
     let api_url = API_URL.to_string();
     let id_url = format!("{api_url}download/{id}");
     let client = reqwest::Client::new();
     let data = client
         .get(&id_url)
         .send()
-        .await?
+        .await.map_err(|_| WebApiUnavailable)?
         .bytes()
-        .await?
+        .await.map_err(|_| WebApiUnavailable)?
         .to_vec();
     let data = decompress(data);
 
@@ -52,15 +53,15 @@ pub async fn load_data(id: String, temp: bool) -> Result<(), Error> {
     let file_name = if temp { "data.db.tmp" } else { "data.db" };
     let db_file = path.join(file_name);
 
-    tokio::fs::write(db_file, data).await.unwrap();
+    tokio::fs::write(db_file, data).await.map_err(|_| PermissionDenied)?;
 
     let version_url = format!("{API_URL}{id}/version");
     let version = client
         .get(&version_url)
         .send()
-        .await?
+        .await.map_err(|_| WebApiUnavailable)?
         .text()
-        .await?;
+        .await.map_err(|_| WebApiUnavailable)?;
     set_local_version(version.parse::<u32>().unwrap_or_default()).await;
     Ok(())
 }
@@ -70,12 +71,12 @@ pub fn decompress(data: Vec<u8>) -> Vec<u8> {
     let mut decompressed = Vec::new();
     let res = io::copy(&mut decoder, &mut decompressed);
     if let Err(e) = res {
-        println!("{}", e);
+        info!("{}", e);
     }
     decompressed
 }
 
-pub async fn first_sync() -> Result<String, ()> {
+pub async fn first_sync() -> Result<String, NotificationData> {
     let id_url = API_URL.to_string() + "generate";
 
     let client = reqwest::Client::new();
@@ -83,24 +84,24 @@ pub async fn first_sync() -> Result<String, ()> {
         .get(&id_url)
         .send()
         .await
-        .map_err(|_| ())?
+        .map_err(|_| WebApiUnavailable)?
         .text()
         .await
-        .map_err(|_| ())?;
+        .map_err(|_| WebApiUnavailable)?;
-    println!("id: {}", id);
+    info!("id: {}", id);
     Ok(id)
 }
 
-pub async fn get_web_version(key: &str) -> Result<u32, reqwest::Error> {
+pub async fn get_web_version(key: &str) -> Result<u32, NotificationData> {
     let id_url = format!("{API_URL}{key}/version");
     let client = reqwest::Client::new();
-    let version = client.get(&id_url).send().await?.text().await?;
+    let version = client.get(&id_url).send().await.map_err(|_| WebApiUnavailable)?.text().await.map_err(|_| WebApiUnavailable)?;
-    println!("version: {}", version);
+    info!("version: {}", version);
     Ok(version.parse::<u32>().unwrap_or_default())
 }
 
 pub async fn get_local_version() -> u32 {
-    let file = app_data_dir().join("data.meta");
+    let file = db_meta_path();
     if file.exists() {
         let mut data = String::new();
         File::open(file.clone())
@@ -124,7 +125,7 @@ pub async fn get_local_version() -> u32 {
 }
 
 pub async fn set_local_version(version: u32) {
-    let file_path = app_data_dir().join("data.meta");
+    let file_path = db_meta_path();
     let mut file = OpenOptions::new()
         .write(true)
         .create(true)

src/data_provider/words.rs

@@ -1,6 +1,6 @@
-use crate::lang::{WordData, WordGroup};
 use rusqlite::{Connection, params};
 use std::collections::HashMap;
+use crate::data::entities::{WordData, WordGroup};
 
 pub fn add_word(word: &mut WordData, connection: &Connection) {
     let index : u32 = connection

src/fs.rs

@@ -0,0 +1,45 @@
+use std::fs;
+use std::path::PathBuf;
+use crate::notification::NotificationData;
+use crate::notification::NotificationData::PermissionDenied;
+
+pub fn app_data_dir() -> PathBuf {
+    let mut dir = dirs::data_dir().unwrap();
+    dir.push("jap_learn");
+    if !dir.exists() {
+        fs::create_dir_all(dir.clone()).unwrap();
+    }
+
+    dir
+}
+
+pub fn db_path() -> PathBuf {
+     app_data_dir().join("data.db")
+}
+pub fn temp_db_path() -> PathBuf {
+     app_data_dir().join("data.db.tmp")
+}
+
+pub fn temp_import_path() -> PathBuf {
+    app_data_dir().join("import")
+}
+
+pub fn db_meta_path() -> PathBuf {
+    app_data_dir().join("data.meta")
+}
+
+pub fn history_dir() -> Result<PathBuf, NotificationData> {
+    let directory = app_data_dir().join("history");
+    if !directory.exists() {
+        fs::create_dir_all(directory.clone()).map_err(|_| PermissionDenied)?;
+    }
+    Ok(directory)
+}
+
+pub fn voice_dir() -> Result<PathBuf, NotificationData> {
+    let directory = app_data_dir().join("voice");
+    if !directory.exists() {
+        fs::create_dir_all(directory.clone()).map_err(|_| PermissionDenied)?;
+    }
+    Ok(directory)
+}

src/lang.rs

@@ -1,718 +0,0 @@
-use crate::data_provider::card_stats::load_stats_of_deck;
-use crate::data_provider::card_stats::update_stat_score;
-use crate::data_provider::history::{push_note, HistoryItem};
-use crate::AppState;
-use chrono::{DateTime, Utc};
-use parking_lot::Mutex;
-use rand::distr::weighted::WeightedIndex;
-use rand::distr::Distribution;
-use rand::prelude::SliceRandom;
-use rand::rng;
-use rand::rngs::ThreadRng;
-use rayon::iter::IndexedParallelIterator;
-use rayon::iter::IntoParallelRefIterator;
-use rayon::iter::ParallelIterator;
-use rhai::{Engine, Scope};
-use rusqlite::types::{FromSql, FromSqlError, FromSqlResult, ToSqlOutput, ValueRef};
-use rusqlite::ToSql;
-use std::cmp::PartialEq;
-use std::collections::HashMap;
-use std::fmt::{Display, Formatter};
-use std::num::ParseIntError;
-use std::str::FromStr;
-use std::sync::Arc;
-use std::time::Instant;
-
-const MAX_HISTORY_LEN: usize = 20;
-const MAX_HISTORY_LEN_PART: f32 = 0.33;
-const MAX_SCORE: u8 = 25;
-const FADE_PER_DAY: f32 = 0.95;
-#[derive(Clone, PartialEq, Eq, Debug, Hash, Copy, Ord, PartialOrd)]
-pub struct Id(u32);
-pub const INVALID_ID: Id = Id(0);
-impl FromStr for Id {
-    type Err = ParseIntError;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        Ok(Id(s.parse::<u32>()?))
-    }
-}
-
-impl From<u32> for Id {
-    fn from(value: u32) -> Self {
-        Id(value)
-    }
-}
-
-impl From<Id> for u32 {
-    fn from(value: Id) -> Self {
-        value.0
-    }
-}
-impl Display for Id {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", self.0)
-    }
-}
-
-impl FromSql for Id {
-    fn column_result(value: ValueRef<'_>) -> FromSqlResult<Self> {
-        match value {
-            ValueRef::Integer(i) => Ok(Id(i as u32)),
-            _ => Err(FromSqlError::InvalidType),
-        }
-    }
-}
-
-impl ToSql for Id {
-    fn to_sql(&self) -> rusqlite::Result<ToSqlOutput<'_>> {
-        Ok(ToSqlOutput::from(self.0 as i64))
-    }
-}
-
-impl From<Id> for String {
-    fn from(value: Id) -> Self {
-        value.0.to_string()
-    }
-}
-
-impl Id {
-    pub(crate) fn is_valid(self) -> bool {
-        self.0 != 0
-    }
-}
-
-#[derive(Clone, Debug)]
-pub struct KanaSet {
-    name: String,
-    pub(crate) chars_type: KanaType,
-    pub(crate) dictionary: Vec<Vec<(String, String)>>,
-    pub(crate) include_map: [bool; 10],
-}
-#[derive(Clone, Debug)]
-pub enum KanaType {
-    Hiragana,
-    Katakana,
-}
-impl KanaSet {
-    pub fn hiragana() -> Self {
-        Self {
-            name: "Хирагана".to_string(),
-            chars_type: KanaType::Hiragana,
-            dictionary: vec![
-                vec![
-                    (String::from("ぁ"), String::from("a")),
-                    (String::from("ぃ"), String::from("i")),
-                    (String::from("ぅ"), String::from("u")),
-                    (String::from("ぇ"), String::from("e")),
-                    (String::from("ぉ"), String::from("o")),
-                ],
-                vec![
-                    (String::from("さ"), String::from("sa")),
-                    (String::from("し"), String::from("shi")),
-                    (String::from("す"), String::from("su")),
-                    (String::from("せ"), String::from("se")),
-                    (String::from("そ"), String::from("so")),
-                ],
-                vec![
-                    (String::from("か"), String::from("ka")),
-                    (String::from("き"), String::from("ki")),
-                    (String::from("く"), String::from("ku")),
-                    (String::from("け"), String::from("ke")),
-                    (String::from("こ"), String::from("ko")),
-                ],
-                // Ряд «та» (たちつてと)
-                vec![
-                    (String::from("た"), String::from("ta")),
-                    (String::from("ち"), String::from("chi")),
-                    (String::from("つ"), String::from("tsu")),
-                    (String::from("て"), String::from("te")),
-                    (String::from("と"), String::from("to")),
-                ],
-                // Ряд «на» (なにぬねの)
-                vec![
-                    (String::from("な"), String::from("na")),
-                    (String::from("に"), String::from("ni")),
-                    (String::from("ぬ"), String::from("nu")),
-                    (String::from("ね"), String::from("ne")),
-                    (String::from("の"), String::from("no")),
-                ],
-                // Ряд «ха» (はひふへほ)
-                vec![
-                    (String::from("は"), String::from("ha")),
-                    (String::from("ひ"), String::from("hi")),
-                    (String::from("ふ"), String::from("fu")),
-                    (String::from("へ"), String::from("he")),
-                    (String::from("ほ"), String::from("ho")),
-                ],
-                // Ряд «ма» (まみむめも)
-                vec![
-                    (String::from("ま"), String::from("ma")),
-                    (String::from("み"), String::from("mi")),
-                    (String::from("む"), String::from("mu")),
-                    (String::from("め"), String::from("me")),
-                    (String::from("も"), String::from("mo")),
-                ],
-                // Ряд «я» (やゆよ) — только 3 символа
-                vec![
-                    (String::from("や"), String::from("ya")),
-                    (String::from("ゆ"), String::from("yu")),
-                    (String::from("よ"), String::from("yo")),
-                ],
-                // Ряд «ра» (らりるれろ)
-                vec![
-                    (String::from("ら"), String::from("ra")),
-                    (String::from("り"), String::from("ri")),
-                    (String::from("る"), String::from("ru")),
-                    (String::from("れ"), String::from("re")),
-                    (String::from("ろ"), String::from("ro")),
-                ],
-                vec![
-                    (String::from("わ"), String::from("wa")),
-                    (String::from("を"), String::from("wo")),
-                    (String::from("ん"), String::from("n")),
-                ],
-            ],
-            include_map: [true; 10],
-        }
-    }
-
-    pub fn katakana() -> Self {
-        Self {
-            name: "Катакана".to_string(),
-            chars_type: KanaType::Katakana,
-            dictionary: vec![
-                vec![
-                    (String::from("ァ"), String::from("a")),
-                    (String::from("ィ"), String::from("i")),
-                    (String::from("ゥ"), String::from("u")),
-                    (String::from("ェ"), String::from("e")),
-                    (String::from("ォ"), String::from("o")),
-                ],
-                vec![
-                    (String::from("サ"), String::from("sa")),
-                    (String::from("シ"), String::from("shi")),
-                    (String::from("ス"), String::from("su")),
-                    (String::from("セ"), String::from("se")),
-                    (String::from("ソ"), String::from("so")),
-                ],
-                vec![
-                    (String::from("カ"), String::from("ka")),
-                    (String::from("キ"), String::from("ki")),
-                    (String::from("ク"), String::from("ku")),
-                    (String::from("ケ"), String::from("ke")),
-                    (String::from("コ"), String::from("ko")),
-                ],
-                // Ряд «та» (タチツテト)
-                vec![
-                    (String::from("タ"), String::from("ta")),
-                    (String::from("チ"), String::from("chi")),
-                    (String::from("ツ"), String::from("tsu")),
-                    (String::from("テ"), String::from("te")),
-                    (String::from("ト"), String::from("to")),
-                ],
-                // Ряд «на» (ナニヌネノ)
-                vec![
-                    (String::from("ナ"), String::from("na")),
-                    (String::from("ニ"), String::from("ni")),
-                    (String::from("ヌ"), String::from("nu")),
-                    (String::from("ネ"), String::from("ne")),
-                    (String::from("ノ"), String::from("no")),
-                ],
-                // Ряд «ха» (ハヒフヘホ)
-                vec![
-                    (String::from("ハ"), String::from("ha")),
-                    (String::from("ヒ"), String::from("hi")),
-                    (String::from("フ"), String::from("fu")),
-                    (String::from("ヘ"), String::from("he")),
-                    (String::from("ホ"), String::from("ho")),
-                ],
-                // Ряд «ма» (マミムメモ)
-                vec![
-                    (String::from("マ"), String::from("ma")),
-                    (String::from("ミ"), String::from("mi")),
-                    (String::from("ム"), String::from("mu")),
-                    (String::from("メ"), String::from("me")),
-                    (String::from("モ"), String::from("mo")),
-                ],
-                // Ряд «я» (ヤユヨ) — только 3 символа
-                vec![
-                    (String::from("ヤ"), String::from("ya")),
-                    (String::from("ユ"), String::from("yu")),
-                    (String::from("ヨ"), String::from("yo")),
-                ],
-                // Ряд «ра» (ラリルレロ)
-                vec![
-                    (String::from("ラ"), String::from("ra")),
-                    (String::from("リ"), String::from("ri")),
-                    (String::from("ル"), String::from("ru")),
-                    (String::from("レ"), String::from("re")),
-                    (String::from("ロ"), String::from("ro")),
-                ],
-                vec![
-                    (String::from("ワ"), String::from("wa")),
-                    (String::from("ヲ"), String::from("wo")),
-                    (String::from("ン"), String::from("n")),
-                ],
-            ],
-            include_map: [true; 10],
-        }
-    }
-
-    pub fn list(&self) -> Vec<(String, String)> {
-        let mut current_set: Vec<(String, String)> = Vec::new();
-
-        for i in 0..10 {
-            if self.include_map[i] {
-                self.dictionary[i].iter().for_each(|v| {
-                    current_set.push(v.clone());
-                });
-            }
-        }
-
-        current_set
-    }
-}
-impl Default for KanaSet {
-    fn default() -> Self {
-        KanaSet::hiragana()
-    }
-}
-impl PartialEq<Self> for KanaSet {
-    fn eq(&self, other: &Self) -> bool {
-        self.name == other.name
-    }
-}
-#[derive(Clone, Debug)]
-pub struct WordData {
-    pub id: Id,
-    pub key: String,
-    pub value: String,
-    pub tags: String,
-    pub additional: HashMap<String, String>,
-    pub group_id: Id,
-}
-impl WordData {
-    pub fn new() -> Self {
-        Self {
-            id: INVALID_ID,
-            key: String::new(),
-            value: String::new(),
-            tags: String::new(),
-            additional: Default::default(),
-            group_id: 1.into(),
-        }
-    }
-}
-#[derive(Clone)]
-pub struct WordGroup {
-    pub id: Id,
-    pub name: String,
-}
-#[derive(Clone, PartialEq)]
-pub struct CardStatistics {
-    pub id: Id,
-    pub word_id: Id,
-    pub set_id: Id,
-    pub last_open: DateTime<Utc>,
-    pub score: u8,
-}
-impl CardStatistics {
-    pub fn update(&mut self, status: WordOpenMode) {
-        match status {
-            WordOpenMode::Easy => {
-                self.score = (self.calculated_score() + 5.0).round() as u8;
-            }
-            WordOpenMode::Ok => self.score = (self.calculated_score() + 2.0).round() as u8,
-            WordOpenMode::Hard => {
-                self.score = (self.calculated_score() * 0.75).round() as u8;
-            }
-            WordOpenMode::None => {
-                self.score = (self.calculated_score() * 0.4) as u8;
-            }
-        }
-
-        self.score = self.score.clamp(1, MAX_SCORE);
-        self.last_open = Utc::now();
-    }
-
-    pub fn calculated_score(&self) -> f32 {
-        let time = Utc::now() - self.last_open;
-        let days = time.num_days();
-        let multiplier = FADE_PER_DAY.powi(days as i32);
-        (self.score as f32 * multiplier).max(1.0)
-    }
-}
-#[derive(Clone, Copy)]
-pub enum WordOpenMode {
-    Easy,
-    Ok,
-    Hard,
-    None,
-}
-#[derive(Clone)]
-pub struct DeckData {
-    words: Vec<WordData>,
-    set: Vec<CardStatistics>,
-    current_word_index: Option<usize>,
-    state: Arc<Mutex<AppState>>,
-    order_module: OrderModule,
-    settings: DeckSettings,
-}
-impl DeckData {
-    pub fn new(settings: &DeckSettings, state: Arc<Mutex<AppState>>) -> Self {
-        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)
-                    .unwrap()
-            })
-            .map(|index| &state_locked.dictionary[index])
-            .cloned()
-            .collect();
-
-        Self {
-            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.clone() {
-            OrderModule::SemiRandomSRS(mut module) => {
-                if !module.initialized {
-                    module.init(self)
-                }
-                let index = module.next(self);
-                self.order_module = OrderModule::SemiRandomSRS(module);
-                index
-            }
-            OrderModule::RandomSRS(mut module) => {
-                if !module.initialized {
-                    module.init(self)
-                }
-                let index = module.next(self);
-                self.order_module = OrderModule::RandomSRS(module);
-                index
-            }
-            OrderModule::WorstWordsSRS(mut module) => {
-                if !module.initialized {
-                    module.init(self)
-                }
-                let index = module.next(self);
-                self.order_module = OrderModule::WorstWordsSRS(module);
-                index
-            }
-        };
-
-        self.current_word_index = Some(index);
-        (self.words[index].clone(), self.set[index].clone())
-    }
-    pub fn open(&mut self, status: WordOpenMode) {
-        if self.current_word_index.is_none() {
-            return;
-        }
-        let index = self.current_word_index.unwrap();
-
-        let word = &mut self.set[index];
-        let old_score = word.score;
-        word.update(status);
-        let new_score = word.score;
-
-        match self.order_module.clone() {
-            OrderModule::SemiRandomSRS(mut module) => {
-                module.open(status, index, word.clone());
-                self.order_module = OrderModule::SemiRandomSRS(module);
-            }
-            OrderModule::RandomSRS(mut module) => {
-                module.open(status, index, word.clone());
-                self.order_module = OrderModule::RandomSRS(module);
-            }
-            OrderModule::WorstWordsSRS(mut module) => {
-                module.open(status, index, word.clone());
-                self.order_module = OrderModule::WorstWordsSRS(module);
-            }
-        }
-        update_stat_score(word, &self.state.lock().connection);
-        push_note(
-            self.settings.id,
-            HistoryItem {
-                timestamp: Utc::now(),
-                word_id: word.word_id,
-                mode: status,
-                before: old_score,
-                after: new_score,
-            },
-        )
-    }
-    pub fn len(&self) -> usize {
-        self.set.len()
-    }
-}
-#[derive(Clone, PartialEq, Copy, Eq)]
-pub enum OrderMode {
-    Default,
-    TrainWorstFirst,
-    FullRandom,
-}
-#[derive(Clone, Copy, Eq, PartialEq, Default)]
-pub enum AppendMode {
-    Full,
-    #[default]
-    Manual,
-}
-#[derive(Clone)]
-enum OrderModule {
-    SemiRandomSRS(SemiRandomSRSModule),
-    RandomSRS(RandomSRSModule),
-    WorstWordsSRS(WorstWordsSRSModule),
-}
-trait SRSModule {
-    fn next(&mut self, set: &mut DeckData) -> usize;
-    fn open(&mut self, status: WordOpenMode, index: usize, updated_word: CardStatistics);
-    fn init(&mut self, set: &mut DeckData);
-}
-#[derive(Clone)]
-struct RandomSRSModule {
-    basket: Vec<usize>,
-    initialized: bool,
-}
-impl RandomSRSModule {
-    fn new() -> RandomSRSModule {
-        Self {
-            basket: vec![],
-            initialized: false,
-        }
-    }
-}
-impl SRSModule for RandomSRSModule {
-    fn next(&mut self, set: &mut DeckData) -> usize {
-        match self.basket.pop() {
-            Some(index) => index,
-            None => {
-                self.basket = (0..set.words.len()).collect::<Vec<usize>>();
-                self.basket.shuffle(&mut rand::rng());
-                self.basket.pop().expect("empty basket")
-            }
-        }
-    }
-
-    fn open(&mut self, _: WordOpenMode, _: usize, _: CardStatistics) {}
-
-    fn init(&mut self, set: &mut DeckData) {
-        self.initialized = true;
-        self.basket = (0..set.set.len()).collect::<Vec<usize>>();
-        self.basket.shuffle(&mut rand::rng())
-    }
-}
-#[derive(Clone)]
-struct SemiRandomSRSModule {
-    history: Vec<usize>,
-    last_weights: WeightedIndex<f32>,
-    generator: ThreadRng,
-    initialized: bool,
-}
-impl SemiRandomSRSModule {
-    fn new() -> SemiRandomSRSModule {
-        SemiRandomSRSModule {
-            history: vec![],
-            last_weights: WeightedIndex::new([1.0]).unwrap(),
-            generator: rng(),
-            initialized: false,
-        }
-    }
-}
-impl SRSModule for SemiRandomSRSModule {
-    fn next(&mut self, set: &mut DeckData) -> usize {
-        let index = self.last_weights.sample(&mut self.generator);
-
-        if self.history.contains(&index) && self.history.len() != 1 {
-            return self.next(set);
-        }
-
-        if self.history.len() == self.history_len(set) {
-            self.history.remove(0);
-        }
-        self.history.push(index);
-
-        index
-    }
-    fn open(&mut self, _: WordOpenMode, index: usize, word: CardStatistics) {
-        let new_weight = (100.0 / word.calculated_score()).powf(2.0);
-        self.last_weights
-            .update_weights(&[(index, &new_weight)])
-            .expect("update weights error");
-    }
-    fn init(&mut self, set: &mut DeckData) {
-        self.initialized = true;
-        let weights = set
-            .set
-            .iter()
-            .map(|s| (100.0 / s.calculated_score()).powf(2.0) * 2.0)
-            .collect::<Vec<f32>>();
-        self.last_weights = WeightedIndex::new(weights).unwrap();
-    }
-}
-impl SemiRandomSRSModule {
-    fn history_len(&self, set: &DeckData) -> usize {
-        ((set.len() as f32 * MAX_HISTORY_LEN_PART) as usize).clamp(1, MAX_HISTORY_LEN)
-    }
-}
-#[derive(Clone)]
-struct WorstWordsSRSModule {
-    initialized: bool,
-    pool_size: usize,
-    rounds_remaining: u8,
-    pool: Vec<usize>,
-    queue: Vec<usize>,
-    rounds_count: u8,
-}
-impl SRSModule for WorstWordsSRSModule {
-    fn next(&mut self, set: &mut DeckData) -> usize {
-        if self.rounds_remaining == 0 {
-            self.fill_pool(set);
-            self.rounds_remaining = self.rounds_count;
-        }
-
-        match self.queue.pop() {
-            Some(index) => index,
-            None => {
-                self.queue.append(&mut self.pool.clone());
-                self.rounds_remaining -= 1;
-                self.queue.pop().expect("empty queue")
-            }
-        }
-    }
-
-    fn open(&mut self, _: WordOpenMode, _: usize, _: CardStatistics) {}
-
-    fn init(&mut self, _: &mut DeckData) {
-        self.initialized = true;
-    }
-}
-impl WorstWordsSRSModule {
-    fn new() -> WorstWordsSRSModule {
-        WorstWordsSRSModule {
-            initialized: false,
-            pool_size: 15,
-            rounds_count: 2,
-            rounds_remaining: 0,
-            pool: vec![],
-            queue: vec![],
-        }
-    }
-    fn fill_pool(&mut self, set: &DeckData) {
-        let mut sorted = set
-            .set
-            .clone()
-            .into_iter()
-            .zip(0..set.set.len())
-            .collect::<Vec<_>>();
-        sorted.sort_by_key(|c| c.0.score);
-        let mut worst = sorted[0..self.pool_size]
-            .iter()
-            .map(|(_, index)| *index)
-            .collect::<Vec<usize>>();
-        worst.shuffle(&mut rand::rng());
-        self.pool = worst;
-    }
-}
-#[derive(Clone)]
-pub struct DeckSettings {
-    pub id: Id,
-    pub name: String,
-    pub forward: String,
-    pub backward: String,
-    pub filter: String,
-    pub count: Option<usize>,
-    pub worst_words_list: Option<Vec<WordData>>,
-    pub open_mode: OrderMode,
-}
-impl DeckSettings {
-    pub(crate) fn with_name(name: String) -> DeckSettings {
-        DeckSettings {
-            id: 0.into(),
-            name,
-            forward: "".to_string(),
-            backward: "".to_string(),
-            filter: "true".to_string(),
-            count: None,
-            worst_words_list: None,
-            open_mode: OrderMode::Default,
-        }
-    }
-    pub fn check_filter(&self) -> bool {
-        let time = Instant::now();
-        let engine = Engine::new();
-        let ast = engine.compile(&self.filter);
-        println!("Compile time is {:?}", time.elapsed());
-        ast.is_ok()
-    }
-    pub fn get_word_list(&self, state: &AppState) -> Vec<usize> {
-        let time = Instant::now();
-        let mut list = vec![];
-        let engine = Engine::new();
-
-        let ast = engine.compile(&self.filter);
-        if let Ok(ast) = ast {
-            let groups = &state.word_groups;
-
-            list = state
-                .dictionary
-                .par_iter()
-                .enumerate()
-                .filter(|(_, 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();
-                    scope
-                        .push_constant("id", word.id.0)
-                        .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",
-                            groups
-                                .iter()
-                                .find(|g| g.id == word.group_id)
-                                .cloned()
-                                .unwrap()
-                                .name,
-                        );
-
-                    let result = engine.eval_ast_with_scope::<bool>(&mut scope, &ast);
-                    result.is_ok() && result.unwrap()
-                })
-                .map(|(index, _)| index)
-                .collect();
-
-            println!("Collecting available words is {:?}", time.elapsed());
-
-            list
-        } else {
-            list
-        }
-    }
-    pub fn require_speech(&self) -> bool {
-        self.forward == "speech" || self.backward == "speech"
-    }
-}

src/main.rs

@@ -1,135 +1,22 @@
 #![windows_subsystem = "windows"]
 mod data_provider;
-mod dictionary;
+pub mod notification;
-mod dictionary_quiz;
+pub mod app;
-mod history;
+mod styling;
-pub mod import;
+mod pages;
-mod lang;
+mod navigation;
-pub mod navigation;
+mod fs;
-mod quiz;
+mod core;
-mod randomizer;
+mod data;
-mod repetition;
-mod repetition_settings;
-mod repetitions;
-mod selector;
-pub mod styling;
-mod sync;
-mod word;
-mod writing;
 
-use crate::RootMessage::Keyboard;
+use crate::app::start;
-use crate::data_provider::card_sets::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};
-use crate::lang::{DeckSettings, Id, WordData, WordGroup};
-use crate::navigation::{AppSettings, RootMessage, ScreenState};
-use crate::quiz::*;
-use chrono::NaiveDate;
-use hashbrown::HashMap;
-use iced::{Font, window};
-use iced::{Subscription, Theme, keyboard};
-use iced_core::Size;
-use iced_core::window::Position;
-#[cfg(target_os = "linux")]
-use iced_core::window::settings::PlatformSpecific;
 use mimalloc::MiMalloc;
-use rusqlite::Connection;
+
 #[global_allocator]
 static GLOBAL: MiMalloc = MiMalloc;
 
-const USER_FONT: Font = Font::with_name("Noto Sans JP");
 
 fn main() -> iced::Result {
-    println!("Welcome to JapLearn");
+    env_logger::init();
-    iced::application(ScreenState::boot, ScreenState::update, ScreenState::view)
+    start()
-        .window(window_settings())
-        .subscription(subscription)
-        .title("JapLearn")
-        .settings(iced::Settings {
-            default_text_size: iced::Pixels(18.0),
-            ..iced::Settings::default()
-        })
-        .font(include_bytes!("../noto.ttf"))
-        .default_font(USER_FONT)
-        .theme(Theme::GruvboxDark)
-        .run()
-}
-
-#[allow(unused_mut)]
-fn window_settings() -> window::Settings {
-    let mut settings = window::Settings {
-        position: Position::Centered,
-        min_size: Some(Size::new(700.0_f32, 700.0_f32)),
-        ..Default::default()
-    };
-
-    #[cfg(target_os = "linux")]
-    {
-        settings.platform_specific = PlatformSpecific {
-            application_id: "JapLearn".to_string(),
-            override_redirect: false,
-        };
-    }
-
-    settings
-}
-
-fn subscription(_state: &ScreenState) -> Subscription<RootMessage> {
-    keyboard::listen().map(Keyboard)
-}
-
-pub struct AppState {
-    pub dictionary: Vec<WordData>,
-    pub decks: Vec<DeckSettings>,
-    pub word_groups: Vec<WordGroup>,
-    pub connection: Connection,
-    pub sync_data: AppSettings,
-    pub activity: HashMap<Id, Vec<(NaiveDate, u32)>>,
-}
-
-impl Default for AppState {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl AppState {
-    pub fn new() -> Self {
-        Self {
-            dictionary: vec![],
-            decks: vec![],
-            word_groups: vec![],
-            connection: default_connection(),
-            sync_data: AppSettings {
-                key: None,
-                auto_web_fetch: false,
-            },
-            activity: Default::default(),
-        }
-    }
-}
-
-fn fill_state(state: &mut AppState) {
-    let list = load_words(&state.connection);
-    let sets = load_sets(&state.connection);
-    let groups = load_word_groups(&state.connection);
-    let setting = load_settings(&state.connection);
-
-    state.dictionary = list;
-    state.decks = sets;
-    state.word_groups = groups;
-    state.sync_data = setting
-}
-
-fn load_settings(connection: &Connection) -> AppSettings {
-    let key = get_setting("SYNC_KEY".to_string(), connection);
-    let fetch = get_setting("AUTO_WEB_FETCH".to_string(), connection)
-        .unwrap_or("false".to_string())
-        .parse::<bool>()
-        .unwrap();
-    AppSettings {
-        key,
-        auto_web_fetch: fetch,
-    }
 }

src/navigation.rs

@@ -1,36 +1,46 @@
-use crate::data_provider::history::{get_history_of_set, history_dir};
+use crate::app::{fill_state, AppState};
+use crate::data_provider::history::get_history_of_set;
 use crate::data_provider::sqlite::{create_db, default_connection};
-use crate::data_provider::web_api::{get_local_version, get_web_version, load_data, set_local_version};
+use crate::data_provider::web_api::{
-use crate::dictionary::{DictionaryMessage, DictionaryState, app_data_dir};
+    get_local_version, get_web_version, load_data, set_local_version,
-use crate::dictionary_quiz::{DictionaryQuizMessage, DictionaryQuizState};
+};
-use crate::history::{HistoryMessage, HistoryState};
+use crate::fs::*;
-use crate::import::{ImportMessage, ImportState};
-use crate::lang::Id;
 use crate::message_navigation;
 use crate::navigation::Page::*;
-use crate::navigation::RootMessage::{DataLoaded, Keyboard, UpdateData};
+use crate::navigation::RootMessage::{
-use crate::quiz::{QuizMessage, QuizState};
+    DataLoaded, Keyboard, Notification, PushNotification, UpdateData,
-use crate::randomizer::{RandomizerMessage, RandomizerState};
+};
-use crate::repetition::{RepetitionMessage, RepetitionState};
+use crate::notification::{
-use crate::repetition_settings::{RepetitionSettingsMessage, RepetitionSettingsState};
+    NotificationData, NotificationManager, NotificationMessage, NotificationRequest,
-use crate::repetitions::{RepetitionsMessage, RepetitionsState};
+};
-use crate::selector::{SelectorMessage, SelectorState};
+use crate::pages::dictionary::{DictionaryMessage, DictionaryState};
+use crate::pages::dictionary_quiz::{DictionaryQuizMessage, DictionaryQuizState};
+use crate::pages::history::{HistoryMessage, HistoryState};
+use crate::pages::import::{ImportMessage, ImportState};
+use crate::pages::quiz::{QuizMessage, QuizState};
+use crate::pages::randomizer::{RandomizerMessage, RandomizerState};
+use crate::pages::repetition::{RepetitionMessage, RepetitionState};
+use crate::pages::repetition_settings::{RepetitionSettingsMessage, RepetitionSettingsState};
+use crate::pages::repetitions::{RepetitionsMessage, RepetitionsState};
+use crate::pages::selector::{SelectorMessage, SelectorState};
+use crate::pages::sync::{SyncMessage, SyncState};
+use crate::pages::word::{WordMessage, WordState};
+use crate::pages::writing::{WritingMessage, WritingState};
 use crate::state_navigate_handle;
 use crate::state_update;
-use crate::sync::{SyncMessage, SyncState};
 use crate::view_navigation;
-use crate::word::{WordMessage, WordState};
-use crate::writing::{WritingMessage, WritingState};
-use crate::{AppState, fill_state};
 use chrono::NaiveDate;
 use hashbrown::HashMap;
 use iced::keyboard::Event;
+use iced::widget::stack;
 use iced::{Element, Task};
+use iced_core::Length::Fill;
+use log::info;
 use parking_lot::Mutex;
-use reqwest::Error;
 use rusqlite::Connection;
 use std::sync::Arc;
 use std::time::Instant;
+use crate::data::Id;
 
 impl Default for ScreenState {
     fn default() -> Self {
@@ -40,6 +50,7 @@ impl Default for ScreenState {
         ScreenState {
             stack: vec![Selector(SelectorState::new(state.clone()))],
             app_state: state.clone(),
+            notification_manager: NotificationManager::new(),
         }
     }
 }
@@ -61,6 +72,8 @@ pub enum RootMessage {
     Import(ImportMessage),
     Keyboard(Event),
     DataLoaded(HashMap<Id, Vec<(NaiveDate, u32)>>),
+    PushNotification(NotificationRequest),
+    Notification(NotificationMessage),
     None,
     UpdateData,
 }
@@ -85,13 +98,14 @@ pub enum Page {
 pub struct ScreenState {
     stack: Vec<Page>,
     app_state: Arc<Mutex<AppState>>,
+    notification_manager: NotificationManager,
 }
 
 impl ScreenState {
     pub fn boot() -> (ScreenState, Task<RootMessage>) {
-        println!("Booting");
+        info!("Booting");
         create_db();
-        println!("Db created");
+        info!("Db created");
         let state = ScreenState::default();
         let reading_additional_task = Task::perform(Self::load_additional_data(), |data| data);
 
@@ -101,14 +115,15 @@ impl ScreenState {
             let key = state_guard.sync_data.key.clone().unwrap();
             final_task = Task::batch([
                 reading_additional_task,
-                Task::perform(Self::load_web_backup(key), |result| {
+                Task::perform(Self::load_web_backup(key), |result| match result {
-                    if let Ok(update) = result
+                    Ok(update) => {
-                        && update
+                        if update {
-                    {
+                            UpdateData
-                        UpdateData
+                        } else {
-                    } else {
+                            RootMessage::None
-                        RootMessage::None
+                        }
                     }
+                    Err(err) => PushNotification(NotificationRequest::Warning(err)),
                 }),
             ]);
         } else {
@@ -116,42 +131,49 @@ impl ScreenState {
         }
 
         drop(state_guard);
-        println!("Boot finished");
+        info!("Boot finished");
         (state, final_task)
     }
 
     async fn load_additional_data() -> RootMessage {
         let directory = history_dir();
-        let mut map = HashMap::new();
+        if let Ok(directory) = directory {
-        for file in directory.read_dir().unwrap().flatten() {
+            let mut map = HashMap::new();
-            let mut vec = vec![];
+            for file in directory.read_dir().unwrap().flatten() {
-            let history_file_name = match file.file_name().into_string() {
+                let mut vec = vec![];
-                Err(_) => continue,
+                let history_file_name = match file.file_name().into_string() {
-                Ok(v) => v,
+                    Err(_) => continue,
-            };
+                    Ok(v) => v,
+                };
 
-            let id = history_file_name[4..history_file_name.len() - 12]
+                let id = history_file_name[4..history_file_name.len() - 12]
-                .parse::<Id>()
+                    .parse::<Id>()
-                .unwrap();
+                    .unwrap();
 
-            let history = get_history_of_set(id);
+                let history = get_history_of_set(id);
-            let by_date = history.chunk_by(|x, x1| {
+                if let Ok(history) = history {
-                x.timestamp.naive_local().date() == x1.timestamp.naive_local().date()
+                    let by_date = history.chunk_by(|x, x1| {
-            });
+                        x.timestamp.naive_local().date() == x1.timestamp.naive_local().date()
-            for group in by_date {
+                    });
-                vec.push((group[0].timestamp.naive_local().date(), group.len() as u32));
+                    for group in by_date {
+                        vec.push((group[0].timestamp.naive_local().date(), group.len() as u32));
+                    }
+                    map.insert(id, vec);
+                } else {
+                    return PushNotification(NotificationRequest::Warning(history.err().unwrap()));
+                }
             }
-            map.insert(id, vec);
+            return DataLoaded(map);
         }
-        DataLoaded(map)
+        PushNotification(NotificationRequest::Warning(directory.err().unwrap()))
     }
 
-    async fn load_web_backup(string: String) -> Result<bool, Error> {
+    async fn load_web_backup(string: String) -> Result<bool, NotificationData> {
         let local = get_local_version().await;
         let web = get_web_version(string.as_str()).await?;
-        println!("{} {}", local, web);
+        info!("{} {}", local, web);
         if web > local {
-            println!("Web version is newer than local version");
+            info!("Web version is newer than local version");
             load_data(string, true).await?;
             set_local_version(web).await;
         } else {
@@ -161,7 +183,7 @@ impl ScreenState {
     }
 
     pub fn update(&mut self, message: RootMessage) -> Task<RootMessage> {
-        println!("Updating");
+        info!("Updating");
         let time = Instant::now();
         if let Keyboard(e) = message {
             return self.handle_keyboard(e);
@@ -173,20 +195,28 @@ impl ScreenState {
         }
 
         if let UpdateData = message {
-            println!("Loading data");
+            info!("Loading data");
             let mut state = self.app_state.lock();
             if cfg!(windows) {
                 state.connection = Connection::open_in_memory().unwrap();
             }
-            let path = app_data_dir();
+            let db_file = db_path();
-            let db_file = path.join("data.db");
+            let temp_db_file = temp_db_path();
-            let temp_db_file = path.join("data.db.tmp");
             std::fs::rename(temp_db_file, &db_file).unwrap();
 
             state.connection = default_connection();
             fill_state(&mut state);
             return Task::none();
         }
+
+        if let Notification(message) = message {
+            return self.notification_manager.update(message);
+        }
+
+        if let PushNotification(notification) = &message {
+            return self.notification_manager.push(notification.clone());
+        }
+
         let task: (Task<RootMessage>, bool) = self.navigate_or_update(message);
 
         if task.1 {
@@ -207,7 +237,7 @@ impl ScreenState {
                 Import
             );
         }
-        println!("Update took {:?}", time.elapsed());
+        info!("Update took {:?}", time.elapsed());
 
         task.0
     }
@@ -233,7 +263,7 @@ impl ScreenState {
     }
 
     pub fn view(&self) -> Element<'_, RootMessage> {
-        println!("View update");
+        info!("View update");
         let time = Instant::now();
         let view = view_navigation!(
             self.stack,
@@ -252,8 +282,10 @@ impl ScreenState {
             Import
         );
 
-        println!("View took {:?}", time.elapsed());
+        let notifications = self.notification_manager.draw().map(Notification);
-        view
+
+        info!("View took {:?}", time.elapsed());
+        stack![view, notifications].width(Fill).height(Fill).into()
     }
 
     fn handle_keyboard(&mut self, message: Event) -> Task<RootMessage> {
@@ -281,7 +313,6 @@ macro_rules! view_navigation {
         }
     }
 }
-
 #[macro_export]
 macro_rules! state_update {
     ($message:expr, $stack:expr, $($e:ident), *) => {
@@ -300,7 +331,6 @@ macro_rules! state_update {
         }
     }
 }
-
 #[macro_export]
 macro_rules! message_navigation {
     ($msg:expr, $stack:expr, $state:expr) => {
@@ -321,7 +351,6 @@ macro_rules! message_navigation {
         }
     };
 }
-
 #[macro_export]
 macro_rules! state_navigate_handle {
     ($stack:expr, $($e:ident), *) => {
@@ -335,14 +364,12 @@ macro_rules! state_navigate_handle {
         }
     }
 }
-
 pub trait NavigatedPage<T> {
     fn navigate(&mut self, message: &T) -> Option<Page>;
     fn navigated(&mut self);
     fn update(&mut self, message: T) -> Task<RootMessage>;
     fn view(&self) -> Element<'_, T>;
 }
-
 pub trait KeyPressedPage {
     fn press(&mut self, message: &Event) -> Task<RootMessage>;
 }

src/notification.rs

@@ -0,0 +1,182 @@
+use crate::navigation::RootMessage;
+use crate::styling::{BUTTON_RADIUS, HALF_SPACING};
+use chrono::Utc;
+use iced::widget::container::Style;
+use iced::widget::{Column, container, row, scrollable, text};
+use iced::{Element, Task};
+use iced_core::Alignment::Center;
+use iced_core::Background::Color;
+use iced_core::Border;
+use iced_core::Length::Fill;
+use iced_core::alignment::Horizontal::Right;
+use iced_core::alignment::Vertical;
+
+pub struct NotificationManager {
+    list: Vec<(u32, NotificationRequest, u32)>,
+    notification_lifetime: u32,
+    next_id: u32,
+}
+
+#[derive(Clone)]
+pub enum NotificationMessage {
+    Remove(u32),
+}
+
+impl Default for NotificationManager {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl NotificationManager {
+    pub fn new() -> Self {
+        Self {
+            list: Vec::new(),
+            notification_lifetime: 10,
+            next_id: 1,
+        }
+    }
+
+    pub fn draw(&self) -> Element<'_, NotificationMessage> {
+        let mut column = Column::new().spacing(HALF_SPACING);
+
+        for (id, notif, time) in &self.list {
+            column = column.push(Self::draw_notif(id, notif, time));
+        }
+
+        container(scrollable(column))
+            .width(Fill)
+            .height(Fill)
+            .align_x(Right)
+            .align_y(Vertical::Top)
+            .padding(HALF_SPACING)
+            .into()
+    }
+
+    pub fn push(&mut self, notification: NotificationRequest) -> Task<RootMessage> {
+        let id = self.next_id;
+        self.list.push((
+            id,
+            notification,
+            Utc::now().timestamp() as u32 + self.notification_lifetime,
+        ));
+        self.next_id += 1;
+        let message = NotificationMessage::Remove(id);
+        let time = self.notification_lifetime;
+        Task::perform(
+            async move {
+                tokio::time::sleep(core::time::Duration::from_secs(time as u64)).await;
+            },
+            |_| RootMessage::Notification(message),
+        )
+    }
+
+    pub fn update(&mut self, message: NotificationMessage) -> Task<RootMessage> {
+        match message {
+            NotificationMessage::Remove(id) => {
+                if let Some(index) = self.list.iter().position(|item| item.0 == id) {
+                    self.list.remove(index);
+                }
+            }
+        }
+        Task::none()
+    }
+
+    fn draw_notif<'a>(
+        id: &u32,
+        notif: &NotificationRequest,
+        _time: &u32,
+    ) -> Element<'a, NotificationMessage> {
+        let color_id;
+        let content = match notif {
+            NotificationRequest::Info(data) => {
+                color_id = 1;
+                Self::draw_data(data)
+            }
+            NotificationRequest::Warning(data) => {
+                color_id = 2;
+                Self::draw_data(data)
+            }
+            NotificationRequest::Error(data) => {
+                color_id = 3;
+                Self::draw_data(data)
+            }
+        };
+
+        let container = container(
+            row![
+                content,
+                iced::widget::button("✕")
+                    .on_press(NotificationMessage::Remove(*id))
+                    .style(iced::widget::button::text)
+            ].align_y(Center).width(300)
+            .padding(HALF_SPACING),
+        );
+        container
+            .style(move |theme| {
+                let color = match color_id {
+                    1 => theme.palette().success,
+                    2 => theme.palette().warning,
+                    3 => theme.palette().danger,
+                    _ => theme.palette().warning,
+                };
+                Style {
+                    text_color: None,
+                    background: Some(Color(color.scale_alpha(0.3))),
+                    border: Border::default()
+                        .width(1)
+                        .color(color)
+                        .rounded(BUTTON_RADIUS),
+                    shadow: Default::default(),
+                    snap: false,
+                }
+            })
+            .into()
+    }
+
+    fn draw_data<'a>(data: &NotificationData) -> Element<'a, NotificationMessage> {
+        match data {
+            NotificationData::DataLoaded => {
+                text!("Данные успешно скачаны")
+            }
+            NotificationData::ImportError => {
+                text!("Ошибка при импорте данных из Anki")
+            }
+            NotificationData::IncorrectAnkiFile => {
+                text!("Неподдерживаемый формат файла .apkg")
+            }
+            NotificationData::OpenFileError => {
+                text!("Ошибка открытия файла пакета")
+            }
+            NotificationData::VoiceVoxUnavailable => {
+                text!("Не получается подключиться к VoiceVox")
+            }
+            NotificationData::PermissionDenied => {
+                text!("У приложение недостаточно прав")
+            }
+            NotificationData::WebApiUnavailable => {
+                text!("Не получается подключиться к Api")
+            }
+        }
+        .width(Fill)
+        .into()
+    }
+}
+
+#[derive(Clone)]
+pub enum NotificationRequest {
+    Info(NotificationData),
+    Warning(NotificationData),
+    Error(NotificationData),
+}
+
+#[derive(Clone)]
+pub enum NotificationData {
+    PermissionDenied,
+    DataLoaded,
+    ImportError,
+    IncorrectAnkiFile,
+    OpenFileError,
+    VoiceVoxUnavailable,
+    WebApiUnavailable,
+}

src/pages.rs

@@ -0,0 +1,13 @@
+pub mod dictionary;
+pub mod dictionary_quiz;
+pub mod history;
+pub mod import;
+pub mod quiz;
+pub mod randomizer;
+pub mod repetition;
+pub mod repetition_settings;
+pub mod repetitions;
+pub mod selector;
+pub mod sync;
+pub mod word;
+pub mod writing;

src/pages/dictionary.rs

@@ -1,13 +1,12 @@
+use crate::data::Id;
 use crate::data_provider::words::{delete_group, delete_word, update_group, update_word};
-use crate::dictionary::DictionaryMessage::*;
+use crate::pages::dictionary::DictionaryMessage::*;
-use crate::dictionary_quiz::DictionaryQuizState;
+use crate::pages::dictionary_quiz::DictionaryQuizState;
-use crate::import::ImportState;
+use crate::pages::import::ImportState;
-use crate::lang::{WordData, WordGroup};
 use crate::navigation::Page::{Import, Word};
-use crate::navigation::{NavigatedPage, Page};
+use crate::navigation::{NavigatedPage, Page, RootMessage};
 use crate::styling::*;
-use crate::word::WordState;
+use crate::pages::word::WordState;
-use crate::{AppState, RootMessage};
 use chrono::{DateTime, TimeDelta, Utc};
 use hashbrown::{HashMap, HashSet};
 use iced::alignment::Vertical::Center;
@@ -20,11 +19,12 @@ use iced::{Border, Color, Shadow, Task};
 use iced_core::Length::Fill;
 use parking_lot::Mutex;
 use rand::random_range;
-use std::fs;
 use std::ops::Add;
-use std::path::PathBuf;
 use std::sync::Arc;
 use std::time::{Duration, Instant};
+use log::info;
+use crate::app::AppState;
+use crate::data::entities::{WordData, WordGroup};
 
 #[derive(Clone)]
 pub struct DictionaryState {
@@ -438,8 +438,8 @@ impl DictionaryState {
             col = col.push(lazy_line);
         }
 
-        println!("Drawing {index} lines");
+        info!("Drawing {index} lines");
-        println!("Words rendering time: {:?}", time.elapsed());
+        info!("Words rendering time: {:?}", time.elapsed());
         scrollable(col).height(Fill).into()
     }
 
@@ -528,7 +528,7 @@ impl DictionaryState {
         });
     }
 
-    fn update_words_include(&mut self, group_id: crate::lang::Id) {
+    fn update_words_include(&mut self, group_id: Id) {
         let include_tags = self
             .tag_map
             .iter()
@@ -554,7 +554,7 @@ impl DictionaryState {
             })
             .collect();
 
-        println!("Time {}", time.elapsed().as_micros());
+        info!("Time {}", time.elapsed().as_micros());
     }
 
     fn groups_panel(&self) -> iced::Element<'_, DictionaryMessage> {
@@ -618,22 +618,12 @@ pub fn split_with_coma(ts: &str) -> Vec<String> {
         .collect::<Vec<String>>()
 }
 
-pub fn app_data_dir() -> PathBuf {
-    let mut dir = dirs::data_dir().unwrap();
-    dir.push("jap_learn");
-    if !dir.exists() {
-        fs::create_dir_all(dir.clone()).unwrap();
-    }
-
-    dir
-}
-
 #[derive(Hash, PartialEq, Eq)]
 struct WordLineState {
     is_included: bool,
     key: String,
     value: String,
     tags: String,
-    id: crate::lang::Id,
+    id: Id,
     index: usize,
 }

src/pages/dictionary_quiz.rs

@@ -1,10 +1,9 @@
-use crate::RootMessage;
+use crate::navigation::RootMessage;
-use crate::dictionary::split_with_coma;
+use crate::pages::dictionary::split_with_coma;
-use crate::dictionary_quiz::DictionaryQuizMessage::*;
+use crate::pages::dictionary_quiz::DictionaryQuizMessage::*;
-use crate::lang::WordData;
 use crate::navigation::Page::PreviousPage;
 use crate::navigation::*;
-use crate::quiz::Score;
+use crate::pages::quiz::Score;
 use crate::styling::*;
 use iced::Background::Color;
 use iced::border::Radius;
@@ -12,6 +11,7 @@ use iced::widget::container::Style;
 use iced::widget::{Row, button, container, row, space, text, text_input};
 use iced::{Border, Element, Fill, Task, Theme, alignment};
 use rand::prelude::SliceRandom;
+use crate::data::entities::WordData;
 
 #[derive(Debug, Clone)]
 pub struct DictionaryQuizState {
@@ -146,8 +146,8 @@ impl DictionaryQuizState {
         if !self.is_help {
             self.score.total += 1;
         }
-        if self.answer == self.correct
+        if self.answer.to_lowercase() == self.correct.to_lowercase()
-            || split_with_coma(self.correct.as_str()).contains(&self.answer)
+            || split_with_coma(self.correct.to_lowercase().as_str()).contains(&self.answer.to_lowercase())
         {
             if !self.is_help {
                 self.score.correct += 1;

src/pages/history.rs

@@ -1,8 +1,6 @@
-use crate::data_provider::history::{get_history_of_set, HistoryItem};
+use crate::data_provider::history::{get_history_of_set};
-use crate::lang::{WordData, INVALID_ID};
+use crate::navigation::*;
-use crate::navigation::{NavigatedPage, Page};
 use crate::styling::*;
-use crate::{AppState, RootMessage};
 use chrono::Local;
 use iced::alignment::Horizontal::Center;
 use iced::widget::space::horizontal;
@@ -11,6 +9,9 @@ use iced::{Element, Fill, FillPortion, Task};
 use parking_lot::Mutex;
 use std::sync::Arc;
 use HistoryMessage::Back;
+use crate::app::AppState;
+use crate::data::entities::{HistoryItem, WordData};
+use crate::data::INVALID_ID;
 
 #[derive(Clone)]
 pub struct HistoryState {
@@ -47,9 +48,9 @@ impl NavigatedPage<HistoryMessage> for HistoryState {
 }
 
 impl HistoryState {
-    pub fn new(id: crate::lang::Id, state: Arc<Mutex<AppState>>) -> Self {
+    pub fn new(id: crate::data::Id, state: Arc<Mutex<AppState>>) -> Self {
         let state = state.lock();
-        let history = get_history_of_set(id);
+        let history = get_history_of_set(id).unwrap_or_default();
         let words = history
             .iter()
             .map(

src/pages/import.rs

@@ -1,10 +1,10 @@
-use crate::AppState;
 use crate::data_provider::import::{ImportData, ImportGroup, get_words_of_group, load_groups};
 use crate::data_provider::words::{add_group, add_words};
-use crate::dictionary::app_data_dir;
+use crate::pages::import::ImportMessage::*;
-use crate::import::ImportMessage::*;
+use crate::data::entities::{WordData, WordGroup};
-use crate::lang::{WordData, WordGroup};
 use crate::navigation::{NavigatedPage, Page, RootMessage};
+use crate::notification::NotificationData::OpenFileError;
+use crate::notification::{NotificationData, NotificationRequest};
 use crate::styling::*;
 use iced::widget::button::danger;
 use iced::widget::container::success;
@@ -23,8 +23,11 @@ use std::fs::{File, OpenOptions};
 use std::io::BufReader;
 use std::path::PathBuf;
 use std::sync::Arc;
+use log::info;
 use tokio::task::spawn_blocking;
 use zip::ZipArchive;
+use crate::app::AppState;
+use crate::fs::*;
 
 const DEFAULT_FIELDS: [&str; 6] = ["key", "value", "tags", "reading", "context", "description"];
 
@@ -275,9 +278,6 @@ impl ImportState {
         let mut row = Row::new();
 
         for default in DEFAULT_FIELDS {
-            // if group.mapping.values().any(|name| name == default) {
-            //     continue;
-            // }
             row = row.push(
                 button(text!("{default}")).on_press(SetupDefaultProperty(default.to_string())),
             );
@@ -365,41 +365,38 @@ impl ImportState {
                 .await
                 .unwrap()
             },
-            |result: Result<ImportData, ()>| {
+            |result: Result<ImportData, NotificationData>| match result {
-                if let Ok(import) = result {
+                Ok(import) => RootMessage::Import(UpdateImport(import)),
-                    RootMessage::Import(UpdateImport(import))
+                Err(err) => RootMessage::PushNotification(NotificationRequest::Error(err)),
-                } else {
-                    RootMessage::None
-                }
             },
         )
     }
 
-    fn extract_import_file(path: PathBuf) -> Result<(), ()> {
+    fn extract_import_file(path: PathBuf) -> Result<(), NotificationData> {
-        let file = File::open(path).map_err(|_| ())?;
+        let file = File::open(path).map_err(|_| OpenFileError)?;
         let reader = BufReader::new(file);
-        let mut archive = ZipArchive::new(reader).map_err(|_| ())?;
+        let mut archive = ZipArchive::new(reader).map_err(|_| OpenFileError)?;
-        let temp_file_path = app_data_dir().join("import");
+        let temp_file_path = temp_import_path();
         let mut temp_file = OpenOptions::new()
             .write(true)
             .create(true)
             .truncate(true)
             .open(&temp_file_path)
-            .map_err(|_| ())?;
+            .map_err(|_| OpenFileError)?;
         if let Ok(mut file) = archive.by_name("collection.anki21") {
-            std::io::copy(&mut file, &mut temp_file).map_err(|_| ())?;
+            std::io::copy(&mut file, &mut temp_file).map_err(|_| OpenFileError)?;
             Ok(())
         } else if let Ok(mut file) = archive.by_name("collection.anki2") {
-            std::io::copy(&mut file, &mut temp_file).map_err(|_| ())?;
+            std::io::copy(&mut file, &mut temp_file).map_err(|_| OpenFileError)?;
             Ok(())
         } else {
-            Err(())
+            Err(OpenFileError)
         }
     }
-    fn read_import_file() -> Result<ImportData, ()> {
+    fn read_import_file() -> Result<ImportData, NotificationData> {
-        let temp_file_path = app_data_dir().join("import");
+        let temp_file_path = temp_import_path();
-        let connection = Connection::open(&temp_file_path).map_err(|_| ())?;
+        let connection = Connection::open(&temp_file_path).map_err(|_| OpenFileError)?;
-        let data = load_groups(&connection);
+        let data = load_groups(&connection)?;
         Ok(data)
     }
     fn setup_mapping(&mut self, property_name: String) {
@@ -430,13 +427,13 @@ impl ImportState {
         let skip_empty = self.skip_empty;
         let group = self.import_data.as_ref().unwrap().0[self.selected_index].clone();
         let progress = self.progress.clone().unwrap();
-        println!("{}", group.name);
+        info!("{}", group.name);
         Task::perform(
             async move {
                 spawn_blocking(move || {
-                    let temp_file_path = app_data_dir().join("import");
+                    let temp_file_path = temp_import_path();
-                    let connection = Connection::open(&temp_file_path).map_err(|_| ())?;
+                    let connection = Connection::open(&temp_file_path).map_err(|_| OpenFileError)?;
-                    let import_list = get_words_of_group(&connection, group.id);
+                    let import_list = get_words_of_group(&connection, group.id)?;
                     let mut words_list = Vec::with_capacity(import_list.len());
 
                     let map_indices = Self::get_mapping_indices(&group);
@@ -500,7 +497,10 @@ impl ImportState {
                 .await
                 .unwrap()
             },
-            |_: Result<(), ()>| RootMessage::Import(ImportFinished),
+            |r: Result<(), NotificationData>| match r {
+                Ok(_) => RootMessage::Import(ImportFinished),
+                Err(err) => RootMessage::PushNotification(NotificationRequest::Error(err))
+            }
         )
     }
 

src/pages/quiz.rs

@@ -1,12 +1,13 @@
-use crate::lang::KanaSet;
+
 use crate::navigation::Page::PreviousPage;
-use crate::navigation::{NavigatedPage, Page};
+use crate::navigation::{NavigatedPage, Page, RootMessage};
-use crate::quiz::QuizMessage::*;
+use crate::pages::quiz::QuizMessage::*;
 use crate::styling::*;
-use crate::{RootMessage, USER_FONT};
 use iced::widget::*;
 use iced::{Element, Fill, Task, alignment};
 use rand::seq::SliceRandom;
+use crate::app::USER_FONT;
+use crate::core::kana_set::KanaSet;
 
 #[derive(Clone, Debug)]
 pub struct QuizState {

src/pages/randomizer.rs

@@ -1,6 +1,6 @@
-use crate::RootMessage;
+use crate::navigation::RootMessage;
 use crate::navigation::{NavigatedPage, Page};
-use crate::randomizer::RandomizerMessage::{Back, Edit, Start};
+use crate::pages::randomizer::RandomizerMessage::{Back, Edit, Start};
 use crate::styling::{HALF_SPACING, back_overlay, jl_button};
 use iced::Task;
 use iced::widget::{button, text_editor};

src/pages/repetition.rs

@@ -1,10 +1,13 @@
+use crate::app::AppState;
+use crate::core::deck::DeckData;
+use crate::core::srs::WordOpenMode;
+use crate::data::entities::{CardStatistics, DeckSettings, WordData};
+use crate::data::Id;
 use crate::data_provider::voice::get_voice;
-use crate::lang::Id;
-use crate::lang::{CardStatistics, DeckData, DeckSettings, WordData, WordOpenMode};
 use crate::navigation::Page::PreviousPage;
-use crate::navigation::{KeyPressedPage, NavigatedPage, Page};
+use crate::navigation::{KeyPressedPage, NavigatedPage, Page, RootMessage};
+use crate::notification::{NotificationData, NotificationRequest};
 use crate::styling::*;
-use crate::{AppState, RootMessage};
 use chrono::Local;
 use iced::alignment::Horizontal::Center;
 use iced::keyboard::key::Physical::Code;
@@ -52,8 +55,9 @@ impl NavigatedPage<RepetitionMessage> for RepetitionState {
                 self.can_play = false;
                 let value = self.current_word.key.clone();
                 if self.settings.require_speech() {
-                    return Task::perform(play_sound(self.sink.clone(), value), |_| {
+                    return Task::perform(play_sound(self.sink.clone(), value), |r| match r {
-                        RootMessage::Repetition(RepetitionMessage::PlayFinished)
+                        Ok(_) => RootMessage::Repetition(RepetitionMessage::PlayFinished),
+                        Err(err) => RootMessage::PushNotification(NotificationRequest::Error(err)),
                     });
                 }
             }
@@ -146,8 +150,9 @@ impl RepetitionState {
         if self.settings.require_speech() && self.sink.is_some() {
             let sink = self.sink.clone();
             let task = play_sound(sink, self.current_word.key.clone());
-            return Task::perform(task, |_| {
+            return Task::perform(task, |r| match r {
-                RootMessage::Repetition(RepetitionMessage::PlayFinished)
+                Ok(_) => RootMessage::Repetition(RepetitionMessage::PlayFinished),
+                Err(err) => RootMessage::PushNotification(NotificationRequest::Error(err)),
             });
         }
         self.increment_counter();
@@ -322,16 +327,19 @@ pub enum RepetitionMessage {
     PlayFinished,
 }
 
-async fn play_sound(sink: Arc<Option<MixerDeviceSink>>, text: String) {
+async fn play_sound(
-    if let Ok(data) = get_voice(text.as_str()).await {
+    sink: Arc<Option<MixerDeviceSink>>,
-        spawn_blocking(move || {
+    text: String,
-            if let Some(sink) = sink.as_ref()
+) -> Result<(), NotificationData> {
-                && let Ok(play) = rodio::play(sink.mixer(), data)
+    let data = get_voice(text.as_str()).await?;
-            {
+    spawn_blocking(move || {
-                play.sleep_until_end()
+        if let Some(sink) = sink.as_ref()
-            }
+            && let Ok(play) = rodio::play(sink.mixer(), data)
-        })
+        {
-        .await
+            play.sleep_until_end()
-        .unwrap();
+        }
-    }
+    })
+    .await
+    .unwrap();
+    Ok(())
 }

src/pages/repetition_settings.rs

@@ -1,10 +1,9 @@
-use crate::AppState;
+
 use crate::data_provider::card_sets::{delete_set, update_deck};
 use crate::data_provider::card_stats::{delete_stats, load_stats_of_deck};
-use crate::lang::DeckSettings;
 use crate::navigation::Page::PreviousPage;
 use crate::navigation::{NavigatedPage, Page, RootMessage};
-use crate::repetition_settings::RepetitionSettingsMessage::*;
+use crate::pages::repetition_settings::RepetitionSettingsMessage::*;
 use crate::styling::*;
 use iced::widget::button::danger;
 use iced::widget::text_input::Catalog;
@@ -15,6 +14,8 @@ use iced_core::{Padding, Theme, color};
 use parking_lot::Mutex;
 use std::sync::Arc;
 use std::time::Duration;
+use crate::app::AppState;
+use crate::data::entities::DeckSettings;
 
 pub struct RepetitionSettingsState {
     set: DeckSettings,

src/pages/repetitions.rs

@@ -1,14 +1,16 @@
+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_stats::{add_stat_list, load_stats_of_deck};
-use crate::history::HistoryState;
-use crate::lang::{AppendMode, CardStatistics, DeckSettings, Id, OrderMode};
 use crate::navigation::Page::{History, PreviousPage, Repetition, RepetitionSettings};
-use crate::navigation::{NavigatedPage, Page};
+use crate::navigation::{NavigatedPage, Page, RootMessage};
-use crate::repetition::RepetitionState;
+use crate::pages::history::HistoryState;
-use crate::repetition_settings::RepetitionSettingsState;
+use crate::pages::repetition::RepetitionState;
-use crate::repetitions::RepetitionsMessage::*;
+use crate::pages::repetition_settings::RepetitionSettingsState;
+use crate::pages::repetitions::RepetitionsMessage::*;
 use crate::styling::*;
-use crate::{AppState, RootMessage};
 use chrono::{Days, Local, Utc};
 use hashbrown::{HashMap, HashSet};
 pub use iced::widget::button::{Catalog, Style};
@@ -51,16 +53,8 @@ impl NavigatedPage<RepetitionsMessage> for RepetitionsState {
                 Self::append_all_words(&mut clone.lock(), selected_set);
                 selected_set.existing_words_indices = selected_set.available_words_indices.clone();
             } else {
-                if selected_set
+                if selected_set.available_words_indices.is_empty()
-                    .available_words_indices
+                    || selected_set.existing_words_indices.is_empty()
-                    .as_ref()
-                    .unwrap()
-                    .is_empty()
-                    || selected_set
-                        .existing_words_indices
-                        .as_ref()
-                        .unwrap()
-                        .is_empty()
                 {
                     return None;
                 }
@@ -80,23 +74,24 @@ impl NavigatedPage<RepetitionsMessage> for RepetitionsState {
         }
     }
     fn navigated(&mut self) {
-        let index = self.selected_deck_index.unwrap();
+        if let Some(index) = self.selected_deck_index {
-        let state = self.state.lock();
+            let state = self.state.lock();
-        if let Some(global_deck) = state.decks.get(index) {
+            if let Some(global_deck) = state.decks.get(index) {
-            if global_deck.id != self.selected_deck().unwrap().id {
+                if global_deck.id != self.selected_deck().unwrap().id {
+                    drop(state);
+                    self.decks.remove(index);
+                    self.clear_selection();
+                } else {
+                    self.decks[index].general_settings =
+                        state.decks[index].clone();
+                    drop(state);
+                    self.fill_deck_word_indices();
+                }
+            } else {
                 drop(state);
                 self.decks.remove(index);
-                self.clear_selection();
+                self.clear_selection()
-            } else {
-                self.decks[self.selected_deck_index.unwrap()].general_settings =
-                    state.decks[index].clone();
-                drop(state);
-                self.fill_deck_word_indices();
             }
-        } else {
-            drop(state);
-            self.decks.remove(index);
-            self.clear_selection()
         }
     }
     fn update(&mut self, message: RepetitionsMessage) -> Task<RootMessage> {
@@ -111,8 +106,9 @@ impl NavigatedPage<RepetitionsMessage> for RepetitionsState {
                 let index = self.decks.len() + 1;
                 self.decks.push(DeckViewData {
                     general_settings: DeckSettings::with_name(format!("Колода #{}", index)),
-                    existing_words_indices: None,
+                    existing_words_indices: Default::default(),
-                    available_words_indices: None,
+                    available_words_indices: Default::default(),
+                    indices_ready: false,
                     append_mode: Default::default(),
                     index: None,
                 });
@@ -142,7 +138,7 @@ impl NavigatedPage<RepetitionsMessage> for RepetitionsState {
             SelectSet(index) => {
                 self.select_deck(index);
                 let deck = self.selected_deck().unwrap();
-                if deck.existing_words_indices.is_none() {
+                if !deck.indices_ready {
                     self.fill_deck_word_indices();
                 }
             }
@@ -193,15 +189,13 @@ impl NavigatedPage<RepetitionsMessage> for RepetitionsState {
                 {
                     {
                         let deck = self.selected_deck().unwrap();
-                        let existing_words_indices = deck.existing_words_indices.as_ref().unwrap();
+                        let existing_words_indices = &deck.existing_words_indices;
                         let mut created_set = HashSet::with_capacity(existing_words_indices.len());
                         existing_words_indices.iter().for_each(|c| {
                             created_set.insert(c);
                         });
                         adding = deck
                             .available_words_indices
-                            .as_ref()
-                            .unwrap()
                             .iter()
                             .filter(|c| !created_set.contains(c))
                             .take(count)
@@ -210,10 +204,7 @@ impl NavigatedPage<RepetitionsMessage> for RepetitionsState {
                     }
 
                     let deck = self.selected_deck_mut().unwrap();
-                    deck.existing_words_indices
+                    deck.existing_words_indices.append(&mut adding.clone());
-                        .as_mut()
-                        .unwrap()
-                        .append(&mut adding.clone());
                 }
 
                 let deck = self.selected_deck().unwrap();
@@ -278,8 +269,9 @@ impl RepetitionsState {
             .enumerate()
             .map(|(index, deck)| DeckViewData {
                 general_settings: deck.clone(),
-                existing_words_indices: None,
+                existing_words_indices: Default::default(),
-                available_words_indices: None,
+                available_words_indices: Default::default(),
+                indices_ready: false,
                 append_mode: Default::default(),
                 index: Some(index),
             })
@@ -290,9 +282,7 @@ impl RepetitionsState {
 impl RepetitionsState {
     fn launch_delete_button(&self, deck: &DeckViewData) -> Element<'_, RepetitionsMessage> {
         if deck.id.is_valid() {
-            if deck.append_mode == AppendMode::Manual
+            if deck.append_mode == AppendMode::Manual && deck.existing_words_indices.is_empty() {
-                && deck.existing_words_indices.as_ref().unwrap().is_empty()
-            {
                 return text!("Добавьте карточки или измените фильтр").into();
             }
             return row![
@@ -515,12 +505,8 @@ impl RepetitionsState {
 
     fn count_comparator_view(&self) -> Element<'_, RepetitionsMessage> {
         let selected_deck = self.selected_deck().unwrap();
-        let now = selected_deck.existing_words_indices.as_ref().unwrap().len();
+        let now = selected_deck.existing_words_indices.len();
-        let available = selected_deck
+        let available = selected_deck.available_words_indices.len();
-            .available_words_indices
-            .as_ref()
-            .unwrap()
-            .len();
         text!("{} слова добавлено из {}", now, available).into()
     }
     fn count_view(&self, deck: &DeckSettings) -> Element<'_, RepetitionsMessage> {
@@ -560,15 +546,13 @@ impl RepetitionsState {
 
 impl RepetitionsState {
     fn append_all_words(state: &mut AppState, deck: &DeckViewData) {
-        let existing = deck.existing_words_indices.as_ref().unwrap();
+        let existing = &deck.existing_words_indices;
         let mut created_set = HashSet::with_capacity(existing.len());
         existing.iter().for_each(|c| {
             created_set.insert(c);
         });
         let required = deck
             .available_words_indices
-            .as_ref()
-            .unwrap()
             .iter()
             .filter(|i| !created_set.contains(i))
             .cloned();
@@ -623,8 +607,8 @@ impl RepetitionsState {
             .map(|c| self.word_id_index_map[&c.word_id])
             .collect();
         let total = deck.get_word_list(state);
-        deck.existing_words_indices = Some(added);
+        deck.existing_words_indices = added;
-        deck.available_words_indices = Some(total);
+        deck.available_words_indices = total;
         self.decks[self.selected_deck_index.unwrap()] = deck;
     }
 }
@@ -652,8 +636,9 @@ pub enum RepetitionsMessage {
 #[derive(Clone)]
 struct DeckViewData {
     general_settings: DeckSettings,
-    existing_words_indices: Option<Vec<usize>>,
+    existing_words_indices: Vec<usize>,
-    available_words_indices: Option<Vec<usize>>,
+    available_words_indices: Vec<usize>,
+    indices_ready: bool,
     append_mode: AppendMode,
     index: Option<usize>,
 }

src/pages/selector.rs

@@ -1,14 +1,12 @@
-use crate::dictionary::DictionaryState;
+use crate::pages::dictionary::DictionaryState;
-use crate::lang::{KanaSet, KanaType};
 use crate::navigation::Page::*;
-use crate::navigation::{NavigatedPage, Page};
+use crate::navigation::{NavigatedPage, Page, RootMessage};
-use crate::randomizer::RandomizerState;
+use crate::pages::randomizer::RandomizerState;
-use crate::repetitions::RepetitionsState;
+use crate::pages::repetitions::RepetitionsState;
-use crate::selector::SelectorMessage::ChangeMode;
+use crate::pages::selector::SelectorMessage::ChangeMode;
 use crate::styling::*;
-use crate::sync::SyncState;
+use crate::pages::sync::SyncState;
-use crate::writing::WritingState;
+use crate::pages::writing::WritingState;
-use crate::{AppState, QuizState, RootMessage};
 use iced::widget::button::{Status, Style};
 use iced::widget::*;
 use iced::{Element, Task, alignment};
@@ -17,6 +15,9 @@ use iced_core::Background;
 use iced_core::Color;
 use parking_lot::Mutex;
 use std::sync::Arc;
+use crate::app::AppState;
+use crate::core::kana_set::{KanaSet, KanaType};
+use crate::pages::quiz::QuizState;
 
 pub struct SelectorState {
     pub set: KanaSet,

src/pages/sync.rs

@@ -1,10 +1,9 @@
 use crate::data_provider::settings::{delete_settings, set_setting};
 use crate::data_provider::web_api::*;
 use crate::navigation::Page::PreviousPage;
-use crate::navigation::{NavigatedPage, Page};
+use crate::navigation::{NavigatedPage, Page, RootMessage};
 use crate::styling::*;
-use crate::sync::SyncMessage::*;
+use crate::pages::sync::SyncMessage::*;
-use crate::{fill_state, AppState, RootMessage};
 use iced::widget::button::danger;
 use iced::widget::container::rounded_box;
 use iced::widget::{button, column, container, progress_bar, row, space, text, toggler};
@@ -12,6 +11,9 @@ use iced::{Center, Element, Fill, Font, Length, Task};
 use parking_lot::Mutex;
 use std::sync::Arc;
 use std::time::Duration;
+use log::error;
+use crate::app::{fill_state, AppState};
+use crate::notification::{NotificationRequest, NotificationData};
 
 #[derive(Clone)]
 pub enum SyncMessage {
@@ -62,7 +64,7 @@ impl NavigatedPage<SyncMessage> for SyncState {
                 return Task::perform(first_sync(), |id| {
                     match id {
                         Ok(id) => RootMessage::Sync(IdReceived(id)),
-                        Err(_) => RootMessage::None
+                        Err(err) => RootMessage::PushNotification(NotificationRequest::Error(err))
                     }
                 });
             }
@@ -128,6 +130,7 @@ impl NavigatedPage<SyncMessage> for SyncState {
                 state.decks = updated_state.decks;
                 state.dictionary = updated_state.dictionary;
                 state.word_groups = updated_state.word_groups;
+                return Task::done(RootMessage::PushNotification(NotificationRequest::Info(NotificationData::DataLoaded)))
             }
             Disable => {}
             DisableSync => {
@@ -244,7 +247,7 @@ impl SyncState {
             .connection
             .query_row("PRAGMA wal_checkpoint(TRUNCATE)", [], |_| Ok(()))
             .unwrap_or_else(|e| {
-                eprintln!("Ошибка при checkpoint WAL: {e}");
+                error!("Ошибка при checkpoint WAL: {e}");
             });
     }
 }

src/pages/word.rs

@@ -1,15 +1,15 @@
 use crate::data_provider::words::{delete_word, update_word};
-use crate::lang::WordData;
+use crate::data::entities::WordData;
 use crate::navigation::Page::PreviousPage;
-use crate::navigation::{NavigatedPage, Page};
+use crate::navigation::{NavigatedPage, Page, RootMessage};
 use crate::styling::*;
-use crate::word::WordMessage::*;
+use crate::pages::word::WordMessage::*;
-use crate::{AppState, RootMessage};
 use iced::widget::button::danger;
 use iced::widget::{button, column, row, rule, scrollable, text, text_input};
 use iced::{Element, Fill, Task};
 use parking_lot::Mutex;
 use std::sync::Arc;
+use crate::app::AppState;
 
 #[derive(Clone)]
 pub struct WordState {

src/pages/writing.rs

@@ -1,11 +1,11 @@
-use crate::RootMessage;
+
-use crate::lang::KanaSet;
 use crate::navigation::Page::PreviousPage;
-use crate::navigation::{NavigatedPage, Page};
+use crate::navigation::{NavigatedPage, Page, RootMessage};
 use crate::styling::*;
 use iced::widget::*;
 use iced::{Element, Fill, Task, alignment};
 use rand::seq::SliceRandom;
+use crate::core::kana_set::KanaSet;
 
 #[derive(Clone, Debug)]
 pub struct WritingState {

src/styling.rs

@@ -1,4 +1,3 @@
-use crate::repetitions::Style;
 use iced::Element;
 use iced::border::Radius;
 use iced::widget::button::*;