use xml::reader::XmlEvent;
use yaserde::{YaDeserialize, YaSerialize};

use crate::modules::opnsense::{Interface, Interfaces};

impl YaSerialize for Interfaces {
    fn serialize<W: std::io::Write>(
        &self,
        writer: &mut yaserde::ser::Serializer<W>,
    ) -> Result<(), String> {
        writer.write("Interfaces serializer TODO");
        Ok(())
    }

    fn serialize_attributes(
        &self,
        attributes: Vec<xml::attribute::OwnedAttribute>,
        namespace: xml::namespace::Namespace,
    ) -> Result<
        (
            Vec<xml::attribute::OwnedAttribute>,
            xml::namespace::Namespace,
        ),
        String,
    > {
        todo!()
    }
}

impl YaDeserialize for Interfaces {
    fn deserialize<R: std::io::Read>(
        reader: &mut yaserde::de::Deserializer<R>,
    ) -> Result<Self, String> {
        let mut interfaces = Interfaces::default();
        let mut current_interface_name = String::new();
        let mut current_interface = Interface::default();

        let mut event = reader.next_event()?;
        loop {
            match event {
                xml::reader::XmlEvent::EndElement { name } => {
                    println!(
                        "Handling EndElement {}, current_interface_name: {}",
                        name.local_name, current_interface_name
                    );
                    println!("Peeking after EndElement {:?}", reader.peek()?);
                    if name.local_name == "interfaces" {
                        break;
                    }
                    todo!("Should not hit here");
                }
                xml::reader::XmlEvent::StartElement { ref name, .. } => {
                    println!("Got start Element {:?}", name);
                    current_interface_name = name.local_name.clone();
                    println!("About to deserialize interface from name {:?}", name);
                    // TODO store names
                    'inner_iface: loop {
                        let peek = reader.peek()?;
                        println!("Peeking before forcing next event {:?}", peek);

                        if let XmlEvent::EndElement { name } = peek {
                            // TODO save the interface name and struct in the hashmap
                            println!("Forcing next_event");
                            reader.next_event()?;

                            let peek = reader.peek()?;
                            println!("Peeking after next event deserializing {:?}", peek);
                            if let XmlEvent::EndElement { name } = peek {
                                println!("Got two EndElement in a row, breaking out of loop");
                                break 'inner_iface;
                            }
                        }
                        println!("Peeking before deserializing {:?}", reader.peek()?);
                        let interface = <Interface as yaserde::YaDeserialize>::deserialize(reader)?;
                        println!("Interface deserialized {:?}", interface);
                        println!("Peeking after deserializing {:?}", reader.peek()?);
                    }
                    println!(
                        "Done with inner interface, loop completed {:?}",
                        reader.peek()?
                    );
                }
                xml::reader::XmlEvent::EndDocument => break,
                _ => {
                    return Err(
                        "This Interfaces Deserializer does not support all XmlEvent types".into(),
                    )
                }
            }
            let peek = reader.peek()?;

            let read_next = true;
            if let XmlEvent::EndElement { name } = peek {
                if name.local_name == "interfaces" {
                    println!("Got endElement interfaces, not reading next event");
                    break;
                }
            }

            if read_next {
                event = reader.next_event()?;
            }
            println!("Outer loop got event {:?}", event);
            println!("Outer loop got peek {:?}", reader.peek()?);
        }
        println!("Done with interfaces {:?}", interfaces);
        println!("reader peeking shows {:?}", reader.peek());

        Ok(interfaces)
    }
}