1 files changed, 138 insertions, 43 deletions

diff --git a/src/main.rs b/src/main.rs
index 3d741ae..057588b 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -29,59 +29,154 @@ SOFTWARE.
 
 */
 
-use clap::{Cli, Command, Subcommand}; 
-use termimage;
+use std::fs::{self, File};
+use std::path::PathBuf;
+
+use clap::{Parser, Subcommand}; 
+use termimage::Options;
 
 mod parser;
-use parser::{get_config, Config}; 
+mod shared;
+
+use parser::{get_config, parse_weather, generate_config, Config}; 
+use shared::WeatherData; 
+
+#[derive(Parser)]
+#[command(name = "wfetch")]
+#[command(about = "Weather fetch tool")]
+struct Cli {
+    #[command(subcommand)]
+    command: Option<Commands>,
+}
 
-// use crate::configmanager::{Config, handle_config};
 #[derive(Subcommand)]
 enum Commands {
-  Config, 
-  Fetch,
-  Clean, 
-  Help,
-  Today, 
-  Tomorrow, 
-  RebuildCache 
+    Config, 
+    Fetch,
+    Clean, 
+    Today, 
+    Tomorrow, 
+    RebuildCache,
+    CheckCfg
 }
-fn process_config() -> Result<Config, Box<dyn std::error::Error>> {
-    let cfg: Config = get_config().unwrap(); 
 
-    Ok(cfg); 
+fn process_config() -> Result<(), Box<dyn std::error::Error>> {
+    let _cfg: Config = get_config()?; 
+    println!("Config is valid");
+    Ok(()) 
 }
 
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-
-    let config = process_config()?;
-    let cli: Cli = Cli::parse();
+fn parse_cached() -> Result<WeatherData, Box<dyn std::error::Error>> { 
+    let home = std::env::var("HOME")?;
+    let cache_path = format!("{}/.cache/WeatherFetch/weather.json", home);
+    
+    if !PathBuf::from(&cache_path).exists() {
+        return Err("Cache file not found".into());
+    }
+    
+    let cache_data = fs::read_to_string(&cache_path)?;
+    let weather_data: WeatherData = serde_json::from_str(&cache_data)?;
+    Ok(weather_data)
+}
 
-    match cli.command {
-        Commands::Config => {
-            println!("Testing config."); // Заглушкии 
-            // let test_result: bool = handle_config(config); 
-        }
-        Commands::Fetch => {
-            println!("Fetching weather data.");
-            
-        }
-        Commands::Clean => {
-            println!("Clean");
-        }
-        Commands::Help => {
-            println!("Help");
-        }
-        Commands::Today => {
-            println!("Today");
-        }
-        Commands::Tomorrow => {
-            println!("Tomorrow");
-        }
-        Commands::RebuildCache => {
-        }
-    } 
+fn print_help() -> Result<(), Box<dyn std::error::Error>> {
+    println!("Help command");
+    println!("Usage: wfetch <command>");
+    println!("Commands:");
+    println!("  config      - Check config");
+    println!("  fetch       - Fetch weather-data");
+    println!("  clean       - Clean cache");
+    println!("  help        - Print help");
+    println!("  today       - Print today weather");
+    println!("  tomorrow    - Print tomorrow weather");
+    println!("  rebuild-cache - Rebuild cache");
+    Ok(())
+}
 
-  }
+fn clean_cache() -> Result<(), Box<dyn std::error::Error>> {
+    let home = std::env::var("HOME")?;
+    let cache_path = format!("{}/.cache/WeatherFetch/weather.json", home);
+    if PathBuf::from(&cache_path).exists() {
+        fs::remove_file(&cache_path)?;
+        println!("Cache cleaned successfully");
+    } else {
+        println!("Cache file not found");
+    }
+    Ok(())
+}
 
+fn rebuild_cache() -> Result<(), Box<dyn std::error::Error>> {
+    let rt = tokio::runtime::Runtime::new()?;
+    let weather_data = rt.block_on(parse_weather())?;
+    
+    let home = std::env::var("HOME")?;
+    let cache_dir = format!("{}/.cache/WeatherFetch", home);
+    fs::create_dir_all(&cache_dir)?;
+    
+    let cache_path = format!("{}/weather.json", cache_dir);
+    let json_data = serde_json::to_string_pretty(&weather_data)?;
+    fs::write(&cache_path, json_data)?;
+    
+    println!("Cache rebuilt successfully");
+    Ok(())
+}
 
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let cli = Cli::parse();
+    
+    match cli.command {
+        Some(Commands::Config) => {
+            println!("Config checker command");
+            let home = std::env::var("HOME")?;
+            let config_path = format!("{}/.config/WeatherFetch/Config.toml", home);
+            if File::open(&config_path).is_err() {
+                generate_config()?; 
+                println!("Config generated successfully"); 
+            } else {
+                process_config()?;
+                println!("Config already exists and is valid."); 
+            }
+            Ok(())
+        },
+        Some(Commands::Fetch) => {
+            println!("Fetch weather-data command");
+            let rt = tokio::runtime::Runtime::new()?;
+            let weather_data = rt.block_on(parse_weather())?;
+            let home = std::env::var("HOME")?; 
+            println!("Weather data fetched to: {}", format!("{}/.cache/WeatherFetch", home));
+            Ok(())
+        },
+        Some(Commands::Clean) => {
+            println!("Clean cache command");
+            clean_cache()?;
+            Ok(())
+        },
+        Some(Commands::Today) => {
+            println!("Today weather command");
+            Ok(())
+        },
+        Some(Commands::Tomorrow) => {
+            println!("Tomorrow weather command");
+            Ok(())
+        },
+        Some(Commands::RebuildCache) => {
+            println!("Rebuild cache command");
+            rebuild_cache()?;
+            Ok(())
+        },
+        Some(Commands::CheckCfg) => {
+            println!("Validating cfg..."); 
+            let home = std::env::var("HOME")?;
+            let config_path = format!("{}/.config/WeatherFetch/Config.toml", home);
+            if File::open(&config_path).is_ok() {
+                process_config()?; 
+            } else {
+                println!("Config file not found, try `wfetch config`, its will generate default cfg.");
+            }
+            Ok(())
+        }
+        None => {
+            print_help()
+        },
+    }
+} 
\ No newline at end of file