jap_learn/src/data/entities.rs

use crate::app::AppState;
use crate::core::srs::{FADE_PER_DAY, MAX_SCORE, OrderMode, WordOpenMode};
use crate::data::{INVALID_ID, Id};
use chrono::{DateTime, NaiveDate, Utc};
use fsrs::MemoryState;
use log::info;
use rayon::prelude::*;
use rhai::{Engine, Scope};
use std::cmp::Ordering;
use std::marker::PhantomData;
use std::time::Instant;
use litemap::LiteMap;

#[derive(Clone, Debug)]
pub struct WordData {
    pub id: Id,
    pub group_id: Id,
    pub key: String,
    pub value: String,
    pub tags: String,
    pub additional: LiteMap<String, String>,
}

impl EntityData for WordData {
    fn id(&self) -> Id {
        self.id
    }

    fn set_id(&mut self, id: Id) {
        self.id = id;
    }
}

#[derive(Clone)]
pub struct WordGroup {
    pub id: Id,
    pub name: String,
}

impl EntityData for WordGroup {
    fn id(&self) -> Id {
        self.id
    }

    fn set_id(&mut self, id: Id) {
        self.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 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()
                                .expect("No group id")
                                .name,
                        );

                    let result = engine.eval_ast_with_scope::<bool>(&mut scope, &ast);
                    if let Ok(result) = result {
                        return result;
                    }
                    false
                })
                .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 CardState {
    pub id: Id,
    pub word_id: Id,
    pub set_id: Id,
    pub last_open: DateTime<Utc>,
    pub score: u8,
    pub fsrs_opened: NaiveDate,
    pub fsrs_memory: Option<MemoryState>,
    pub fsrs_open_day: NaiveDate,
}

impl EntityData for CardState {
    fn id(&self) -> Id {
        self.id
    }

    fn set_id(&mut self, id: Id) {
        self.id = id;
    }
}

impl CardState {
    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(Copy)]
pub struct EntityHandle<E> {
    pub(crate) id: Id,
    index: u32,
    pub(crate) _phantom: PhantomData<E>,
}

impl<T> Clone for EntityHandle<T> {
    fn clone(&self) -> Self {
        EntityHandle {
            id: self.id,
            index: self.index,
            _phantom: Default::default(),
        }
    }
}
impl<T> EntityHandle<T> {
    pub fn new(id: Id, index: usize, real: bool) -> Self {
        Self {
            id,
            index: ((index as u32) << 1 >> 1) | (!real as u32) << 31,
            _phantom: Default::default(),
        }
    }
    pub fn index(&self) -> usize {
        (self.index << 1 >> 1) as usize
    }

    pub fn set_index(&mut self, index: usize) {
        self.index = (self.index >> 31 << 31) | ((index as u32) << 1 >> 1);
    }

    pub fn real(&self) -> bool {
        (self.index >> 31) == 0
    }

    pub fn set_real(&mut self, value: bool) {
        self.index = self.index << 1 >> 1 | (!value as u32) << 31;
    }
}
impl<T> Eq for EntityHandle<T> {}

impl<T> PartialEq<Self> for EntityHandle<T> {
    fn eq(&self, other: &Self) -> bool {
        self.real() == other.real() && self.id == other.id
    }
}
impl<T> PartialOrd<Self> for EntityHandle<T> {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        Some(self.cmp(other))
    }
}

impl<T> Ord for EntityHandle<T> {
    fn cmp(&self, other: &Self) -> Ordering {
        if self.real() && !other.real() {
            return Ordering::Less;
        }

        if !self.real() && other.real() {
            return Ordering::Greater;
        }

        self.id.cmp(&other.id)
    }
}

pub trait EntityData {
    fn id(&self) -> Id;
    fn set_id(&mut self, id: Id);
}