Settings on new page

src/repetition_settings.rs

@@ -1,11 +1,41 @@
+use crate::AppState;
+use crate::data_provider::card_sets::{delete_set, update_card_set};
 use crate::navigation::Page::PreviousPage;
 use crate::navigation::{NavigatedPage, Page, RootMessage};
 use crate::repetition_settings::RepetitionSettingsMessage::*;
-use crate::styling::back_overlay;
-use iced::widget::row;
+use crate::repetitions::{CardSetSettings, RepetitionsMessage};
+use crate::styling::*;
+use iced::widget::button::danger;
+use iced::widget::{button, column, row, scrollable, space, text, text_input};
 use iced::{Element, Task};
+use iced_core::Length::Fill;
+use iced_core::{Length, Padding};
+use std::sync::{Arc, Mutex};
+use std::time::Duration;
+
+pub struct RepetitionSettingsState {
+    set: CardSetSettings,
+    index: usize,
+    state: Arc<Mutex<AppState>>,
+    real_delete: bool,
+}
+
+impl RepetitionSettingsState {
+    pub(crate) fn new(index: usize, p1: Arc<Mutex<AppState>>) -> RepetitionSettingsState {
+        let set;
+        {
+            let local_state = p1.lock().unwrap();
+            set = local_state.card_sets[index].clone();
+        }
+        RepetitionSettingsState {
+            index,
+            set,
+            state: p1,
+            real_delete: false,
+        }
+    }
+}
 
-pub struct RepetitionSettingsState {}
 impl NavigatedPage<RepetitionSettingsMessage> for RepetitionSettingsState {
     fn navigate(&self, message: &RepetitionSettingsMessage) -> Option<Page> {
         if let Back = message {
@@ -20,19 +50,121 @@ impl RepetitionSettingsState {
     pub fn update(&mut self, message: RepetitionSettingsMessage) -> Task<RootMessage> {
         match message {
             Back => {}
+            Save => {
+                let mut state = self.state.lock().unwrap();
+                update_card_set(&mut self.set, &state.connection);
+                state.card_sets[self.index] = self.set.clone();
+            }
+            SetName(new) => {
+                self.set.name = new;
+            }
+            SetForward(new) => {
+                self.set.forward = new;
+            }
+            SetBackward(backward) => {
+                self.set.backward = backward;
+            }
+            SetFilter(new) => {
+                self.set.filter = new;
+            }
+            TryFilter => {
+                let state = self.state.lock().unwrap();
+                let count = self.set.get_word_list(&state).len();
+                self.set.count = Some(count);
+            }
+            DeleteSet => {
+                if self.real_delete == false {
+                    self.real_delete = true;
+                    return Task::future(async {
+                        tokio::time::sleep(Duration::from_millis(3000)).await;
+                        return RootMessage::RepetitionSettings(RevertDeleteSet);
+                    });
+                }
+                let mut state = self.state.lock().unwrap();
+                delete_set(&self.set, &state.connection);
+                state.card_sets.remove(self.index);
+                return Task::done(RootMessage::RepetitionSettings(Back));
+            },
+            RevertDeleteSet => self.real_delete = false,
         }
         Task::none()
     }
 
     pub fn view(&self) -> Element<'_, RepetitionSettingsMessage> {
         back_overlay(
-            row![].into(),
+            iced::widget::column![
+                scrollable(
+                    column![
+                        column![
+                            text!("Название набора"),
+                            text_input("", &self.set.name).on_input(SetName),
+                        ]
+                        .spacing(QUARTER_SPACING),
+                        column![
+                            text!("Передняя сторона"),
+                            text_input("", &self.set.forward).on_input(SetForward),
+                        ]
+                        .spacing(QUARTER_SPACING),
+                        column![
+                            text!("Задняя сторона"),
+                            text_input("", &self.set.backward).on_input(SetBackward),
+                        ]
+                        .spacing(QUARTER_SPACING),
+                        column![
+                            text!("Фильтр"),
+                            text_input("", &self.set.filter).on_input(SetFilter),
+                            button("Проверить фильтр")
+                                .style(jl_button)
+                                .on_press(TryFilter),
+                            self.count_view(&self.set),
+                        ]
+                        .spacing(QUARTER_SPACING),
+                    ]
+                    .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),
+                    button(if self.real_delete {
+                        "Вы уверены?"
+                    } else {
+                        "Удалить"
+                    })
+                    .style(danger)
+                    .on_press(DeleteSet),
+                    space().width(Fill),
+                ]
+                .spacing(DEFAULT_SPACING),
+            ]
+            .spacing(DEFAULT_SPACING)
+            .into(),
             Back,
         )
     }
+
+    fn count_view(&self, set: &CardSetSettings) -> Element<'_, RepetitionSettingsMessage> {
+        if let Some(count) = set.count {
+            return text!("Количество слов: {}", count).into();
+        }
+        space().into()
+    }
 }
 
 #[derive(Clone)]
-pub enum  RepetitionSettingsMessage {
-    Back
-}
+pub enum RepetitionSettingsMessage {
+    Back,
+    Save,
+    SetName(String),
+    SetForward(String),
+    SetBackward(String),
+    SetFilter(String),
+    TryFilter,
+    DeleteSet,
+    RevertDeleteSet,
+}