mod cli;
mod coords;
mod current_weather;
mod current_weather_extractor;
mod current_weather_output;
mod current_weather_output_model;

mod current_weather_print_params;
mod data_format;
mod ifconfig;
mod ip_api;
mod open_meteo;
mod speed_unit;
mod temp_unit;

use billboard::{Alignment, Billboard};
use current_weather_print_params::CurrentWeatherPrintParams;
use data_format::DataFormat;
use std::process::exit;
use structopt::StructOpt;

use cli::Arguments;
use coords::Coordinates;

use current_weather_extractor::CurrentWeatherExtractor;
use ifconfig::extract_public_ip;
use ip_api::extract_coords_and_city;
use open_meteo::request_current_weather;

fn main() {
    let opts = Arguments::from_args();
    match opts {
        Arguments::CurrentWeather {
            latitude,
            longitude,
            all,
            is_day,
            temperature,
            temperature_unit,
            windspeed,
            speed_unit,
            winddirection,
            include_coords,
            include_city,
            mut format,
            clean,
            json,
        } => {
            if !all
                && !is_day
                && !temperature
                && !windspeed
                && !winddirection
                && !include_coords
                && !include_city
            {
                eprintln!("[ERROR] Provide at least one parameter to print, check --help");
                exit(1);
            }

            let coordinates: Coordinates;
            let city: Option<String>;

            if latitude.is_some() && longitude.is_some() {
                let latitude = latitude.unwrap();
                let longitude = longitude.unwrap();
                coordinates = Coordinates::new(latitude, longitude);

                if !coordinates.is_correct_latitude() {
                    eprintln!("[ERROR] {} is not a valid latitude", coordinates.latitude);
                    exit(1);
                } else if !coordinates.is_correct_longitude() {
                    eprintln!("[ERROR] {} is not a valid longitude", coordinates.longitude);
                    exit(1);
                }

                city = None;
            } else {
                let ip_result = extract_public_ip();
                let ip = ip_result.unwrap_or_else(|_| {
                    eprintln!("[ERROR] Could not extract public IP from ifconfig");
                    exit(1);
                });

                let coords_result = extract_coords_and_city(&ip);
                let coords = coords_result.unwrap_or_else(|_| {
                    eprintln!("[ERROR] Could not extract IP coordinates from ip_api");
                    exit(1);
                });

                let latitude = coords["lat"].as_f64().unwrap();
                let longitude = coords["lon"].as_f64().unwrap();
                coordinates = Coordinates::new(latitude, longitude);
                city = Some(coords["city"].as_str().unwrap().to_string());
            }

            let result = request_current_weather(&coordinates, &temperature_unit, &speed_unit);
            let current_weather = result.unwrap_or_else(|_| {
                eprintln!(
                    "[ERROR] Requesting CurrentWeather for Lat: {}, Lon: {}",
                    coordinates.latitude, coordinates.longitude
                );
                exit(1);
            });

            if clean {
                format = DataFormat::Clean;
            } else if json {
                format = DataFormat::JSON;
            }

            let print_params = CurrentWeatherPrintParams::new(
                all,
                is_day,
                temperature,
                temperature_unit,
                windspeed,
                speed_unit,
                winddirection,
                include_coords,
                include_city,
                format,
            );

            let current_weather_printer =
                CurrentWeatherExtractor::new(current_weather, print_params, coordinates, city);
            let output = current_weather_printer.extract_output();
            if DataFormat::Normal == current_weather_printer.params.format {
                Billboard::builder()
                    .text_alignment(Alignment::Left)
                    .box_alignment(Alignment::Left)
                    .build()
                    .eprint(output.to_string());
            } else {
                println!("{}", output.to_string());
            }
        }
    }
}