use std::collections::BTreeMap;
use std::fs::File;
use std::io;
use std::io::BufRead;
use std::net::Ipv4Addr;
use std::path::{Path, PathBuf};
use std::str::FromStr;
use std::sync::mpsc;
use std::time::{Duration, SystemTime};
use clap::Parser;
use pp::ping_result::PingResult;
use pp::ping_request::PingRequest;
use pp::manager::Manager;
use pp::{duration_to_string, SECONDS_BETWEEN_DISPLAY};
use pp::target_state::TargetState;
use std::{env, error::Error, ffi::OsString, process};
use color_eyre::owo_colors::OwoColorize;
use crossterm::style::Stylize;
use log::debug;
use pp::app_settings::AppSettings;

struct PPState {}

impl PPState {
    pub fn get_default_targets() -> BTreeMap<String, TargetState> {
        let mut working = BTreeMap::new();
        working.insert("Localhost".to_string(),
                       TargetState {
                           name: "Localhost".to_string(),
                           target: Ipv4Addr::new(127, 0, 0, 1),
                           ..TargetState::default()
                       },
        );

        working.insert("Home Gateway".to_string(),
                       TargetState {
                           name: "Home Gateway".to_string(),
                           target: Ipv4Addr::new(172, 24, 0, 1),
                           ..TargetState::default()
                       },
        );

        working.insert("1111 DNS".to_string(),
                       TargetState {
                           name: "1111 DNS".to_string(),
                           target: Ipv4Addr::new(1, 1, 1, 1),
                           ..TargetState::default()
                       },
        );
        working.insert("Google DNS".to_string(),
                       TargetState {
                           name: "Google DNS".to_string(),
                           target: Ipv4Addr::new(8, 8, 8, 8),
                           ..TargetState::default()
                       },
        );

        working.insert("Site IP 1".to_string(),
                       TargetState {
                           name: "Site IP 1".to_string(),
                           target: Ipv4Addr::new(216, 121, 247, 231),
                           ..TargetState::default()
                       },
        );
        working.insert("Site IP 2".to_string(),
                       TargetState {
                           name: "Site IP 2".to_string(),
                           target: Ipv4Addr::new(216, 234, 202, 122),
                           ..TargetState::default()
                       },
        );
        working.insert("Site IP 3".to_string(),
                       TargetState {
                           name: "Site IP 3".to_string(),
                           target: Ipv4Addr::new(24, 143, 184, 98),
                           ..TargetState::default()
                       },
        );
        working
    }

    pub fn build_targets_from_file(filename: Option<PathBuf>) -> BTreeMap<String, TargetState> {
        // PPState::get_default_targets();
        if let Some(file) = filename {
            let mut working = BTreeMap::new();
            if !&file.exists() {
                debug!("Cant load hosts from {:?}.  Using default host list.", file.clone().as_os_str());
                // use
                PPState::get_default_targets()
            } else {
                debug!("LOADING HOSTS FROM  {:?}", file.to_str());
                let file = File::open(file);
                let mut rdr = csv::Reader::from_reader(file.unwrap());
                for result in rdr.records() {
                    let record = result.unwrap();
                    working.insert(record[1].to_string(),
                                   TargetState {
                                       name: record[1].to_string(),
                                       target: Ipv4Addr::from_str(&record[0]).unwrap(),
                                       alive: false,
                                       last_alive_change: SystemTime::now(),
                                       last_rtt: 0,
                                   });
                }
                working
            }
        } else {
            PPState::get_default_targets()
        }
    }
}
    fn ips_from_state(to_read_from: BTreeMap<String, TargetState>) -> Vec<Ipv4Addr> {
        let mut working: Vec<Ipv4Addr> = vec![];
        for current in to_read_from {
            working.push(current.1.target);
        }
        working
    }

    /// Simple program to greet a person


    fn main() {
        // Get App Settings
        let settings = AppSettings::parse();

        print!("Prep to load targets...");
        let file_to_check = match settings.ping_host_file {
            None => {
                PathBuf::from("./hosts.txt")
            }
            Some(actual) => {
                actual
            }
        };
        let mut targets = PPState::build_targets_from_file(Some(file_to_check));

        // channel to send requests to ping
        let (ping_response_sender, ping_response_listener) = mpsc::channel::<PingResult>();

        println!("Setting up requests for {} hosts.", targets.len());
        Manager::spawn_manager_thread(ips_from_state(targets.clone()), ping_response_sender.clone());

        let mut display_loop_start = SystemTime::now();
        let mut duration_since_last_loop = SystemTime::now().duration_since(display_loop_start).unwrap();
        loop {
            let now = SystemTime::now();
            if let Ok(response) = ping_response_listener.recv_timeout(Duration::from_millis(100)) {
                let local_targets = targets.clone();
                for (_, (name, current_state)) in local_targets.iter().enumerate() {
                    if current_state.target == response.target {
                        let last_alive_change = if response.success == current_state.alive {
                            current_state.last_alive_change
                        } else {
                            SystemTime::now()
                        };

                        let new_state = TargetState {
                            name: current_state.name.clone(),
                            target: current_state.target,
                            alive: response.success,
                            last_rtt: response.rtt,
                            last_alive_change,
                        };
                        targets.insert(name.clone(), new_state);
                    }
                }
            }
            duration_since_last_loop = now
                .duration_since(display_loop_start)
                .expect("unable to figure out how long ago we displayed stuff");
            if duration_since_last_loop.as_secs() > SECONDS_BETWEEN_DISPLAY as u64 {
                println!("DISPLAY LOOP");
                println!("Host \t\t\t\t\t | Alive \t | RTT \t\t");
                for (name, current_result) in targets.clone() {
                    let time_since_last_change = now
                        .duration_since(current_result.last_alive_change)
                        .unwrap_or(Duration::from_secs(0));
                    let mut target_string = format!("{} ({})", name, current_result.target);
                    while target_string.len() < 34 {
                        target_string.push(' ');
                        // target_string = format!("{} ", target_string);
                    }

                    target_string = if current_result.alive {
                        target_string.green().to_string()
                    } else {
                        target_string.red().to_string()
                    };

                    println!("{} \t | {} \t | {}\t | Changed {} ago",
                             target_string,
                             current_result.alive,
                             current_result.last_rtt,
                             duration_to_string(time_since_last_change)
                    );
                }
                display_loop_start = now;
            }
        }
    }