Factor searching into its own class

src/search.rs

@@ -0,0 +1,182 @@
+use std::ops::Deref;
+
+use crate::util::clamp;
+use eframe::egui;
+use serde::Deserialize;
+use tokio::sync::mpsc;
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct Root {
+    pub results: Vec<FileEntry>,
+    pub metadata: Metadata,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct Metadata {
+    pub page: usize,
+    pub total_pages: usize,
+    pub page_size: usize,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct FileEntry {
+    pub name: String,
+    pub ext: String,
+    #[allow(dead_code)]
+    pub path: String,
+    pub url: String,
+    pub size: i64,
+    pub preview: String,
+}
+
+pub struct SearchContext {
+    pub is_searching: bool,
+    pub server_url: String,
+    pub query: String,
+    search_rx: Option<mpsc::Receiver<Result<(Vec<FileEntry>, Metadata), String>>>,
+    pub search_results: Vec<FileEntry>,
+    pub page: usize,
+    pub per_page: usize,
+    pub total_pages: usize,
+    pub total_results: usize,
+}
+
+impl Default for SearchContext {
+    fn default() -> Self {
+        SearchContext {
+            is_searching: false,
+            server_url: "https://stuff.catgirls.fish/search".to_string(),
+            query: "".to_string(),
+            search_rx: None,
+            search_results: vec![],
+            page: 1,
+            per_page: 25,
+            total_pages: 0,
+            total_results: 0,
+        }
+    }
+}
+
+impl SearchContext {
+    pub fn next_page(&mut self, ctx: &egui::Context) {
+        let skip = self.page == self.total_pages;
+        self.page = clamp(self.page + 1, 1, self.total_pages);
+        if !skip {
+            self.start_search();
+            ctx.forget_all_images();
+        }
+    }
+
+    pub fn previous_page(&mut self, ctx: &egui::Context) {
+        let skip = self.page == 1;
+        self.page = clamp(self.page - 1, 1, self.total_pages);
+        if !skip {
+            self.start_search();
+            ctx.forget_all_images();
+        }
+    }
+
+    pub fn start_search(&mut self) -> String {
+        let page = self.page.clone();
+        let page_size = self.per_page.clone();
+        let query = self.query.clone();
+        let url = self.server_url.clone();
+        let (tx, rx) = mpsc::channel::<Result<(Vec<FileEntry>, Metadata), String>>(1);
+
+        self.search_rx = Some(rx);
+        self.is_searching = true;
+        self.search_results.clear();
+        self.page = 0;
+        self.total_pages = 0;
+        self.total_results = 0;
+
+        tokio::spawn(async move {
+            let res = search_files(url, query, page, page_size).await;
+            let _ = tx.send(res).await;
+        });
+
+        "Searching...".to_string()
+    }
+
+    pub fn process_channel(&mut self, ctx: &egui::Context) -> (String, bool) {
+        let done = false;
+        let mut return_str = "".to_string();
+        if self.search_rx.is_some() {
+            let mut clear_rx = false;
+            if let Some(rx) = self.search_rx.as_mut() {
+                match rx.try_recv() {
+                    Ok(Ok(results)) => {
+                        // Ok recv, ok results
+                        self.search_results = results.0.clone();
+                        return_str = "Ready!".to_string();
+                        self.total_pages = results.1.total_pages;
+                        self.page = results.1.page;
+                        self.per_page = results.1.page_size;
+                        self.is_searching = false;
+                        clear_rx = true;
+                    }
+                    Ok(Err(e)) => {
+                        // Ok recv, err results
+                        return_str = format!("Search failed: {}", e);
+                        self.is_searching = false;
+                        clear_rx = true;
+                    }
+                    Err(mpsc::error::TryRecvError::Empty) => {
+                        ctx.request_repaint();
+                    }
+                    Err(mpsc::error::TryRecvError::Disconnected) => {
+                        return_str = "Search thread ended unexpectedly".to_string();
+                        self.is_searching = false;
+                        clear_rx = true;
+                    }
+                }
+            }
+            if clear_rx {
+                self.search_rx = None;
+            }
+        }
+
+        (return_str, done)
+    }
+}
+
+pub async fn search_files(
+    url: String,
+    query: String,
+    page: usize,
+    page_size: usize,
+) -> Result<(Vec<FileEntry>, Metadata), String> {
+    let full_url = format!("{}?q={}&p={}&s={}", url, query, page, page_size);
+
+    let client = match reqwest::Client::builder()
+        .user_agent(
+            "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:141.0) Gecko/20100101 Firefox/141.0",
+        )
+        .danger_accept_invalid_certs(true)
+        .build()
+    {
+        Ok(client) => client,
+        Err(e) => return Err(format!("Failed to create the client: {}", e)),
+    };
+
+    let res = client.get(full_url).send().await;
+    let response = match res {
+        Ok(response_ok) => response_ok,
+        Err(e) => return Err(format!("Failed to download the file: {}", e)),
+    };
+    if response.status() != reqwest::StatusCode::OK {
+        return Err(format!(
+            "Failed to download the file: {}",
+            response.status()
+        ));
+    }
+
+    let results = match response.json::<Root>().await {
+        Ok(r) => r,
+        Err(e) => {
+            return Err(format!("Failed to deserialize results data: {}", e));
+        }
+    };
+
+    Ok((results.results, results.metadata))
+}