use crate::whois::whois_base::{
    NameServer, RegexQuery, Registrant, RegistrantType, Whois, WhoisData,
};
use whois_rust::{WhoIs, WhoIsLookupOptions};

struct Eligibility {
    e_type: Option<String>,
    e_name: Option<String>,
    e_id: Option<String>,
    r_id: Option<String>,
}

impl Eligibility {
    fn new() -> Eligibility {
        Eligibility {
            e_id: Some(String::new()),
            e_name: Some(String::new()),
            e_type: Some(String::new()),
            r_id: Some(String::new()),
        }
    }
}

pub struct _Whois {
    base: WhoisData,
    eligibility: Eligibility,
    modified: String,
}

impl Whois for _Whois {
    fn new() -> Self {
        _Whois {
            base: WhoisData::new(),
            eligibility: Eligibility::new(),
            modified: String::new(),
        }
    }
    fn to_vec(&self) -> Vec<String> {
        let mut ret_vec: Vec<String> = vec![];
        let mut registrar = String::from("Registrar: ");
        registrar.push_str(&self.base.registrar.clone().unwrap());
        ret_vec.push(registrar);

        let mut last_modified = String::from("Last Modified: ");
        last_modified.push_str(&self.modified.clone());
        ret_vec.push(last_modified);

        let mut domain_status = String::from("Status: ");
        domain_status.push_str(&self.base.domain_status.clone().unwrap());
        ret_vec.push(domain_status);

        let mut dnssec = String::from("DNSSEC: ");
        dnssec.push_str(&self.base.dnssec.clone().unwrap());
        ret_vec.push(dnssec);

        let mut registrant_type = String::new();
        for registrant in &self.base.registrant.clone().unwrap() {
            match registrant.rtype {
                RegistrantType::Admin => {
                    registrant_type.push_str("Admin ");
                }
                RegistrantType::Billing => {
                    registrant_type.push_str("Billing ");
                }
                RegistrantType::Tech => {
                    registrant_type.push_str("Tech ");
                }
                RegistrantType::Registrant => {
                    registrant_type.push_str("Registrant ");
                }
            }
            let mut name = registrant_type.clone();
            name.push_str("Name: ");
            name.push_str(&registrant.name);
            ret_vec.push(name);

            let mut org = registrant_type.clone();
            org.push_str("Organisation: ");
            org.push_str(&registrant.org);
            ret_vec.push(org);

            let mut email = registrant_type.clone();
            email.push_str("Email: ");
            email.push_str(&registrant.email);
            ret_vec.push(email);
        }

        for nameserver in &self.base.nameservers.clone().unwrap() {
            let mut tmp = String::from("Nameserver: ");
            tmp.push_str(&nameserver.host);
            ret_vec.push(tmp);
        }

        let mut eligibility_name = String::from("Eligibility Name: ");
        eligibility_name.push_str(&self.eligibility.e_name.clone().unwrap());
        ret_vec.push(eligibility_name);

        let mut eligibility_type = String::from("Eligibility Type: ");
        eligibility_type.push_str(&self.eligibility.e_type.clone().unwrap());
        ret_vec.push(eligibility_type);

        let mut eligibility_id = String::from("Eligibility ID: ");
        eligibility_id.push_str(&self.eligibility.e_id.clone().unwrap());
        ret_vec.push(eligibility_id);

        let mut registrant_id = String::from("Registrant ID: ");
        registrant_id.push_str(&self.eligibility.r_id.clone().unwrap());
        ret_vec.push(registrant_id);

        return ret_vec;
    }
    fn lookup(&mut self, domain: String) -> Vec<String> {
        let whois = WhoIs::from_path("servers.json").unwrap();
        let result: String = whois
            .lookup(WhoIsLookupOptions::from_string(domain).unwrap())
            .unwrap();
        let registrar_regex =
            RegexQuery::new(String::from(r"(?i)(.*registrar:|registrar *name:)(.*)"));
        let last_modified_regex = RegexQuery::new(String::from(r"(?i)(.*last modified:)(.*)"));
        let domain_status_regex =
            RegexQuery::new(String::from(r"(?i)(.*domain status:|.*status:)(.* )"));
        // TODO: Capture the registrant info for each type
        let registrant_name_regex = RegexQuery::new(String::from(r"(?i)(registrant.*name:)(.*)"));
        let registrant_org_regex =
            RegexQuery::new(String::from(r"(?i)(registrant org.*:|registrant:)(.*)"));
        let registrant_email_regex = RegexQuery::new(String::from(r"(?i)(registrant email:)(.*)"));
        let nameserver_regex =
            RegexQuery::new(String::from(r"(?i)(nameservers*:|name servers*:)(.*)"));
        let dnssec_regex = RegexQuery::new(String::from(r"(?i)(.*dnssec:)(.*)"));
        let eligebility_name_regex =
            RegexQuery::new(String::from(r"(?i)(.*eligibility name:)(.*)"));
        let eligebility_type_regex =
            RegexQuery::new(String::from(r"(?i)(.*eligibility type:)(.*)"));
        let eligebility_id_regex = RegexQuery::new(String::from(r"(?i)(.*eligibility id:)(.*)"));
        let registrant_id_regex = RegexQuery::new(String::from(r"(?i)(.*registrant id:)(.*)"));

        let registrar = WhoisData::return_regex(registrar_regex.get_matches(&result), 0);
        let last_modified = WhoisData::return_regex(last_modified_regex.get_matches(&result), 0);
        let domain_status = WhoisData::return_regex(domain_status_regex.get_matches(&result), 0);
        let reg_name = WhoisData::return_regex(registrant_name_regex.get_matches(&result), 0);
        let reg_org = WhoisData::return_regex(registrant_org_regex.get_matches(&result), 0);
        let reg_email = WhoisData::return_regex(registrant_email_regex.get_matches(&result), 0);

        let mut nameservers = vec![];
        for nameserver in nameserver_regex.get_matches(&result) {
            nameservers.push(NameServer::new(nameserver));
        }
        let mut dnssec = dnssec_regex.get_matches(&result);
        if dnssec.len() == 0 {
            dnssec = vec![String::from("Failed to get DNSSEC")];
        }
        let eligebility_name =
            WhoisData::return_regex(eligebility_name_regex.get_matches(&result), 0);
        let eligebility_type =
            WhoisData::return_regex(eligebility_type_regex.get_matches(&result), 0);
        let eligebility_id = WhoisData::return_regex(eligebility_id_regex.get_matches(&result), 0);
        let registrant_id = WhoisData::return_regex(registrant_id_regex.get_matches(&result), 0);

        // println!("{:?}", registrar[0]);
        self.base.domain_status = Some(domain_status.clone());
        self.base.registrant = Some(vec![Registrant::new(
            reg_name.clone(),
            reg_org.clone(),
            reg_email,
            RegistrantType::Registrant,
        )]);
        self.base.nameservers = Some(nameservers);
        self.base.dnssec = Some(dnssec[0].clone());
        self.base.registrar = Some(registrar.clone());
        self.eligibility.e_name = Some(eligebility_name.clone());
        self.eligibility.e_type = Some(eligebility_type.clone());
        self.eligibility.e_id = Some(eligebility_id.clone());
        self.eligibility.r_id = Some(registrant_id.clone());
        self.modified = last_modified;
        self.to_vec()
    }
}