Skip to main content

nf_rated/render/
core.rs

1use crate::{data::is_valid_query_filter, data::ItemType, RatedRow};
2
3use super::StatefulList;
4
5#[derive(Clone)]
6pub enum InputMode {
7    Querying,
8    Configuring,
9}
10
11#[derive(Clone)]
12pub enum Log {
13    Error(String),
14    Warn(String),
15    Info(String),
16    Debug(String),
17}
18
19#[derive(Clone, PartialEq)]
20pub enum QueryField {
21    Genre,
22    Title,
23    Cast,
24    Country,
25    Language,
26    Plot,
27}
28
29impl From<QueryField> for String {
30    fn from(field: QueryField) -> Self {
31        match field {
32            QueryField::Genre => "Genre".to_string(),
33            QueryField::Title => "Title".to_string(),
34            QueryField::Cast => "Cast".to_string(),
35            QueryField::Country => "Country".to_string(),
36            QueryField::Language => "Language".to_string(),
37            QueryField::Plot => "Plot".to_string(),
38        }
39    }
40}
41
42pub struct App {
43    pub items: StatefulList<RatedRow>,
44
45    pub query_field: QueryField,
46    pub genre_query: String,
47    pub title_query: String,
48    pub cast_query: String,
49    pub country_query: String,
50    pub language_query: String,
51    pub plot_query: String,
52
53    pub item_type: ItemType,
54    pub logs: Vec<Log>,
55    pub input_mode: InputMode,
56}
57
58impl App {
59    pub fn new(rows: Vec<RatedRow>) -> Self {
60        Self {
61            items: StatefulList::with_items(rows),
62
63            query_field: QueryField::Genre,
64            genre_query: "".to_string(),
65            title_query: "".to_string(),
66            cast_query: "".to_string(),
67            country_query: "".to_string(),
68            language_query: "".to_string(),
69            plot_query: "".to_string(),
70
71            item_type: ItemType::Both,
72            logs: vec![],
73            input_mode: InputMode::Querying,
74        }
75    }
76
77    pub fn next_item_type(&mut self) {
78        let next_type = match self.item_type {
79            ItemType::Movie => ItemType::Series,
80            ItemType::Series => ItemType::Both,
81            ItemType::Both => ItemType::Movie,
82        };
83        self.item_type = next_type;
84    }
85
86    pub fn next_query_field(&mut self) {
87        let next_query_field = match self.query_field {
88            QueryField::Genre => QueryField::Title,
89            QueryField::Title => QueryField::Cast,
90            QueryField::Cast => QueryField::Country,
91            QueryField::Country => QueryField::Language,
92            QueryField::Language => QueryField::Plot,
93            QueryField::Plot => QueryField::Genre,
94        };
95        self.query_field = next_query_field
96    }
97
98    pub fn prev_query_field(&mut self) {
99        let prev_query_field = match self.query_field {
100            QueryField::Plot => QueryField::Language,
101            QueryField::Country => QueryField::Cast,
102            QueryField::Language => QueryField::Country,
103            QueryField::Cast => QueryField::Title,
104            QueryField::Title => QueryField::Genre,
105            QueryField::Genre => QueryField::Plot,
106        };
107        self.query_field = prev_query_field
108    }
109
110    pub fn get_query(&self) -> &str {
111        match self.query_field {
112            QueryField::Genre => &self.genre_query,
113            QueryField::Title => &self.title_query,
114            QueryField::Cast => &self.cast_query,
115            QueryField::Country => &self.country_query,
116            QueryField::Language => &self.language_query,
117            QueryField::Plot => &self.plot_query,
118        }
119    }
120
121    pub fn push_onto_query(&mut self, c: char) {
122        match self.query_field {
123            QueryField::Genre => self.genre_query.push(c),
124            QueryField::Title => self.title_query.push(c),
125            QueryField::Cast => self.cast_query.push(c),
126            QueryField::Country => self.country_query.push(c),
127            QueryField::Language => self.language_query.push(c),
128            QueryField::Plot => self.plot_query.push(c),
129        };
130    }
131
132    pub fn pop_off_query(&mut self) {
133        match self.query_field {
134            QueryField::Genre => self.genre_query.pop(),
135            QueryField::Title => self.title_query.pop(),
136            QueryField::Cast => self.cast_query.pop(),
137            QueryField::Country => self.country_query.pop(),
138            QueryField::Language => self.language_query.pop(),
139            QueryField::Plot => self.plot_query.pop(),
140        };
141    }
142
143    pub fn has_any_query(&self) -> bool {
144        vec![
145            &self.genre_query,
146            &self.title_query,
147            &self.cast_query,
148            &self.country_query,
149            &self.language_query,
150            &self.plot_query,
151        ]
152        .iter()
153        .any(|&q| is_valid_query_filter(q))
154    }
155
156    pub fn clear_all_queries(&mut self) {
157        self.genre_query.clear();
158        self.title_query.clear();
159        self.cast_query.clear();
160        self.country_query.clear();
161        self.language_query.clear();
162        self.plot_query.clear();
163    }
164}
165