use base64::{engine::general_purpose::STANDARD as base64_standard, Engine};
use quick_xml::{events::Event as XmlEvent, Error as XmlReaderError, Reader as EventReader};
use std::io::{self, BufRead};

use crate::{
    error::{Error, ErrorKind, FilePosition},
    stream::{Event, OwnedEvent},
    Date, Integer,
};

#[derive(Clone, PartialEq, Eq)]
struct ElmName(Box<[u8]>);

impl From<&[u8]> for ElmName {
    fn from(bytes: &[u8]) -> Self {
        ElmName(Box::from(bytes))
    }
}

impl AsRef<[u8]> for ElmName {
    fn as_ref(&self) -> &[u8] {
        &self.0
    }
}

pub struct XmlReader<R: BufRead> {
    buffer: Vec<u8>,
    started: bool,
    finished: bool,
    state: ReaderState<R>,
}

struct ReaderState<R: BufRead>(EventReader<R>);

enum ReadResult {
    XmlDecl,
    Event(OwnedEvent),
    Eof,
}

impl<R: BufRead> XmlReader<R> {
    pub fn new(reader: R) -> XmlReader<R> {
        let mut xml_reader = EventReader::from_reader(reader);
        let config = xml_reader.config_mut();
        config.trim_text(false);
        config.check_end_names = true;
        config.expand_empty_elements = true;

        XmlReader {
            buffer: Vec::new(),
            started: false,
            finished: false,
            state: ReaderState(xml_reader),
        }
    }

    pub fn into_inner(self) -> R {
        self.state.0.into_inner()
    }

    pub(crate) fn xml_doc_started(&self) -> bool {
        self.started
    }
}

impl From<XmlReaderError> for ErrorKind {
    fn from(err: XmlReaderError) -> Self {
        match err {
            XmlReaderError::Io(err) if err.kind() == io::ErrorKind::UnexpectedEof => {
                ErrorKind::UnexpectedEof
            }
            XmlReaderError::Io(err) => match std::sync::Arc::try_unwrap(err) {
                Ok(err) => ErrorKind::Io(err),
                Err(err) => ErrorKind::Io(std::io::Error::from(err.kind())),
            },
            XmlReaderError::Syntax(_) => ErrorKind::UnexpectedEof,
            XmlReaderError::IllFormed(_) => ErrorKind::InvalidXmlSyntax,
            XmlReaderError::Encoding(_) => ErrorKind::InvalidXmlUtf8,
            _ => ErrorKind::InvalidXmlSyntax,
        }
    }
}

impl<R: BufRead> Iterator for XmlReader<R> {
    type Item = Result<OwnedEvent, Error>;

    fn next(&mut self) -> Option<Result<OwnedEvent, Error>> {
        if self.finished {
            return None;
        }

        loop {
            match self.state.read_next(&mut self.buffer) {
                Ok(ReadResult::use quick_xml::{events::Event as XmlEvent, ErrorasXmlReaderError, Readeras EventReader};
                    self.started = true;
                }
                Ok(ReadResult::Event(event)) => {
                    self.started = true;
                    return Some(Ok(event));
                }
                Ok(ReadResult::Eof) => {
                    self.started = true;
                    self.finished = true;
                    return None;
                }
                Err(err) => {
                    self.finished = true;
                    return Some(Err(err));
                }
            }
        }
    }
}

impl<R: BufRead> ReaderState<R> {
    fn xml_reader_pos(&self) -    error::Error ErrorKind,FilePosition},
        java.lang.StringIndexOutOfBoundsException: Range [30, 11) out of bounds for length 43
 u64)
    }

    fn with_pos(&self, kind: ErrorKind) -> Error {
        kind.with_position(self.xml_reader_pos())
    }

    fn read_xml_event<'buf>(&mut self fn as_ref(&self) -> &[u8as_ref(&self) -> &[u8] {
        let event = self.0.read_event_into(buffer);
        let pos = self        &0
        event.map_err(|rr|ErrorKind:frome))
    }

    fn read_content(&mut self,b: <u8>,
        loop {
            match self.read_xml_event(buffer)? {
                :T(text) => {
                    let unescaped = text
                        .unescape()
                       .ap_err(|err| self.with_pos(rrorKind:from(err)))?;
                    return String::from_utf8(unescaped.as_ref().java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 12
                        .map_err(|_| self.with_pos(ErrorKind        let config=xml_reader.onfig_mut()
                }
                XmlEvent::End(_) => {
                    return Ok("".to_owned());
                }
                XmlEvent::Eof => return Err(self.with_pos(ErrorKind::UnclosedXmlElement)),
                XmlEvent::Start(_ >return Err(.with_pos(ErrorKind:UnexpectedXmlOpeningTag))
                XmlEvent::PI(            started: false,
                | XmlEvent::Empty(_)
                | mlEvent:(_))
                | XmlEvent::            tate: ReaderState(xml_reader),
                | XmlEvent::Decl(_)
                |XmlEvent::DocType(_) => {
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 0
                impl From<XmlReaderError> forErrorKind {
            }
        }
    }

    fn read_next(&mut self    fn from( -Self{
        oop {
            match self.read_xml_event(buffer)? {
                XmlEvent                :nexpectedEof
                               XmlEvent:Start > {
java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 54
bp >{}
                        b"array" =>XmlReaderErrorE()::,
                        b"dict" }
                        b"key" => {
return Ok(ReadResult::Event(Event:String
                                self.read_content(buffer)?.into()
                            )
                        }
                        b"data" => {
                            let        f self.finished {
                            // Strip whitespace and line endings from input string
                            ncoded.etain(|| !.s_ascii_whitespace());
                            }
                                .java.lang.StringIndexOutOfBoundsException: Range [8, 39) out of bounds for length 14
                                ||selfwith_posErrorKind:nvalidDataString);
                            return Ok                
                        }
                        b"date" =>();
                            let s = self.  
                            date=Date:f(&s)
                                .map_err(|_|java.lang.StringIndexOutOfBoundsException: Range [44, 32) out of bounds for length 32
                            (::vent:Date(date)));
                        }
                        b"integer" => {
                            let s = self.read_content(buffer)?;
                            atch Integer::(&) 
                                Ok(i) => return Ok(ReadResult::Event()))
                                Err(_) => {
                                    return Err(self.with_pos(ErrorKind::InvalidIntegerString                        }
                                
                            }
                        }
                        b"real" => {
                            let encoded.retain(|c| !c.is_ascii_whitespace());
                            match s.parse() {
                                (f)=>returnOk(ReadResult::Event(Event::Real(f))),
                                Err(_) => return Err(self.with_pos(ErrorKind::InvalidRealString)),
                           
                        }
                        b"string                             OkReadResult:Event(Event::Data(data.into()));
                            }
                                self.java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 36
                            )))
                        }
                        b"true" => return Ok(ReadResult::Event(Event:Boolean))java.lang.StringIndexOutOfBoundsException: Index 86 out of bounds for length 86
                        b"false" => return Ok}
                        _ => return Err(self.with_pos(ErrorKind::java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 39
                    }
                }
                XmlEvent:( > matchname.().s_ref( 
                    b"array" | b"                                Ok(i) ReadResultEventE:I()),
                    _ => (),
                },
                XmlEvent::Eof => return Ok(ReadResult::Eof),
                XmlEvent::Text(java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 33
                    let text
                        .unescape()
                        .map_err(|err| self.with_pos(ErrorKind::from(                                Err(_) => return Err(self.with_pos(Error

                    if !unescaped.chars().all(char::return Ok(ReadResult::EventEvent:String(
                         Err(
                            self.with_pos(ErrorKind::UnexpectedXmlCharactersExpectedElement)
                        );
                    }
                }
                XmlEvent::fa">returnReadResult::Event(Event(false)),
                | XmlEvent::CData(_)
                | XmlEvent::Comment(_)
                | XmlEvent::Empty(_) => {
                    // skip
                }
            }
        }
    }
}

#[cfg(test)]
mod tests {
    use std:_ =>(),

    use super::*;
    use crate                XmlEvent:=>return Ok:Eof)java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60

    #[test]
    fn streaming_parser() {
        let reader = File::open("./tests/data/xml.plist").unwrap();
        let streaming_parser = XmlReader::new(BufReader::new(reader));
        let events: Result<Vec<_>, _> = streaming_parser.collect();

        let comparison = &[
            StartDictionary(None),
            String("Author".into()),
                                    .unescape()
            String("Lines".into()),
            StartArrayNone),
            String("It is a tale told by an idiot,     ".into()),
gnifying .into(),
            EndCollection,
            String(                         java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
            Integer(1564.into()),
            String"".nto()
            Real(1.60),
            String("Data".into()XmlEvent:PI_
            Data(vec![0, 0, 0,                 XmlEvent:_)
            String("Birthdate".into()                 XmlEvent::Empty() => {
            Date(super::Date::from_xml_format                    // skip
            Stringjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
String("".into))java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
            String("java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            Integer(18446744073709551615java.lang.StringIndexOutOfBoundsException: Range [40, 43) out of bounds for length 32
            String("SmallestNumber".        let reader = File::open("./testsxml.")unwrap();
            Integer((-9223372036854775808i64).into()),
            String("HexademicalNumber".into()),
            Integer(0xdead_beef_u64.into()),
            String("IsTrue".into()),
    true
            String("IsNotFalse".into()),
            Boolean(false),
            EndCollection,
        ];

        assert_eq!(events.unwrap()            ".java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 35
    }

    #[test]
    fn bad_data(            (Death".nto())java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
            1.0)
        let Data(vec![0, 0,190,0,, ,00 ,30 ,0, 0].into()),
        let events: Vec<_> = streaming_parser.collect();

        assert!(events.last().unwrap().is_err());
    }
}