From 1c5737924ba2c0cdcafabda04debf39cfbdf2288 Mon Sep 17 00:00:00 2001
From: Philip <philipkristoffersen@gmail.com>
Date: Sun, 12 Sep 2021 06:56:21 +0200
Subject: [PATCH] Implement cached serach

---
 .gitignore           |  3 ++-
 src/cached_search.rs | 61 ++++++++++++++++++++++++++++++++++++++++++++
 src/main.rs          | 36 ++++++++++++--------------
 3 files changed, 79 insertions(+), 21 deletions(-)
 create mode 100644 src/cached_search.rs

diff --git a/.gitignore b/.gitignore
index afcd4d6..d516459 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,2 +1,3 @@
 /target
-auth_key.txt
\ No newline at end of file
+auth_key.txt
+cache.json
\ No newline at end of file
diff --git a/src/cached_search.rs b/src/cached_search.rs
new file mode 100644
index 0000000..e620c87
--- /dev/null
+++ b/src/cached_search.rs
@@ -0,0 +1,61 @@
+use std::{collections::HashMap, fs::File, io::Write, path::Path};
+
+type SearchMap = HashMap<u32, usize>;
+
+pub struct CachedSearch<'a> {
+    search_map: SearchMap,
+    client: &'a steamgriddb_api::Client,
+}
+
+impl<'a> CachedSearch<'a> {
+    pub fn new(client: &steamgriddb_api::Client) -> CachedSearch {
+        CachedSearch {
+            search_map: get_search_map(),
+            client,
+        }
+    }
+
+    pub fn save(&self) {
+        save_search_map(&self.search_map);
+    }
+
+    pub async fn search(
+        &mut self,
+        app_id: u32,
+        query: &str,
+    ) -> Result<Option<usize>, Box<dyn std::error::Error>> {
+        
+        let cached_result = self.search_map.get(&app_id);
+        if let Some(result) = cached_result {
+            return Ok(Some(*result));
+        }
+
+        let search = self.client.search(query).await?;
+        if search.is_empty() {
+            return Ok(None);
+        }
+        let first_item = &search[0];
+        let assumed_id = first_item.id;
+        self.search_map.insert(app_id, assumed_id);
+
+        Ok(Some(assumed_id))
+    }
+}
+
+fn get_search_map() -> SearchMap {
+    let path = Path::new("cache.json");
+    if path.exists() {
+        let string = std::fs::read_to_string(path).unwrap();
+        let search_map =
+            serde_json::from_str::<SearchMap>(&string).expect("Failed to parse cache.json");
+        search_map
+    } else {
+        SearchMap::new()
+    }
+}
+
+fn save_search_map(search_map: &SearchMap) {
+    let string = serde_json::to_string(search_map).unwrap();
+    let mut file = File::create("cache.json").unwrap();
+    file.write_all(string.as_bytes()).unwrap();
+}
diff --git a/src/main.rs b/src/main.rs
index 94c8a18..8215253 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -6,19 +6,24 @@ use std::{
     io::Write,
     path::Path,
 };
+mod cached_search;
 mod egs;
 use egs::{get_egs_manifests, ManifestItem};
 use std::error::Error;
 use steam_shortcuts_util::{
     parse_shortcuts, shortcut::ShortcutOwned, shortcuts_to_bytes, Shortcut,
 };
-use steamgriddb_api::{Client, query_parameters::{GridQueryParameters, HeroQueryParameters}, search::SearchResult};
+use steamgriddb_api::{search::SearchResult, Client};
+
+use crate::cached_search::CachedSearch;
 
 pub struct ShortcutInfo {
     pub path: String,
     pub shortcuts: Vec<ShortcutOwned>,
 }
 
+
+
 fn get_shortcuts_for_user(user: &SteamUsersInfo) -> ShortcutInfo {
     let mut shortcuts = vec![];
     let mut new_path = user.shortcut_path.clone();
@@ -55,8 +60,10 @@ fn get_shortcuts_for_user(user: &SteamUsersInfo) -> ShortcutInfo {
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn Error>> {
+    
     let auth_key = std::fs::read_to_string("auth_key.txt")?;
     let client = steamgriddb_api::Client::new(auth_key);
+    let mut search = CachedSearch::new(&client);
 
     let egs_manifests = get_egs_manifests()?;
     let egs_shortcuts: Vec<ShortcutOwned> =
@@ -97,12 +104,14 @@ async fn main() -> Result<(), Box<dyn Error>> {
         let mut search_results = HashMap::new();
         for s in shortcuts_to_search_for {
             println!("Searching for {}", s.app_name);
-            let search = search_for_shortcut(&client, s.app_name).await;
+            let search = search.search(s.app_id,s.app_name).await?;
             if let Some(search) = search {
                 search_results.insert(s.app_id, search);
             }
         }
 
+     
+
         let types = vec![ImageType::Logo, ImageType::Hero, ImageType::Grid];
         for image_type in types {
             let mut images_needed = shortcuts
@@ -112,27 +121,12 @@ async fn main() -> Result<(), Box<dyn Error>> {
             let image_ids: Vec<usize> = images_needed
                 .clone()
                 .filter_map(|s| search_results.get(&s.app_id))
-                .map(|search| search.id)
+                .map(|search| *search)
                 .collect();
 
-
-            let animation_order= vec![
-                    steamgriddb_api::query_parameters::AnimtionType::Animated,
-                    steamgriddb_api::query_parameters::AnimtionType::Static,
-                ];
-            let hero_parameters = HeroQueryParameters {
-                types: Some(&animation_order),
-                ..HeroQueryParameters::default()
-            };
-            let grid_parameters = GridQueryParameters {
-                types: Some(&animation_order),
-                ..GridQueryParameters::default()
-            };
             let query_type = match image_type {
-                ImageType::Hero => {
-                    steamgriddb_api::query_parameters::QueryType::Hero(Some(hero_parameters))
-                }
-                ImageType::Grid => steamgriddb_api::query_parameters::QueryType::Grid(Some(grid_parameters)),
+                ImageType::Hero => steamgriddb_api::query_parameters::QueryType::Hero(None),
+                ImageType::Grid => steamgriddb_api::query_parameters::QueryType::Grid(None),
                 ImageType::Logo => steamgriddb_api::query_parameters::QueryType::Logo(None),
             };
 
@@ -165,6 +159,8 @@ async fn main() -> Result<(), Box<dyn Error>> {
         }
     }
 
+    search.save();
+
     Ok(())
 }