use std::cmp::Ordering;
use std::net::IpAddr;
use std::net::Ipv4Addr;

use super::opnsense::{OPNsense, StaticMap};
use crate::infra::maybe_string::MaybeString;
use crate::modules::opnsense::NumberOption;
use crate::modules::opnsense::Range;
use yaserde_derive::{YaDeserialize, YaSerialize};

pub struct DhcpConfig<'a> {
    opnsense: &'a mut OPNsense,
}

#[derive(Debug)]
pub enum DhcpError {
    InvalidMacAddress(String),
    InvalidIpAddress(String),
    IpAddressAlreadyMapped(String),
    MacAddressAlreadyMapped(String),
    IpAddressOutOfRange(String),
}

impl std::fmt::Display for DhcpError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            DhcpError::InvalidMacAddress(mac) => write!(f, "Invalid MAC address format: {}", mac),
            DhcpError::InvalidIpAddress(ip) => write!(f, "Invalid IP address format: {}", ip),
            DhcpError::IpAddressAlreadyMapped(ip) => {
                write!(f, "IP address {} is already mapped", ip)
            }
            DhcpError::MacAddressAlreadyMapped(mac) => {
                write!(f, "MAC address {} is already mapped", mac)
            }
            DhcpError::IpAddressOutOfRange(ip) => {
                write!(f, "IP address {} is out of interface range", ip)
            }
        }
    }
}

impl std::error::Error for DhcpError {}

impl<'a> DhcpConfig<'a> {
    pub fn new(opnsense: &'a mut OPNsense) -> Self {
        Self { opnsense }
    }

    pub fn add_static_mapping(
        &mut self,
        mac: String,
        ipaddr: Ipv4Addr,
        hostname: String,
    ) -> Result<(), DhcpError> {
        let range: Range = todo!();
        if !Self::is_valid_mac(&mac) {
            return Err(DhcpError::InvalidMacAddress(mac));
        }

        // if !Self::is_ip_in_range(&ipaddr, range) {
        //     return Err(DhcpError::IpAddressOutOfRange(ipaddr));
        // }

        let existing_mappings = &self.opnsense.dhcpd.lan.staticmaps;

        // TODO
        // if existing_mappings.iter().any(|m| m.ipaddr == ipaddr) {
        //     return Err(DhcpError::IpAddressAlreadyMapped(ipaddr));
        // }

        // if existing_mappings.iter().any(|m| m.mac == mac) {
        //     return Err(DhcpError::MacAddressAlreadyMapped(mac));
        // }

        // let static_map = StaticMap {
        //     mac,
        //     ipaddr,
        //     hostname,
        //     descr: Default::default(),
        //     winsserver: Default::default(),
        //     dnsserver: Default::default(),
        //     ntpserver: Default::default(),
        // };

        // self.opnsense.dhcpd.lan.staticmaps.push(static_map);
        Ok(())
    }

    pub fn get_static_mappings(&self) -> &[StaticMap] {
        &self.opnsense.dhcpd.lan.staticmaps
    }

    fn is_valid_mac(mac: &str) -> bool {
        let parts: Vec<&str> = mac.split(':').collect();
        if parts.len() != 6 {
            return false;
        }

        parts
            .iter()
            .all(|part| part.len() == 2 && part.chars().all(|c| c.is_ascii_hexdigit()))
    }

    fn is_ip_in_range(ip: &Ipv4Addr, range: Range) -> bool {
        let range_start = range
            .from
            .parse::<Ipv4Addr>()
            .expect("Invalid DHCP range start");
        let range_end = range.to.parse::<Ipv4Addr>().expect("Invalid DHCP range to");

        let start_compare = range_start.cmp(ip);
        let end_compare = range_end.cmp(ip);

        if (Ordering::Less == start_compare || Ordering::Equal == start_compare)
            && (Ordering::Greater == end_compare || Ordering::Equal == end_compare)
        {
            return true;
        } else {
            return false;
        }
    }
}

#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(rename = "dhcpd")]
pub struct Dhcpd {
    #[yaserde(rename = "lan")]
    pub lan: DhcpInterface,
}

#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
pub struct DhcpInterface {
    pub enable: i32,
    pub gateway: String,
    pub domain: String,
    #[yaserde(rename = "ddnsdomainalgorithm")]
    pub ddns_domain_algorithm: String,
    #[yaserde(rename = "numberoptions")]
    pub number_options: Vec<NumberOption>,
    #[yaserde(rename = "range")]
    pub range: Range,
    pub winsserver: MaybeString,
    pub dnsserver: MaybeString,
    pub ntpserver: MaybeString,
    #[yaserde(rename = "staticmap")]
    pub staticmaps: Vec<StaticMap>,
    pub pool: MaybeString,
}

#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
pub struct DhcpRange {
    #[yaserde(rename = "from")]
    pub from: String,
    #[yaserde(rename = "to")]
    pub to: String,
}

#[cfg(test)]
mod test {
    use std::net::Ipv4Addr;
    use crate::infra::yaserde::to_xml_str;

    use super::*;
    use pretty_assertions::assert_eq;

    #[test]
    fn dhcpd_should_deserialize_serialize_identical() {
        let dhcpd: Dhcpd =
            yaserde::de::from_str(SERIALIZED_DHCPD).expect("Deserialize Dhcpd failed");

        assert_eq!(
            to_xml_str(&dhcpd).expect("Serialize Dhcpd failed"),
            SERIALIZED_DHCPD
        );
    }

    const SERIALIZED_DHCPD: &str = "<?xml version=\"1.0\"?>
<dhcpd>
  <lan>
    <enable>1</enable>
    <gateway>192.168.20.1</gateway>
    <domain>somedomain.yourlocal.mcd</domain>
    <ddnsdomainalgorithm>hmac-md5</ddnsdomainalgorithm>
    <numberoptions>
      <item/>
    </numberoptions>
    <range>
      <from>192.168.20.50</from>
      <to>192.168.20.200</to>
    </range>
    <winsserver/>
    <dnsserver>192.168.20.1</dnsserver>
    <ntpserver/>
    <staticmap>
      <mac>55:55:55:55:55:1c</mac>
      <ipaddr>192.168.20.160</ipaddr>
      <hostname>somehost983</hostname>
      <descr>someservire8</descr>
      <winsserver/>
      <dnsserver/>
      <ntpserver/>
    </staticmap>
    <staticmap>
      <mac>55:55:55:55:55:1c</mac>
      <ipaddr>192.168.20.155</ipaddr>
      <hostname>somehost893</hostname>
      <winsserver/>
      <dnsserver/>
      <ntpserver/>
    </staticmap>
    <staticmap>
      <mac>55:55:55:55:55:1c</mac>
      <ipaddr>192.168.20.165</ipaddr>
      <hostname>somehost893</hostname>
      <descr/>
      <winsserver/>
      <dnsserver/>
      <ntpserver/>
    </staticmap>
    <staticmap>
      <mac>55:55:55:55:55:1c</mac>
      <ipaddr>192.168.20.50</ipaddr>
      <hostname>hostswitch2</hostname>
      <descr>switch-2 (bottom)</descr>
      <winsserver/>
      <dnsserver/>
      <ntpserver/>
    </staticmap>
    <pool/>
  </lan>
</dhcpd>\n";

    #[test]
    fn test_ip_in_range() {
        let range = Range {
            from: "192.168.1.100".to_string(),
            to: "192.168.1.200".to_string(),
        };

        // Test IP within range
        let ip = "192.168.1.150".parse::<Ipv4Addr>().unwrap();
        assert_eq!(DhcpConfig::is_ip_in_range(&ip, range.clone()), true);

        // Test IP at start of range
        let ip = "192.168.1.100".parse::<Ipv4Addr>().unwrap();
        assert_eq!(DhcpConfig::is_ip_in_range(&ip, range.clone()), true);

        // Test IP at end of range
        let ip = "192.168.1.200".parse::<Ipv4Addr>().unwrap();
        assert_eq!(DhcpConfig::is_ip_in_range(&ip, range.clone()), true);

        // Test IP before range
        let ip = "192.168.1.99".parse::<Ipv4Addr>().unwrap();
        assert_eq!(DhcpConfig::is_ip_in_range(&ip, range.clone()), false);

        // Test IP after range
        let ip = "192.168.1.201".parse::<Ipv4Addr>().unwrap();
        assert_eq!(DhcpConfig::is_ip_in_range(&ip, range.clone()), false);
    }
}