use tun::Error;

// Here we will recieve bytes and try to get their destanation & apply Rules for them.
use crate::config::Config;

#[derive(Debug, PartialEq)]
pub enum Protocol {
    TCP,
    UDP,
    Unsupported(u8)
}
type Ipv4 = [u8; 4];
type Ipv6 = [u8; 16];
type Port = u16;
#[derive(Debug, PartialEq)]
pub enum PacketInfo {
    // <https://www.geeksforgeeks.org/computer-networks/what-is-ipv4/>
    V4 {
        src_ip: Ipv4,
        src_port: Port,
        dst_ip: Ipv4,
        dst_port: Port,
        protocol: Protocol,
        dns: bool
    },
    // <https://www.geeksforgeeks.org/computer-networks/internet-protocol-version-6-ipv6-header/>
    V6 {
        src_ip: Ipv6,
        src_port: Port,
        dst_ip: Ipv6,
        dst_port: Port,
        protocol: Protocol,
        dns: bool
    }
}

impl PacketInfo {
    pub fn protocol(&self) -> &Protocol {
        match self {
            PacketInfo::V4 { protocol, .. } => protocol,
            PacketInfo::V6 { protocol, .. } => protocol,
        }
    }
}

type GenericError = Box<dyn std::error::Error + Send + Sync + 'static>;
type SniffedPacket = Result<PacketInfo, Box<dyn std::error::Error + Send + Sync + 'static>>;

pub fn sniff_raw_packets(packet: &[u8]) -> SniffedPacket {
    let ver = packet[0] >> 4;
    dbg!(ver);
    match ver {
        4 => {
            let dst_port = Port::from_be_bytes([packet[22], packet[23]]);
            let dns;
            if dst_port == 53 { dns = true; } else { dns = false; };
            // FIXME: hardcoded IPv4 port offset
            let v4 = PacketInfo::V4{
                src_ip: <Ipv4>::try_from(&packet[12..16])?,
                src_port: Port::from_be_bytes([packet[20], packet[21]]),
                dst_ip: <Ipv4>::try_from(&packet[16..20])?,
                dst_port,
                protocol: match packet[9] {
                    6 => Protocol::TCP,
                    17 => Protocol::UDP,
                    p => Protocol::Unsupported(p)
                },
                dns
            };
        if !matches!(v4.protocol(), Protocol::Unsupported(_)) {
            println!("{v4:?}");
        } else {
            println!("oppsie unsupported");
            }
            Ok(v4)
        },
        6 => {
    println!("im in 6!");
            let dst_port = Port::from_be_bytes([packet[22], packet[23]]);
            let dns;
            if dst_port == 53 { dns = true; } else { dns = false; };
            let v6 = PacketInfo::V6{
                src_ip: <Ipv6>::try_from(&packet[8..24])?,
                src_port: Port::from_be_bytes([packet[40], packet[41]]),
                dst_ip: <Ipv6>::try_from(&packet[24..40])?,
                dst_port,
                protocol: match packet[6] {
                    6 => Protocol::TCP,
                    17 => Protocol::UDP,
                    p => Protocol::Unsupported(p)
                },
                dns
            };
        if !matches!(v6.protocol(), Protocol::Unsupported(_)) {
            println!("{v6:?}");
        } else {
            println!("oppsie unsupported");
            }
            Ok(v6)
        },
        ver => {
            Err(format!("unsuppiorted ver: {ver}").into())
        }
    }
}

pub fn apply_rules(config: Config, pinfo: PacketInfo) {
    todo!()
}