634 lines
20 KiB
Rust
634 lines
20 KiB
Rust
use crate::data_provider::card_stats::{
|
||
add_stat_list, delete_stat, load_stats_of_set, update_stat_score,
|
||
};
|
||
use crate::data_provider::history::{push_note, HistoryItem};
|
||
use crate::repetitions::CardSetSettings;
|
||
use crate::AppState;
|
||
use chrono::{DateTime, Utc};
|
||
use rand::distr::weighted::WeightedIndex;
|
||
use rand::distr::Distribution;
|
||
use rand::prelude::SliceRandom;
|
||
use rand::rng;
|
||
use rand::rngs::ThreadRng;
|
||
use serde::{Deserialize, Serialize};
|
||
use std::cmp::min;
|
||
use std::collections::HashMap;
|
||
use std::sync::{Arc, Mutex};
|
||
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, 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 next(&mut self) -> (String, String) {
|
||
let current_set = self.list();
|
||
|
||
let mut rand = rand::rng();
|
||
let index: u32 = rand.random();
|
||
current_set[index as usize % current_set.len()].clone()
|
||
}*/
|
||
|
||
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, Serialize, Deserialize)]
|
||
pub struct WordData {
|
||
pub id: u32,
|
||
pub key: String,
|
||
pub value: String,
|
||
pub tags: String,
|
||
pub additional: HashMap<String, String>,
|
||
pub group_id: u32,
|
||
}
|
||
|
||
impl WordData {
|
||
pub fn new() -> Self {
|
||
Self {
|
||
id: 0,
|
||
key: String::new(),
|
||
value: String::new(),
|
||
tags: String::new(),
|
||
additional: Default::default(),
|
||
group_id: 1,
|
||
}
|
||
}
|
||
}
|
||
|
||
#[derive(Clone)]
|
||
pub struct WordGroup {
|
||
pub id: u32,
|
||
pub name: String,
|
||
}
|
||
|
||
#[derive(Clone, PartialEq)]
|
||
pub struct CardStatistics {
|
||
pub id: u32,
|
||
pub word_id: u32,
|
||
pub set_id: u32,
|
||
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;
|
||
}
|
||
}
|
||
|
||
if self.score < 1 {
|
||
self.score = 1
|
||
} else if self.score > MAX_SCORE {
|
||
self.score = 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 CardSet {
|
||
words: Vec<WordData>,
|
||
set: Vec<CardStatistics>,
|
||
current_word_index: Option<usize>,
|
||
state: Arc<Mutex<AppState>>,
|
||
order_module: OrderModule,
|
||
settings: CardSetSettings,
|
||
}
|
||
|
||
impl CardSet {
|
||
pub fn new(settings: &CardSetSettings, state: Arc<Mutex<AppState>>) -> Self {
|
||
let state_for = state.clone();
|
||
let state_locked = state.lock().unwrap();
|
||
|
||
let mut current_set = load_stats_of_set(&settings, &state_locked.connection);
|
||
let last_list = settings.get_word_list(&state_locked);
|
||
let saved_ids = current_set.iter().map(|l| l.word_id).collect::<Vec<u32>>();
|
||
let word_ids = last_list.iter().map(|l| l.id).collect::<Vec<u32>>();
|
||
|
||
let new_stats: &mut Vec<CardStatistics> = &mut last_list
|
||
.iter()
|
||
.filter(|word| !saved_ids.contains(&word.id))
|
||
.map(|word| CardStatistics {
|
||
id: 0,
|
||
word_id: word.id.clone(),
|
||
last_open: Utc::now(),
|
||
score: 1,
|
||
set_id: settings.id.clone(),
|
||
})
|
||
.collect();
|
||
|
||
let time = Instant::now();
|
||
|
||
if !new_stats.is_empty() {
|
||
add_stat_list(new_stats, &state_locked.connection);
|
||
current_set.append(new_stats);
|
||
}
|
||
|
||
println!(
|
||
"Added {} stats: {}",
|
||
new_stats.len(),
|
||
time.elapsed().as_millis()
|
||
);
|
||
let mut index = 0;
|
||
for stat in current_set.clone() {
|
||
if !word_ids.contains(&stat.word_id) {
|
||
delete_stat(&stat, &state_locked.connection);
|
||
current_set.remove(index);
|
||
} else {
|
||
index += 1;
|
||
}
|
||
}
|
||
|
||
Self {
|
||
set: current_set,
|
||
words: last_list,
|
||
current_word_index: None,
|
||
state: state_for,
|
||
order_module: match settings.open_mode {
|
||
SetOrderMode::Default => OrderModule::SemiRandomSRS(SemiRandomSRSModule::new()),
|
||
SetOrderMode::TrainWorstFirst => {
|
||
OrderModule::WorstWordsSRS(WorstWordsSRSModule::new())
|
||
}
|
||
SetOrderMode::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 == false {
|
||
module.init(self)
|
||
}
|
||
let index = module.next(self);
|
||
self.order_module = OrderModule::SemiRandomSRS(module);
|
||
index
|
||
}
|
||
OrderModule::RandomSRS(mut module) => {
|
||
if module.initialized == false {
|
||
module.init(self)
|
||
}
|
||
let index = module.next(self);
|
||
self.order_module = OrderModule::RandomSRS(module);
|
||
index
|
||
}
|
||
OrderModule::WorstWordsSRS(mut module) => {
|
||
if module.initialized == false {
|
||
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 let None = self.current_word_index {
|
||
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().unwrap().connection);
|
||
push_note(
|
||
self.settings.id,
|
||
HistoryItem {
|
||
timestamp: Utc::now(),
|
||
word_id: word.word_id,
|
||
mode: WordOpenMode::Easy,
|
||
before: old_score,
|
||
after: new_score,
|
||
},
|
||
)
|
||
}
|
||
|
||
pub fn len(&self) -> usize {
|
||
self.set.len()
|
||
}
|
||
}
|
||
|
||
#[derive(Clone, PartialEq, Copy, Eq)]
|
||
pub enum SetOrderMode {
|
||
Default,
|
||
TrainWorstFirst,
|
||
FullRandom,
|
||
}
|
||
|
||
#[derive(Clone)]
|
||
enum OrderModule {
|
||
SemiRandomSRS(SemiRandomSRSModule),
|
||
RandomSRS(RandomSRSModule),
|
||
WorstWordsSRS(WorstWordsSRSModule),
|
||
}
|
||
|
||
trait SRSModule {
|
||
fn next(&mut self, set: &mut CardSet) -> usize;
|
||
fn open(&mut self, status: WordOpenMode, index: usize, updated_word: CardStatistics);
|
||
fn init(&mut self, set: &mut CardSet);
|
||
}
|
||
|
||
#[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 CardSet) -> usize {
|
||
if self.basket.is_empty() {
|
||
self.basket = (0..set.words.len()).collect::<Vec<usize>>();
|
||
self.basket.shuffle(&mut rand::rng())
|
||
}
|
||
|
||
self.basket.pop().unwrap()
|
||
}
|
||
|
||
fn open(&mut self, _: WordOpenMode, _: usize, _: CardStatistics) {}
|
||
|
||
fn init(&mut self, set: &mut CardSet) {
|
||
self.initialized = true;
|
||
self.basket = (0..set.words.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 CardSet) -> usize {
|
||
let index = self.last_weights.sample(&mut self.generator);
|
||
|
||
if self.history.contains(&index) {
|
||
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)])
|
||
.unwrap();
|
||
}
|
||
|
||
fn init(&mut self, set: &mut CardSet) {
|
||
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: &CardSet) -> usize {
|
||
min(
|
||
MAX_HISTORY_LEN,
|
||
(set.len() as f32 * MAX_HISTORY_LEN_PART) as usize,
|
||
)
|
||
}
|
||
}
|
||
|
||
#[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 CardSet) -> usize {
|
||
if self.rounds_remaining == 0 {
|
||
self.fill_pool(set);
|
||
self.rounds_remaining = self.rounds_count;
|
||
}
|
||
|
||
if self.queue.is_empty() {
|
||
self.queue.append(&mut self.pool.clone());
|
||
self.rounds_remaining -= 1;
|
||
}
|
||
|
||
self.queue.pop().unwrap()
|
||
}
|
||
|
||
fn open(&mut self, _: WordOpenMode, _: usize, _: CardStatistics) {}
|
||
|
||
fn init(&mut self, _: &mut CardSet) {
|
||
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: &CardSet) {
|
||
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;
|
||
}
|
||
}
|