376 lines
10 KiB
Rust
376 lines
10 KiB
Rust
use crate::data_provider::card_stats::{
|
|
add_stat, delete_stat, load_stats_of_set, update_stat_score,
|
|
};
|
|
|
|
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};
|
|
|
|
const MAX_HISTORY_LEN: usize = 20;
|
|
const MAX_HISTORY_LEN_PART: f32 = 0.33;
|
|
const MAX_SCORE: i32 = 25;
|
|
const FADE_PER_DAY: f32 = 0.95;
|
|
|
|
|
|
#[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: i32,
|
|
}
|
|
|
|
impl CardStatistics {
|
|
pub fn update(&mut self, status: WordOpenMode) {
|
|
match status {
|
|
WordOpenMode::Easy => {
|
|
self.score = (self.calculated_score() + 5.0).round() as i32;
|
|
}
|
|
WordOpenMode::Ok => self.score = (self.calculated_score() + 2.0).round() as i32,
|
|
WordOpenMode::Hard => {
|
|
self.score = (self.calculated_score() - 1.0).round() as i32;
|
|
}
|
|
WordOpenMode::None => {
|
|
self.score = (self.calculated_score() * 0.5) as i32;
|
|
}
|
|
}
|
|
|
|
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
|
|
}
|
|
}
|
|
|
|
#[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,
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
pub struct CardSetSettings {
|
|
pub id: u32,
|
|
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: SetOrderMode
|
|
}
|
|
|
|
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>>();
|
|
|
|
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(),
|
|
})
|
|
.for_each(|mut new_statistic| {
|
|
add_stat(&mut new_statistic, &state_locked.connection);
|
|
current_set.push(new_statistic);
|
|
});
|
|
|
|
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()),
|
|
},
|
|
}
|
|
}
|
|
|
|
pub fn next(&mut self) -> (WordData, CardStatistics) {
|
|
let index = match self.order_module.clone() {
|
|
OrderModule::SemiRandomSRS(mut module) => {
|
|
if module.initializated == false {
|
|
module.init(self)
|
|
}
|
|
let index = module.next(self);
|
|
self.order_module = OrderModule::SemiRandomSRS(module);
|
|
index
|
|
}
|
|
OrderModule::RandomSRS(mut module) => {
|
|
if module.initializated == false {
|
|
module.init(self)
|
|
}
|
|
let index = module.next(self);
|
|
self.order_module = OrderModule::RandomSRS(module);
|
|
index
|
|
}
|
|
OrderModule::WorstWordsSRS(mut module) => {
|
|
if module.initializated == 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];
|
|
word.update(status);
|
|
|
|
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)
|
|
}
|
|
|
|
pub fn len(&self) -> usize {
|
|
self.set.len()
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, PartialEq, Copy, Eq)]
|
|
pub(crate) 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 {
|
|
backet: Vec<usize>,
|
|
initializated: bool,
|
|
}
|
|
|
|
impl RandomSRSModule {
|
|
fn new() -> RandomSRSModule {
|
|
Self{
|
|
backet: vec![],
|
|
initializated: false,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl SRSModule for RandomSRSModule {
|
|
fn next(&mut self, set: &mut CardSet) -> usize {
|
|
if self.backet.is_empty() {
|
|
self.backet = (0..set.words.len()).collect::<Vec<usize>>();
|
|
self.backet.shuffle(&mut rand::rng())
|
|
}
|
|
|
|
self.backet.pop().unwrap()
|
|
}
|
|
|
|
fn open(&mut self, _: WordOpenMode, _: usize, _: CardStatistics) {}
|
|
|
|
fn init(&mut self, set: &mut CardSet) {
|
|
self.initializated = true;
|
|
self.backet = (0..set.words.len()).collect::<Vec<usize>>();
|
|
self.backet.shuffle(&mut rand::rng())
|
|
}
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
struct SemiRandomSRSModule {
|
|
history: Vec<usize>,
|
|
last_weights: WeightedIndex<f32>,
|
|
generator: ThreadRng,
|
|
initializated: bool,
|
|
}
|
|
|
|
impl SemiRandomSRSModule {
|
|
fn new() -> SemiRandomSRSModule {
|
|
SemiRandomSRSModule {
|
|
history: vec![],
|
|
last_weights: WeightedIndex::new([1.0]).unwrap(),
|
|
generator: rng(),
|
|
initializated: 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, status: 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.initializated = 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 {
|
|
initializated: bool,
|
|
}
|
|
|
|
impl SRSModule for WorstWordsSRSModule {
|
|
fn next(&mut self, set: &mut CardSet) -> usize {
|
|
todo!()
|
|
}
|
|
|
|
fn open(&mut self, status: WordOpenMode, index: usize, updated_word: CardStatistics) {
|
|
todo!()
|
|
}
|
|
|
|
fn init(&mut self, set: &mut CardSet) {
|
|
todo!()
|
|
}
|
|
}
|
|
|
|
impl WorstWordsSRSModule {
|
|
fn new() -> WorstWordsSRSModule {
|
|
WorstWordsSRSModule {
|
|
initializated: false,
|
|
}
|
|
}
|
|
}
|