use cloudflare::{Instance, CloudflareDnsType};
use reqwest::blocking::get;
use serde_derive::{Deserialize, Serialize};
use std::{fs, thread::{sleep}};
use chrono::{Utc, Duration};
use log::{info, warn, error, LevelFilter};
use systemd_journal_logger::JournalLog;
mod config;
mod cloudflare;

fn default_key() -> String {
    return "".to_string();
}

#[derive(Clone)]
struct ChangeTracker {
    created: u16,
    updated: u16,
    unchanged: u16,
    error: u16
}

impl ChangeTracker {
    fn new() -> ChangeTracker {
        ChangeTracker { 
            created: 0, 
            updated: 0, 
            unchanged: 0, 
            error: 0 
        }
    }

    fn print(&self, f: &str) {
        match f {
            "" => {
                self.print("simple");
            }
            "simple" => {
                println!("{} created", self.created);
                println!("{} updated", self.updated);
                println!("{} unchanged", self.unchanged);
                println!("{} errors", self.error);
            }
            &_ => {
                println!("unknown format pattern '{}', defaulting to 'simple'", f);
                self.print("simple");
            }
        }
    }
}

#[derive(Serialize, Deserialize)]
struct DnsEntry {
    name: String,
    type4: bool,
    type6: bool,
    interface: Option<String>,
}

impl DnsEntry {
    /// Updates a single DNS Entry
    /// 
    /// * `change4` : IPv4 DNS change tracker, used to print details about the results of the update run after it concludes
    /// * `change6` : Same as `change4` but for IPv6
    /// * `ips` : Enum of current IPv4 and IPv6 base, used to check against and update the DNS record
    /// * `agent` : Cloudflare Auth Agent, provides the needed Authentication headers for the API Calls
    /// * `zone_id` : Cloudfalre ID of the Zone this DNS entry resides in, needed for the API Calls 
    /// 
    /// * `return` : Returns true if the DNS Update failed due to an Error, otherwise returns false
    fn update(
            &self, 
            change4: &mut ChangeTracker, 
            change6: &mut ChangeTracker, 
            ips: &Ips,
            agent: &Instance, 
            zone_id: &String
        ) -> bool {
        let mut found4 = false;
        let mut found6 = false;

        // Loops over every Entry in the List fetched from the Cloudflare API
        // If the entry is in this List we need to update it, if not it needs to be created
        for cloudflare_entry in &agent.dns_entries {
            if cloudflare_entry.is_equal(&self.name) {
                // Update IPv4 Entry
                if cloudflare_entry.r#type == CloudflareDnsType::A && self.type4 {
                    found4 = true;

                    if cloudflare_entry.is_ip_new(&ips.ipv4) {
                        match agent.update_entry(cloudflare_entry, &ips.ipv4) {
                            Ok(success) => {
                                if success {
                                    change4.updated += 1;
                                } 
                                else {
                                    change4.error += 1;
                                }
                            },
                            Err(_e) => { return true } // if an error is detected any subsequent calls are likely to fail as well
                        };
                    } 
                    else {
                        change4.unchanged += 1;
                    }
                }
                // Update IPv6 Entry
                else if cloudflare_entry.r#type == CloudflareDnsType::AAAA && self.type6 {
                    found6 = true;
                    let ipv6 = ips.ipv6base.clone() + self.interface.as_ref().unwrap();

                    if cloudflare_entry.is_ip_new(&ipv6) {
                        match agent.update_entry(cloudflare_entry, &ipv6) {
                            Ok(success) => {
                                if success {
                                    change6.updated += 1
                                } 
                                else {
                                    change6.error += 1
                                }
                            },
                            Err(_e) => { return true } // if an error is detected any subsequent calls are likely to fail as well
                        };
                    } 
                    else {
                        change6.unchanged += 1;
                    }
                }
                // ignore otherwise
                else {}
            }
        }

        if !found4 && self.type4 {
            match agent.create_entry(zone_id, "A", &self.name, &ips.ipv4) {
                Ok(success) => {
                    if success {
                        change4.created += 1;
                    }
                    else {
                        change4.error += 1;
                    };
                },
                Err(_e) => { return true } // early return since if an error is detected any subsequent calls are likely to fail as well
            }
        }

        if !found6 && self.type6 {
            let ipv6 = ips.ipv6base.clone() + self.interface.as_ref().unwrap();
            match agent.create_entry(zone_id, "AAAA", &self.name, &ipv6) {
                Ok(success) => {
                    if success {
                        change6.created += 1;
                    }
                    else {
                        change6.error += 1;
                    };
                },
                Err(_e) => { return true } // if an error is detected any subsequent calls are likely to fail as well
            };
        }

        return false; // If this point is reached no error has been caught therefore returning false
    }
}

#[derive(Serialize, Deserialize)]
struct DnsZone {
    email: String,
    name: String,
    id: String,
    dns_entries: Vec<DnsEntry>,
}

impl DnsZone {
    /// Attempts to Update the DNS Entries of the Zone with a new IP
    /// 
    /// * `change4` : IPv4 DNS change tracker, used to print details about the results of the update run after it concludes
    /// * `change6` : Same as `change4` but for IPv6
    /// * `ips` : Enum of current IPv4 and IPv6 base, used to check against and update the DNS record
    /// * `key` : API Key needed to create the Auth Agent for the API
    /// 
    /// * `return` : Returns true if the DNS Updates failed due to an Error, false otherwise
    fn update(
        &self, 
        change4: &mut ChangeTracker, 
        change6: &mut ChangeTracker, 
        ips: &Ips, 
        key: &String 
    ) -> bool {
        let mut agent = Instance::new(key);

        match agent.load_entries(&self.email, &self.id) {
            Ok(_) => {
                let mut results = Vec::<bool>::new();

                for entry in &self.dns_entries {
                    let result = entry.update(change4, change6, &ips, &agent, &self.id);
                    results.append(&mut vec!(result));
                    if result {
                        break; // if one update fails all others are likely to fail as well
                    }
                }

                let result = results.contains(&true);

                return result;
            },
            Err(_e) => { return true }, // Early return since an Error likely means subsequent calls will also fail
        }
    }
}

#[derive(Serialize, Deserialize)]
struct DnsConfig {
    ipv6_interface: String,
    #[serde(default = "default_key")]
    api_key: String,
    zones: Vec<DnsZone>,
}

impl DnsConfig {
    fn new() -> DnsConfig {
        DnsConfig {
            ipv6_interface: "".to_string(),
            api_key: "".to_string(),
            zones: Vec::new(),
        }
    }

    fn load(&mut self) {
        let file_contents = match fs::read_to_string("config.json") {
            Ok(data) => data,
            Err(e) => panic!("{:#?}", e),
        };
        let config_parse: DnsConfig = match serde_json::from_str(&file_contents) {
            Ok(data) => data,
            Err(e) => panic!("{:#?}", e),
        };

        let key_file_contents = match fs::read_to_string("api-key.json") {
            Ok(data) => data,
            Err(e) => panic!("{:#?}", e),
        };
        let api_key_parse: serde_json::Value = match serde_json::from_str(&key_file_contents) {
            Ok(data) => data,
            Err(e) => panic!("{:#?}", e),
        };

        *self = config_parse;
        self.api_key = api_key_parse["api_key"].as_str().unwrap().to_owned();
    }
}

struct Ips {
    ipv4: String,
    ipv6base: String,
}

impl Ips {
    fn new() -> Ips {
        Ips {
            ipv4: "0.0.0.0".to_string(),
            ipv6base: ":".to_string(),
        }
    }

    /// Get the current IPv4 address and IPv6 prefix from Mullvad API
    ///
    /// Returns true if the get succeeded and false if it failed. 
    /// The IPv6 Prefix is generated by removing the IPv6 Interface from the fetched IPv6 address
    fn get(&mut self, ipv6_interface: &str) -> bool {
        let ipv4uri = "https://am.i.mullvad.net/ip";
        let ipv6uri = "https://ipv6.am.i.mullvad.net/ip";
        let mut ret;

        match get(ipv4uri) {
            Ok(data) => {
                if data.status() == 200 {
                    self.ipv4 = data.text().expect("0.0.0.0").trim_end().to_owned();
                    ret = true;
                }
                else {
                    ret = false;
                }
            },
            Err(_e) => {
                println!("Could not fetch IPv4");
                ret = false;

                return ret; // Early return since a fail on IPv4 means a likely fail on IPv6
            }
        }

        match get(ipv6uri) {
            Ok(data) => {
                if data.status() == 200 {
                    let ipv6 = match data.text() {
                        Ok(ip) => {ip},
                        Err(_) => {panic!("Expected IP, found none")},
                    };
                    let stripped = match ipv6.trim_end().strip_suffix(ipv6_interface) {
                        Some(string) => string.to_string(),
                        None => ":".to_string(),
                    };
                    self.ipv6base = stripped;
                    ret = true && ret; // Only set ret to true if previous ret is also true
                }
                else {
                    ret = false;
                }
            }
            Err(_e) => {
                println!("Could not fetch IPv6");
                ret = false;
            }
        }

        return ret;
    }
}

/// Loops over all DNS Entries in the config and calls an update on them
fn update_dns() {
    let mut config = DnsConfig::new();
    config.load();

    let mut ips = Ips::new();
    if ips.get(&config.ipv6_interface) {
        println!("Current IPv4: {}", ips.ipv4);
        println!("Current IPv6: {}{}", ips.ipv6base, &config.ipv6_interface);

        let mut change4 = ChangeTracker::new();

        let mut change6 = ChangeTracker::new();

        let mut update_results = Vec::<bool>::new();

        // Iterator does not work here
        for zone in &config.zones {
            let error = zone.update(&mut change4, &mut change6, &ips, &config.api_key);
            update_results.append(&mut vec!(error));
            if error {
                break; // if one update fails all others are likely to fail as well
            }   
        }

        if update_results.contains(&true) {
            println!("DNS Update failed due to Network Error")
        }
        else {
            println!("++++A Records+++");
            change4.print("simple");
            println!("++AAAA Records++");
            change6.print("simple")
        }

    }
}

fn main() {
    JournalLog::new().expect("Systemd-Logger crate error").install().expect("Systemd-Logger crate error");
    log::set_max_level(LevelFilter::Info);

    let mut now = Utc::now() - Duration::seconds(59);
    let mut current = now;

    let ifaces = config::InterfaceConfig::load().unwrap();
    let zone_cfgs= config::ZoneConfig::load().unwrap();
        now = Utc::now();
        if now >= current + Duration::seconds(60) {
            current = now;

            print!("\x1B[2J\x1B[1;1H");
            println!("Starting DNS Update at {} {}", now.format("%H:%M:%S"), now.timezone());
            update_dns();
        }
        else {
            sleep(std::time::Duration::from_millis(500));
        }
    }
}