//! Implementations of traits from this crate for minidom types
use std::marker::PhantomData;
use std::vec::IntoIter;

use minidom::{Element, Node};

use rxml::{
    parser::EventMetrics,
    writer::{SimpleNamespaces, TrackNamespace},
    AttrMap, Event, Name, Namespace, NcName,
};

use crate::{error::Error, FromEventsBuilder, FromEventsError, FromXml, IntoXml};

enum IntoEventsInner {
    Header(Element),
    Nodes {
        remaining: IntoIter<Node>,
        nested: Option<Box<IntoEvents>>,
    },
    Fin,
}

pub(super) fn make_start_ev_parts(el: &Element) -> Result<(rxml::QName, AttrMap), Error> {
    let name = NcName::try_from(el.name())?;
    let namespace = Namespace::try_from(el.ns())?;

    let mut attrs = AttrMap::new();
    for (name, value) in el.attrs() {
        let name = Name::try_from(name)?;
        let (prefix, name) = name.split_name()?;
        let namespace = if let Some(prefix) = prefix {
            if prefix == "xml" {
                Namespace::XML
            } else {
                let ns = match el.prefixes.get(&Some(prefix.into())) {
                    Some(v) => v,
                    None => {
                        panic!("undeclared xml namespace prefix in minidom::Element")
                    }
                };
                Namespace::try_from(ns.to_owned())?
            }
        } else {
            Namespace::NONE
        };

        attrs.insert(namespace, name, value.to_owned());
    }

    Ok(((namespace, name), attrs))
}

impl IntoEventsInner {
    fn next(&mut self) -> Result<Option<Event>, Error> {
        match self {
            IntoEventsInner::Header(ref mut el) => {
                let (qname, attrs) = make_start_ev_parts(el)?;
                let event = Event::StartElement(EventMetrics::zero(), qname, attrs);

                *self = IntoEventsInner::Nodes {
                    remaining: el.take_nodes().into_iter(),
                    nested: None,
                };
                return Ok(Some(event));
            }
            IntoEventsInner::Nodes {
                ref mut nested,
                ref mut remaining,
            } => {
                loop {
                    if let Some(nested) = nested.as_mut() {
                        if let Some(ev) = nested.next() {
                            return Some(ev).transpose();
                        }
                    }
                    match remaining.next() {
                        Some(Node::Text(text)) => {
                            return Ok(Some(Event::Text(EventMetrics::zero(), text)));
                        }
                        Some(Node::Element(el)) => {
                            *nested = Some(Box::new(el.into_event_iter()?));
                            // fallthrough to next loop iteration
                        }
                        None => {
                            // end of element, switch state and emit EndElement
                            *self = IntoEventsInner::Fin;
                            return Ok(Some(Event::EndElement(EventMetrics::zero())));
                        }
                    }
                }
            }
            IntoEventsInner::Fin => Ok(None),
        }
    }
}

/// Convert a [`minidom::Element`] into [`rxml::Event`]s
pub struct IntoEvents(IntoEventsInner);

impl Iterator for IntoEvents {
    type Item = Result<Event, Error>;

    fn next(&mut self) -> Option<Self::Item> {
        self.0.next().transpose()
    }
}

impl IntoXml for Element {
    type EventIter = IntoEvents;

    fn into_event_iter(self) -> Result<Self::EventIter, Error> {
        // TODO: proper error reporting...
        Ok(IntoEvents(IntoEventsInner::Header(self)))
    }
}

/// Construct a [`minidom::Element`] from [`rxml::Event`]s
pub struct ElementFromEvents {
    inner: Option<Element>,
    nested: Option<Box<ElementFromEvents>>,
}

impl FromEventsBuilder for ElementFromEvents {
    type Output = minidom::Element;

    fn feed(&mut self, ev: Event) -> Result<Option<Self::Output>, Error> {
        let inner = self
            .inner
            .as_mut()
            .expect("feed() called after it finished");
        if let Some(nested) = self.nested.as_mut() {
            match nested.feed(ev)? {
                Some(v) => {
                    inner.append_child(v);
                    self.nested = None;
                    return Ok(None);
                }
                None => return Ok(None),
            }
        }
        match ev {
            Event::XmlDeclaration(_, _) => Ok(None),
            Event::StartElement(_, qname, attrs) => {
                let nested = match Element::from_events(qname, attrs) {
                    Ok(v) => v,
                    Err(FromEventsError::Invalid(e)) => return Err(e),
                    Err(FromEventsError::Mismatch { .. }) => {
                        unreachable!("<Element as FromXml>::from_events should accept everything!")
                    }
                };
                self.nested = Some(Box::new(nested));
                Ok(None)
            }
            Event::Text(_, text) => {
                inner.append_text_node(text);
                Ok(None)
            }
            Event::EndElement(_) => Ok(Some(self.inner.take().unwrap())),
        }
    }
}

impl FromXml for Element {
    type Builder = ElementFromEvents;

    fn from_events(
        qname: rxml::QName,
        attrs: rxml::AttrMap,
    ) -> Result<Self::Builder, FromEventsError> {
        let mut prefixes = SimpleNamespaces::new();
        let mut builder = Element::builder(qname.1, qname.0);
        for ((namespace, name), value) in attrs.into_iter() {
            if namespace.is_none() {
                builder = builder.attr(name, String::from(value));
            } else {
                let (is_new, prefix) = prefixes.declare_with_auto_prefix(namespace.clone());
                let name = prefix.with_suffix(&name);
                if is_new {
                    builder = builder
                        .prefix(
                            Some(prefix.as_str().to_owned()),
                            namespace.as_str().to_owned(),
                        )
                        .unwrap();
                }
                builder = builder.attr(name, String::from(value));
            }
        }

        let element = builder.build();
        Ok(Self::Builder {
            inner: Some(element),
            nested: None,
        })
    }
}

/// Helper struct to streamingly parse a struct which implements conversion
/// from [`minidom::Element`].
pub struct FromEventsViaElement<T> {
    inner: ElementFromEvents,
    _phantom: PhantomData<T>,
}

impl<T: TryFrom<minidom::Element, Error = crate::error::Error>> FromEventsViaElement<T> {
    /// Create a new streaming parser for `T`.
    pub fn new(qname: rxml::QName, attrs: rxml::AttrMap) -> Result<Self, FromEventsError> {
        Ok(Self {
            _phantom: PhantomData,
            inner: Element::from_events(qname, attrs)?,
        })
    }
}

impl<T: TryFrom<minidom::Element, Error = crate::error::Error>> FromEventsBuilder
    for FromEventsViaElement<T>
{
    type Output = T;

    fn feed(&mut self, ev: Event) -> Result<Option<Self::Output>, Error> {
        match self.inner.feed(ev) {
            Ok(Some(v)) => Ok(Some(v.try_into()?)),
            Ok(None) => Ok(None),
            Err(e) => Err(e),
        }
    }
}

/// Helper struct to stream a struct which implements conversion
/// to [`minidom::Element`].
pub struct IntoEventsViaElement<T> {
    inner: IntoEvents,
    _phantom: PhantomData<T>,
}

impl<E, T: TryInto<minidom::Element, Error = E>> IntoEventsViaElement<T>
where
    Error: From<E>,
{
    /// Create a new streaming parser for `T`.
    pub fn new(value: T) -> Result<Self, crate::error::Error> {
        let element = value.try_into()?;
        Ok(Self {
            _phantom: PhantomData,
            inner: element.into_event_iter()?,
        })
    }
}

impl<T: TryFrom<minidom::Element, Error = crate::error::Error>> Iterator
    for IntoEventsViaElement<T>
{
    type Item = Result<Event, Error>;

    fn next(&mut self) -> Option<Self::Item> {
        self.inner.next()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn transform_element_is_equivalent() {
        let el: Element = "<foo xmlns='urn:a' a='b' c='d'><child a='x'/><child a='y'>some text</child><child xmlns='urn:b'><nested-child/></child></foo>".parse().unwrap();
        let transformed: Element = crate::transform(el.clone()).unwrap();
        assert_eq!(el, transformed);
    }
}