jap_learn/src/repetitions.rs

use std::ops::Deref;
use crate::data_provider::card_sets::{delete_set, update_card_set};
use crate::data_provider::card_stats::{add_stat_list, load_stats_of_set};
use crate::history::HistoryState;
use crate::lang::{AppendMode, DeckSettings, CardStatistics, OrderMode};
use crate::navigation::Page::{History, PreviousPage, Repetition, RepetitionSettings};
use crate::navigation::{NavigatedPage, Page};
use crate::repetition::RepetitionState;
use crate::repetition_settings::RepetitionSettingsState;
use crate::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};
use iced::widget::button::{Status, danger};
use iced::widget::tooltip::Position::Top;
use iced::widget::{
    Column, Row, button, column, container, lazy, radio, row, scrollable, space, svg, text,
    text_input, tooltip,
};
use iced::{Background, Border, Center, Color, Element, Fill, Length, Shadow, Task, Theme};
use iced_core::Padding;
use iced_core::border::Radius;
use iced_core::svg::Handle;
use std::sync::{Arc, Mutex};

#[derive(Clone)]
pub struct RepetitionsState {
    correct_filters: Vec<bool>,
    current_sets_cards_cache: HashMap<usize, (Vec<usize>, Vec<usize>)>,
    word_id_index_map: HashMap<u32, usize>,
    local_settings: HashMap<u32, DeckLocalSetting>,
    view_data: Option<SetViewData>,
    state: Arc<Mutex<AppState>>,
}

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

            if self.local_settings[&card_set.id].append_mode == AppendMode::Full {
                self.append_all_words(&card_set);
            } else {
                let cache = self
                    .current_sets_cards_cache
                    .get(&self.selected_set_index.unwrap())
                    .unwrap();
                if cache.1.is_empty() || cache.0.is_empty() {
                    let local_settings = self.local_settings.get_mut(&card_set.id).unwrap();
                    local_settings.append_warning = true;
                }
            }

            Some(Repetition(RepetitionState::new(card_set, clone)))
        } else if let GoToSettings = message {
            Some(RepetitionSettings(RepetitionSettingsState::new(
                self.selected_set_index.unwrap(),
                self.state.clone(),
            )))
        } else {
            None
        }
    }
    fn navigated(&mut self) {
        self.clear_selection();
        self.current_sets_cards_cache.clear();
    }
    fn update(&mut self, message: RepetitionsMessage) -> Task<RootMessage> {
        match message {
            Next => {}
            Back => {}
            GoToRepetition => {}
            GoToHistory => {}
            GoToSettings => {}

            CreateSet => {

            }
            DeleteSet => {}
            SetName(_) => {}
            SelectSet(_) => {}
            Save => {}
            SetForward(_) => {}
            SetBackward(_) => {}
            SetFilter(_) => {}
            TryFilter => {}
            SetOpenMode(_) => {}
            SetAppendMode(_) => {}
            AppendWords(_) => {}
        }
        Task::none()
    }

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

impl RepetitionsState {
    pub(crate) fn new(state: Arc<Mutex<AppState>>) -> RepetitionsState {
        let state_ = state.lock().unwrap();
        let count = state_.card_sets.len();
        let mut map = HashMap::with_capacity(state_.dictionary.len());

        state_
            .dictionary
            .iter()
            .enumerate()
            .for_each(|(index, word)| {
                map.insert(word.id, index);
            });

        let mut local_settings = HashMap::with_capacity(state_.card_sets.len());
        state_.card_sets.iter().for_each(|card_set| {
            local_settings.insert(card_set.id, Default::default());
        });
        drop(state_);
        RepetitionsState {
            selected_set_index: None,
            correct_filters: vec![true; count],
            current_sets_cards_cache: Default::default(),
            word_id_index_map: map,
            local_settings,
            view_data: None,
            state,
            set_names: vec![],
        }
    }
}

impl RepetitionsState {
    fn launch_delete_button(&self, set: &DeckSettings) -> Element<'_, RepetitionsMessage> {
        if set.id != 0 {
            return row![
                space().width(Fill),
                button(text!("Начать повторение").width(200).center())
                    .style(cta_button)
                    .on_press(GoToRepetition)
            ]
            .into();
        }
        button("Удалить").style(danger).on_press(DeleteSet).into()
    }
    fn selected_set_view(&self) -> Element<'_, RepetitionsMessage> {
        if let Some(set) = &self.view_data {
            return column![
                scrollable(
                    column![
                        column![
                            text!("Название набора"),
                            row![
                                text_input("", &set.name).on_input(SetName),
                                button(svg(Handle::from_memory(SETTINGS_ICON)))
                                    .width(43)
                                    .on_press(GoToSettings),
                            ]
                            .spacing(HALF_SPACING)
                        ]
                        .spacing(QUARTER_SPACING),
                        {
                            if set.id == 0 {
                                column![
                                    column![
                                        text!("Передняя сторона"),
                                        text_input("", &set.forward).on_input(SetForward),
                                    ]
                                    .spacing(QUARTER_SPACING),
                                    column![
                                        text!("Задняя сторона"),
                                        text_input("", &set.backward).on_input(SetBackward),
                                    ]
                                    .spacing(QUARTER_SPACING),
                                    column![
                                        text!("Фильтр"),
                                        text_input("", &set.filter).on_input(SetFilter),
                                        button("Проверить фильтр")
                                            .style(jl_button)
                                            .on_press(TryFilter),
                                        self.count_view(set),
                                    ]
                                    .spacing(QUARTER_SPACING),
                                ]
                                .spacing(DEFAULT_SPACING)
                            } else {
                                column![
                                    self.filled_set_data_view(set),
                                    self.word_append_panel(set),
                                    radio(
                                        "Обычный режим",
                                        OrderMode::Default,
                                        Some(set.open_mode),
                                        SetOpenMode
                                    ),
                                    radio(
                                        "Начать с плохих слов",
                                        OrderMode::TrainWorstFirst,
                                        Some(set.open_mode),
                                        SetOpenMode
                                    ),
                                    radio(
                                        "Полностью случайно",
                                        OrderMode::FullRandom,
                                        Some(set.open_mode),
                                        SetOpenMode
                                    ),
                                    button("История").style(jl_button).on_press(GoToHistory),
                                ]
                                .spacing(HALF_SPACING)
                            }
                        },
                        // self.words_words_view(&set),
                    ]
                    .spacing(DEFAULT_SPACING)
                    .padding(Padding {
                        top: 0.0,
                        right: DEFAULT_SPACING,
                        bottom: 0.0,
                        left: 0.0,
                    })
                )
                .height(Fill),
                row![
                    button("Сохранить").style(jl_button).on_press(Save),
                    self.launch_delete_button(&set)
                ]
                .spacing(DEFAULT_SPACING),
            ]
            .spacing(DEFAULT_SPACING)
            .width(Length::FillPortion(2))
            .into();
        }
        space().width(Length::FillPortion(2)).into()
    }
    fn filled_set_data_view(&self, set: &DeckSettings) -> Column<'_, RepetitionsMessage> {
        column![self.activity_bar(set), self.count_comparator_view()]
            .align_x(Center)
            .width(Fill)
            .spacing(DEFAULT_SPACING)
    }
    fn activity_bar(&self, set: &DeckSettings) -> Element<'_, RepetitionsMessage> {
        const MAX_DAY_COUNT: f32 = 128.0;

        let state = self.state.lock().unwrap();
        let history = state.activity.get(&set.id);
        let mut counts: Vec<u32> = vec![0; 30 * 7];
        let now = Local::now().date_naive();

        if let Some(history) = history {
            for (date, activity) in history {
                let distance = now - *date;
                let index = counts.len() as i64 - distance.num_days() - 1;

                if index == 210 {
                    println!("invalid index")
                }
                if index < 0 {
                    continue;
                }

                counts[index as usize] = *activity;
            }
        }

        lazy((counts, now), |(counts, now)| {
            let mut row = Row::new()
                .padding(Padding {
                    top: 0.0,
                    right: 0.0,
                    bottom: 0.0,
                    left: DEFAULT_SPACING,
                })
                .spacing(QUARTER_SPACING);

            let mut iter = counts.iter();
            for i in 0..30 {
                let mut column = Column::new().spacing(QUARTER_SPACING);

                for j in 0..7 {
                    let value = *iter.next().unwrap() as f32;
                    let k = (value / MAX_DAY_COUNT).min(1.0) * 0.9 + 0.1;

                    let date = (*now)
                        .checked_sub_days(Days::new(30 * 7 - i * 7 - j - 1))
                        .unwrap();

                    column = column.push(tooltip(
                        iced::widget::container(space().height(15).width(15)).style(
                            move |x: &Theme| container::Style {
                                text_color: None,
                                background: Some(Background::Color(
                                    x.palette().primary.scale_alpha(k),
                                )),
                                border: Border {
                                    color: Default::default(),
                                    width: 0.0,
                                    radius: Radius::new(5),
                                },
                                shadow: Default::default(),
                                snap: false,
                            },
                        ),
                        text!("{} {} карточки", date.format("%Y.%m.%d"), value),
                        Top,
                    ));
                }

                row = row.push(column);
            }
            scrollable(
                column!["Карта активности", row]
                    .spacing(QUARTER_SPACING)
                    .align_x(Center),
            )
        })
        .into()
    }
    fn word_append_panel(&self, set: &DeckSettings) -> Element<'_, RepetitionsMessage> {
        column![
            text!("Режим добавления карточек"),
            row![
                radio(
                    "Добавлять все доступные",
                    AppendMode::Full,
                    Some(self.local_settings[&set.id].append_mode),
                    SetAppendMode
                ),
                radio(
                    "Добавлять вручную",
                    AppendMode::Manual,
                    Some(self.local_settings[&set.id].append_mode),
                    SetAppendMode
                )
            ]
            .spacing(HALF_SPACING),
            self.adder_panel(set),
        ]
        .spacing(HALF_SPACING)
        .into()
    }
    fn adder_panel(&self, set: &DeckSettings) -> Element<'_, RepetitionsMessage> {
        match self.local_settings[&set.id].append_mode {
            AppendMode::Full => space().into(),
            AppendMode::Manual => row![
                button("+5").on_press(AppendWords(5)),
                button("+10").on_press(AppendWords(10)),
                button("+15").on_press(AppendWords(15)),
                button("+20").on_press(AppendWords(20))
            ]
            .spacing(HALF_SPACING)
            .into(),
        }
    }
    fn count_comparator_view(&self) -> Element<'_, RepetitionsMessage> {
        let cache = &self.current_sets_cards_cache[&self.selected_set_index.unwrap()];
        let now = cache.0.len();
        let available = cache.1.len();
        text!("{} слова добавлено из {}", now, available).into()
    }
    fn count_view(&self, set: &DeckSettings) -> 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();

        for (i, set) in self.set_names.iter().enumerate() {
            column = column.push(
                button(text!("{}", set.clone()))
                    .on_press_with(move || SelectSet(i))
                    .style(move |_x: &Theme, status: Status| Style {
                        background: if status == Status::Hovered {
                            Some(Background::Color(Color::WHITE.scale_alpha(0.2)))
                        } else {
                            None
                        },
                        text_color: if self.correct_filters[i] {
                            _x.palette().primary
                        } else {
                            _x.palette().warning
                        },
                        border: Border {
                            color: Default::default(),
                            width: 0.0,
                            radius: BUTTON_RADIUS.into(),
                        },
                        shadow: Shadow::default(),
                        snap: false,
                    }),
            );
        }

        column
    }
}

impl RepetitionsState {
    fn append_all_words(&self, set: &DeckSettings) {
        let cache = &self.current_sets_cards_cache[&index];
        let mut created_set = HashSet::with_capacity(cache.0.len());
        cache.0.iter().for_each(|c| {
            created_set.insert(c);
        });
        let required = cache.1.iter().filter(|i| !created_set.contains(i)).cloned();
        Self::append_words(&self.state.lock().unwrap(), set, required);
    }
    fn append_words(state: &AppState, set: &DeckSettings, indices: impl Iterator<Item = usize>) {
        let words = &state.dictionary;
        let stats = &mut indices
            .map(|i| {
                let word = words.get(i).unwrap();
                CardStatistics {
                    id: 0,
                    word_id: word.id,
                    last_open: Utc::now(),
                    score: 1,
                    set_id: set.id,
                }
            })
            .collect::<Vec<_>>();

        if !stats.is_empty() {
            add_stat_list(stats, &state.connection);
        }
    }
    fn select_set(&mut self, index: usize) {
        let state = self.state.lock().unwrap();
        if let Some(set) = state.card_sets.get(index) {

        }
    }

    fn clear_selection(&mut self) {
        self.view_data = None;
    }
}
#[derive(Clone)]
pub enum RepetitionsMessage {
    Next,
    Back,
    GoToRepetition,
    CreateSet,
    DeleteSet,
    SetName(String),
    SelectSet(usize),
    Save,
    SetForward(String),
    SetBackward(String),
    SetFilter(String),
    TryFilter,
    SetOpenMode(OrderMode),
    SetAppendMode(AppendMode),
    GoToHistory,
    GoToSettings,
    AppendWords(usize),
}

#[derive(Clone, Default)]
struct DeckLocalSetting {
    append_mode: AppendMode,
    append_warning: bool,
}

#[derive(Clone)]
struct SetViewData{
    set_local_settings: DeckLocalSetting,
    set_settings: DeckSettings,
    existing_words_indices: Vec<usize>,
    available_words_indices: Vec<usize>,
}
impl Deref for SetViewData {
    type Target = DeckSettings;

    fn deref(&self) -> &Self::Target {
        &self.set_settings
    }
}