jap_learn/src/repetitions.rs

use crate::data_provider::card_sets::{delete_set, update_card_set};
use crate::data_provider::card_stats::load_stats_of_set;
use crate::history::HistoryState;
use crate::lang::{SetOrderMode, WordData};
use crate::navigation::Page::{History, PreviousPage, Repetition};
use crate::navigation::{NavigatedPage, Page};
use crate::repetition::RepetitionState;
use crate::styling::*;
use crate::{AppState, RootMessage};
use iced::widget::button::{danger, Status};
pub use iced::widget::button::{Catalog, Style};
use iced::widget::container::bordered_box;
use iced::widget::{button, column, container, radio, row, scrollable, space, text, text_input, Column};
use iced::{Background, Border, Center, Color, Element, Fill, Length, Shadow, Task, Theme};
use rhai::{Engine, Scope};
use std::sync::{Arc, Mutex};

#[derive(Clone)]
pub struct RepetitionsState {
    selected_set: Option<usize>,
    correct_filters: Vec<bool>,
    
    pub state: Arc<Mutex<AppState>>,
}

impl NavigatedPage<RepetitionsMessage> for RepetitionsState {
    fn navigate(&self, message: &RepetitionsMessage) -> Option<Page> {
        if let RepetitionsMessage::Back = message {
            Some(PreviousPage)
        } else if let RepetitionsMessage::GoToHistory = message {
            let card_set;
            {
                card_set = self.state.lock().unwrap().card_sets[self.selected_set.unwrap()].id;
            }
            Some(History(HistoryState::new(card_set, self.state.clone())))
        } else if let RepetitionsMessage::GoToRepetition = message {
            let clone = self.state.clone();
            let card_set;
            {
                card_set = self.state.lock().unwrap().card_sets[self.selected_set.unwrap()].clone();
            }
            Some(Repetition(RepetitionState::new(card_set, clone)))
        } else {
            None
        }
    }
}

impl RepetitionsState {
    pub(crate) fn new(state: Arc<Mutex<AppState>>) -> RepetitionsState {
        let count = state.lock().unwrap().card_sets.len();
        RepetitionsState {
            selected_set: None,
            correct_filters: vec![true; count],
            state,
        }
    }
}

impl RepetitionsState {
    pub fn update(&mut self, message: RepetitionsMessage) -> Task<RootMessage> {
        let mut state = self.state.lock().unwrap();
        match message {
            RepetitionsMessage::Next => {}
            RepetitionsMessage::Back => {}
            RepetitionsMessage::GoToRepetition => {}
            RepetitionsMessage::GoToHistory => {}
            RepetitionsMessage::CreateSet => {
                let index = state.card_sets.len() + 1;
                state
                    .card_sets
                    .push(CardSetSettings::with_name(format!("Card set #{}", index)));
                self.correct_filters.push(true);
            }
            RepetitionsMessage::DeleteSet => {
                let set = state.card_sets.remove(self.selected_set.unwrap());
                self.correct_filters.remove(self.selected_set.unwrap());
                self.selected_set = None;
                delete_set(&set, &state.connection);
            }
            RepetitionsMessage::SelectSet(index) => {
                self.selected_set = Some(index);
                let mut set = state.card_sets.get(index).unwrap().clone();
                set.update_worst_words(&state);
                state.card_sets[index] = set;
            }
            RepetitionsMessage::SetName(new) => {
                state.card_sets[self.selected_set.unwrap()].name = new;
            }
            RepetitionsMessage::Save => {
                for i in 0..state.card_sets.len() {
                    self.correct_filters[i] = state.card_sets[i].check_filter();
                }

                let word = &mut state.card_sets[self.selected_set.unwrap()].clone();

                update_card_set(word, &state.connection);

                state.card_sets[self.selected_set.unwrap()] = word.clone();
            }
            RepetitionsMessage::SetForward(new) => {
                state.card_sets[self.selected_set.unwrap()].forward = new;
            }
            RepetitionsMessage::SetBackward(new) => {
                state.card_sets[self.selected_set.unwrap()].backward = new;
            }
            RepetitionsMessage::SetFilter(new) => {
                state.card_sets[self.selected_set.unwrap()].filter = new;
            }
            RepetitionsMessage::TryFilter => {
                let set = state.card_sets.get(self.selected_set.unwrap()).unwrap();
                let count = set.get_word_list(&state).len();
                state.card_sets[self.selected_set.unwrap()].count = Some(count);
            },
            RepetitionsMessage::SetOpenMode(mode) => {
                state.card_sets.get_mut(self.selected_set.unwrap()).unwrap().open_mode = mode;
            }
        }
        Task::none()
    }

    pub fn view(&self) -> Element<'_, RepetitionsMessage> {
        back_overlay(row![
                    column![
                        scrollable(self.sets_list()).height(Fill),
                        button("Добавить").style(jl_button)
                            .width(Fill)
                            .on_press(RepetitionsMessage::CreateSet),
                    ]
                    .spacing(DEFAULT_SPACING)
                    .width(Length::FillPortion(1)),
                    self.selected_set_view(),
                    self.launch_button()
                ]
            .align_y(Center)
            .spacing(DEFAULT_SPACING)
            .width(Fill)
            .height(Fill).into(), RepetitionsMessage::Back)
    }

    fn launch_button(&self) -> Element<'_, RepetitionsMessage> {
        if let Some(set) = self.selected_set && self.state.lock().unwrap().card_sets[set].id != 0 {
            return button(text!("▷").height(Fill).center()).style(jl_button)
                .height(200)
                .on_press(RepetitionsMessage::GoToRepetition)
                .into();
        }
        space().into()
    }

    fn selected_set_view(&self) -> Element<'_, RepetitionsMessage> {
        if let Some(index) = self.selected_set {
            let set;
            {
                set = self.state.lock().unwrap().card_sets[index].clone();
            }
            return column![
                scrollable(
                    column![
                        text_input("Название набора", &set.name)
                            .on_input(RepetitionsMessage::SetName),
                        text_input("Передняя сторона", &set.forward)
                            .on_input(RepetitionsMessage::SetForward),
                        text_input("Задняя сторона", &set.backward)
                            .on_input(RepetitionsMessage::SetBackward),
                        text!("Фильтр"),
                        text_input("", &set.filter).on_input(RepetitionsMessage::SetFilter),
                        button("Проверить фильтр").style(jl_button).on_press(RepetitionsMessage::TryFilter),
                        self.count_view(&set),
                        radio("Обычный режим", SetOrderMode::Default, Some(set.open_mode), RepetitionsMessage::SetOpenMode),
                        self.words_words_view(&set),
                        button("История").style(jl_button).on_press(RepetitionsMessage::GoToHistory),
                    ]
                    .spacing(DEFAULT_SPACING)
                )
                .height(Fill),
                row![
                    button("Сохранить").style(jl_button).on_press(RepetitionsMessage::Save),
                    button("Удалить")
                        .style(danger)
                        .on_press(RepetitionsMessage::DeleteSet)
                ]
                .spacing(DEFAULT_SPACING),
            ]
            .spacing(DEFAULT_SPACING)
            .width(Length::FillPortion(2))
            .into();
        }
        space().width(Length::FillPortion(2)).into()
    }

    fn words_words_view(&self, set: &CardSetSettings) -> Element<'_, RepetitionsMessage> {
        column![
            text!("Худшие слова"),
            container(scrollable(self.worst_words_list(&set)).height(200)).style(bordered_box),
            radio("Начать с плохих слов", SetOrderMode::TrainWorstFirst, Some(set.open_mode), RepetitionsMessage::SetOpenMode),
            radio("Полностью случайно", SetOrderMode::FullRandom, Some(set.open_mode), RepetitionsMessage::SetOpenMode)
        ]
        .spacing(DEFAULT_SPACING)
        .into()
    }

    fn worst_words_list(&self, set: &CardSetSettings) -> Element<'_, RepetitionsMessage> {


        let mut column = Column::new();

        for word in set.worst_words_list.clone().unwrap() {
            column = column.push(text!("{} | {}", &word.key, &word.value));
        }
        column.into()
    }

    fn count_view(&self, set: &CardSetSettings) -> Element<'_, RepetitionsMessage> {
        if let Some(count) = set.count {
            return text!("Количество слов: {}", count).into();
        }
        space().into()
    }

    fn sets_list(&self) -> Column<'_, RepetitionsMessage> {
        let mut column = Column::new();
        let mut i = 0;
        let sets = &self.state.lock().unwrap().card_sets;
        for set in sets {
            column = column.push(
                button(text!("{}", set.name.clone()))
                    .on_press_with(move || RepetitionsMessage::SelectSet(i.clone()))
                    .style(move |_x: &Theme, status : Status| Style {
                        background: if status == Status::Hovered {Some(Background::Color(Color::WHITE.scale_alpha(0.1)))} else { None },
                        text_color: if self.correct_filters[i.clone()] {
                            _x.palette().primary
                        } else {
                            _x.palette().warning
                        },
                        border: Border{
                            color: Default::default(),
                            width: 0.0,
                            radius: 8.0.into(),
                        },
                        shadow: Shadow::default(),
                        snap: false,
                    }),
            );
            i += 1;
        }

        column
    }

}

#[derive(Clone)]
pub enum RepetitionsMessage {
    Next,
    Back,
    GoToRepetition,
    CreateSet,
    DeleteSet,
    SetName(String),
    SelectSet(usize),
    Save,
    SetForward(String),
    SetBackward(String),
    SetFilter(String),
    TryFilter,
    SetOpenMode(SetOrderMode),
    GoToHistory,
}

#[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 CardSetSettings {
    fn with_name(name: String) -> CardSetSettings {
        CardSetSettings {
            id: 0,
            name,
            forward: "".to_string(),
            backward: "".to_string(),
            filter: "true".to_string(),
            count: None,
            worst_words_list: None,
            open_mode: SetOrderMode::Default,
        }
    }

    fn check_filter(&self) -> bool {
        let engine = Engine::new();
        let ast = engine.compile(&self.filter);
        ast.is_ok()
    }

    pub fn get_word_list(&self, state: &AppState) -> Vec<WordData> {
        let mut list = vec![];
        let engine = Engine::new();
        let ast = engine.compile(&self.filter);
        if ast.is_err() {
            return list;
        }

        let ast = ast.unwrap();

        let groups = &state.word_groups;

        for word in &state.dictionary {
            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("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);
            if result.is_ok() && result.unwrap() {
                list.push(word.clone());
            }
        }

        list
    }

    pub fn require_speech(&self) -> bool {
        self.forward == "speech" || self.backward == "speech"
    }

    fn update_worst_words(&mut self, state: &AppState){
        if let Some(_) = self.worst_words_list {
            return;
        }

        let connection = &state.connection;
        let mut stats = load_stats_of_set(self, connection);
        stats.sort_by_key(|s| s.calculated_score() as i32);
        let avg = stats.iter().map(|s| s.calculated_score()).sum::<f32>() / stats.len() as f32;
        let avg = avg * 0.7;
        let bad: Vec<WordData> = stats
            .iter()
            .take_while(|word| word.calculated_score() < avg)
            .map(|stat| {
                state.dictionary[ state
                    .dictionary
                    .binary_search_by_key(&stat.word_id, |x| x.id)
                    .unwrap()].clone()
            })
            .collect();

        self.worst_words_list = Some(bad.clone());
    }


}