use crate::error::Error;
use crate::error::ExpectedKind;
use crate::error::Received;
use crate::error::eof;
use crate::error::io_syntax_error;
use crate::error::is_eof_error;
use crate::error::syntax_error;

use crate::hex;

use crate::value::CompoundClass;
use crate::value::DomainParse;
use crate::value::DummyValue;
use crate::value::Embeddable;
use crate::value::IOValue;
use crate::value::IOValueDomainCodec;
use crate::value::Map;
use crate::value::NestedValue;
use crate::value::Reader;
use crate::value::Record;
use crate::value::Set;
use crate::value::Token;
use crate::value::Value;
use crate::value::ViaCodec;
use crate::value::boundary as B;
use crate::value::reader::BinarySource;
use crate::value::reader::ReaderResult;
use crate::value::repr::Annotations;

use num::bigint::BigInt;

use std::io;
use std::iter::FromIterator;
use std::marker::PhantomData;

pub struct TextReader<'a, D: Embeddable, Dec: DomainParse<D>> {
    buf: &'a str,
    pos: usize,
    dec: Dec,
    phantom: PhantomData<D>,
}

impl<'a, D: Embeddable, Dec: DomainParse<D>> TextReader<'a, D, Dec> {
    pub fn new(buf: &'a str, dec: Dec) -> Self {
        TextReader {
            buf,
            pos: 0,
            dec,
            phantom: PhantomData,
        }
    }

    fn remaining_input(&self) -> &str {
        &self.buf[self.pos ..]
    }

    fn peek(&self) -> ReaderResult<char> {
        if self.pos >= self.buf.len() {
            Err(eof())
        } else {
            Ok(self.buf[self.pos ..].chars().next().unwrap())
        }
    }

    fn drop(&mut self, count: usize) {
        self.pos += count;
    }

    fn undrop(&mut self, count: usize) {
        self.pos -= count;
    }

    fn next_char(&mut self) -> ReaderResult<char> {
        let c = self.peek()?;
        self.drop(c.len_utf8());
        Ok(c)
    }

    fn skip_whitespace(&mut self) {
        while let Ok(c) = self.peek() {
            if !c.is_whitespace() && c != ',' {
                break;
            }
            self.drop(c.len_utf8())
        }
    }

    // TODO: This is a duplicate of fn expected in PackedReader.
    fn expected<N: NestedValue<D>>(&mut self, k: ExpectedKind) -> Error {
        match Reader::<D, N>::demand_next(self, true) {
            Ok(v) => Error::Expected(k, Received::ReceivedOtherValue(format!("{:?}", v))),
            Err(e) => e.into()
        }
    }

    fn gather_annotations<N: NestedValue<D>>(&mut self) -> ReaderResult<Vec<N>> {
        let mut vs = Vec::new();
        loop {
            self.skip_whitespace();
            match self.peek()? {
                ';' => { self.drop(1); vs.push(N::new(self.comment_line()?)) }
                '@' => { self.drop(1); vs.push(self.demand_next(true)?) }
                _ => return Ok(vs),
            }
        }
    }

    fn skip_annotations(&mut self) -> ReaderResult<()> {
        loop {
            self.skip_whitespace();
            match self.peek()? {
                ';' => { self.drop(1); self.comment_line()?; },
                '@' => { self.drop(1); Reader::<D, DummyValue<D>>::skip_value(self)?; },
                _ => return Ok(()),
            }
        }
    }

    pub fn next_iovalue(&mut self, read_annotations: bool) -> io::Result<IOValue> {
        let mut r = TextReader::new(self.remaining_input(), ViaCodec::new(IOValueDomainCodec));
        let v = r.demand_next(read_annotations)?;
        self.pos += r.pos;
        Ok(v)
    }

    fn comment_line(&mut self) -> io::Result<String> {
        let mut s = String::new();
        loop {
            match self.next_char()? {
                '\r' | '\n' => return Ok(s),
                c => s.push(c),
            }
        }
    }

    fn read_intpart<N: NestedValue<D>>(&mut self, mut s: String, c: char) -> io::Result<N> {
        match c {
            '0' => {
                s.push(c);
                self.read_fracexp(s)
            }
            _ => {
                self.read_digit1(&mut s, c)?;
                self.read_fracexp(s)
            }
        }
    }

    fn read_fracexp<N: NestedValue<D>>(&mut self, mut s: String) -> io::Result<N> {
        match self.peek()? {
            '.' => {
                s.push(self.next_char()?);
                let c = self.next_char()?;
                self.read_digit1(&mut s, c)?;
            }
            _ => ()
        }
        self.read_exp(s)
    }

    fn read_exp<N: NestedValue<D>>(&mut self, mut s: String) -> io::Result<N> {
        match self.peek()? {
            'e' | 'E' => {
                s.push(self.next_char()?);
                self.read_sign_and_exp(s)
            }
            _ => self.finish_number(s)
        }
    }

    fn read_sign_and_exp<N: NestedValue<D>>(&mut self, mut s: String) -> io::Result<N> {
        match self.peek()? {
            '+' | '-' => s.push(self.next_char()?),
            _ => (),
        }
        let c = self.next_char()?;
        self.read_digit1(&mut s, c)?;
        self.finish_number(s)
    }

    fn finish_number<N: NestedValue<D>>(&mut self, s: String) -> io::Result<N> {
        if let Ok(n) = s.parse::<BigInt>() {
            return Ok(N::new(n));
        }
        match self.peek()? {
            'f' | 'F' => {
                self.drop(1);
                Ok(N::new(s.parse::<f32>().map_err(
                    |_| io_syntax_error(&format!(
                        "Invalid single-precision number: {:?}", s)))?))
            }
            _ =>
                Ok(N::new(s.parse::<f64>().map_err(
                    |_| io_syntax_error(&format!(
                        "Invalid double-precision number: {:?}", s)))?))
        }
    }

    fn read_digit1(&mut self, s: &mut String, c: char) -> io::Result<()>
    {
        if !c.is_digit(10) {
            return Err(io_syntax_error("Incomplete number"));
        }
        s.push(c);
        while self.peek()?.is_digit(10) {
            s.push(self.next_char()?);
        }
        Ok(())
    }

    fn read_stringlike<X, H, Acc, Element, R>(
        &mut self,
        mut seed: R,
        acc: Acc,
        xform_item: X,
        terminator: char,
        hexescape: char,
        hexescaper: H,
    ) -> io::Result<R>
    where
        X: Fn(char) -> Element,
        H: Fn(&mut Self) -> io::Result<Element>,
        Acc: Fn(&mut R, Element) -> (),
    {
        loop {
            match self.next_char()? {
                c if c == terminator => return Ok(seed),
                '\\' => match self.next_char()? {
                    c if c == hexescape =>
                        acc(&mut seed, hexescaper(self)?),
                    c if c == terminator || c == '\\' || c == '/' =>
                        acc(&mut seed, xform_item(c)),
                    'b' => acc(&mut seed, xform_item('\x08')),
                    'f' => acc(&mut seed, xform_item('\x0c')),
                    'n' => acc(&mut seed, xform_item('\x0a')),
                    'r' => acc(&mut seed, xform_item('\x0d')),
                    't' => acc(&mut seed, xform_item('\x09')),
                    _ => return Err(io_syntax_error("Invalid escape code")),
                },
                c => acc(&mut seed, xform_item(c)),
            }
        }
    }

    fn hexnum(&mut self, count: usize) -> io::Result<u32> {
        let mut v: u32 = 0;
        for _ in 0 .. count {
            let c = self.next_char()?;
            match c.to_digit(16) {
                Some(d) =>
                    v = v << 4 | d,
                None =>
                    return Err(io_syntax_error("Bad hex escape")),
            }
        }
        Ok(v)
    }

    fn read_string(&mut self, delimiter: char) -> io::Result<String> {
        self.read_stringlike(
            String::new(),
            |s, c| s.push(c),
            |c| c,
            delimiter,
            'u',
            |r| {
                let n1 = r.hexnum(4)?;
                if (0xd800 ..= 0xdbff).contains(&n1) {
                    let mut ok = true;
                    ok = ok && r.next_char()? == '\\';
                    ok = ok && r.next_char()? == 'u';
                    if !ok {
                        Err(io_syntax_error("Missing second half of surrogate pair"))
                    } else {
                        let n2 = r.hexnum(4)?;
                        if (0xdc00 ..= 0xdfff).contains(&n2) {
                            let n = ((n1 - 0xd800) << 10) + (n2 - 0xdc00) + 0x10000;
                            char::from_u32(n).ok_or_else(
                                || io_syntax_error("Bad code point from surrogate pair"))
                        } else {
                            Err(io_syntax_error("Bad second half of surrogate pair"))
                        }
                    }
                } else {
                    char::from_u32(n1).ok_or_else(
                        || io_syntax_error("Bad code point"))
                }
            })
    }

    fn read_literal_binary<N: NestedValue<D>>(&mut self) -> io::Result<N> {
        Ok(N::new(&self.read_stringlike(
            Vec::new(),
            |bs, b| bs.push(b),
            |c| c as u8,
            '"',
            'x',
            |r| Ok(r.hexnum(2)? as u8))?[..]))
    }

    fn read_hex_binary<N: NestedValue<D>>(&mut self) -> io::Result<N> {
        let mut s = String::new();
        loop {
            self.skip_whitespace();
            let c1 = self.next_char()?;
            if c1 == '"' {
                let bs = hex::HexParser::Strict.decode(&s).unwrap();
                return Ok(N::new(&bs[..]));
            }
            let c2 = self.next_char()?;
            if !(c1.is_digit(16) && c2.is_digit(16)) {
                return Err(io_syntax_error("Invalid hex binary"));
            }
            s.push(c1);
            s.push(c2);
        }
    }

    fn read_base64_binary<N: NestedValue<D>>(&mut self) -> io::Result<N> {
        let mut s = String::new();
        loop {
            self.skip_whitespace();
            let mut c = self.next_char()?;
            if c == ']' {
                let bs = base64::decode_config(&s, base64::STANDARD_NO_PAD)
                    .map_err(|_| io_syntax_error("Invalid base64 character"))?;
                return Ok(N::new(&bs[..]));
            }
            if c == '-' { c = '+'; }
            if c == '_' { c = '/'; }
            if c == '=' { continue; }
            s.push(c);
        }
    }

    fn upto<N: NestedValue<D>>(&mut self, delimiter: char, read_annotations: bool) -> io::Result<Vec<N>> {
        let mut vs = Vec::new();
        loop {
            self.skip_whitespace();
            if self.peek()? == delimiter {
                self.drop(delimiter.len_utf8());
                return Ok(vs);
            }
            vs.push(Reader::<D, N>::demand_next(self, read_annotations)?);
        }
    }

    fn read_dictionary<N: NestedValue<D>>(&mut self, read_annotations: bool) -> io::Result<N> {
        let mut d = Map::new();
        loop {
            self.skip_whitespace();
            if self.peek()? == '}' {
                self.drop(1);
                return Ok(N::new(d));
            }
            let k = Reader::<D, N>::demand_next(self, read_annotations)?;
            self.skip_whitespace();
            if self.next_char()? != ':' {
                return Err(io_syntax_error("Missing expected key/value separator"));
            }
            let v = Reader::<D, N>::demand_next(self, read_annotations)?;
            d.insert(k, v);
        }
    }

    fn read_raw_symbol<N: NestedValue<D>>(&mut self, mut s: String) -> io::Result<N> {
        loop {
            let c = match self.peek() {
                Err(e) if is_eof_error(&e) => ' ',
                Err(e) => return Err(e)?,
                Ok(c) if c.is_whitespace() => ' ',
                Ok(c) => c
            };
            match c {
                '(' | ')' | '{' | '}' | '[' | ']' | '<' | '>' |
                '"' | ';' | ',' | '@' | '#' | ':' | '|' | ' ' =>
                    return Ok(Value::symbol(&s).wrap()),
                c => {
                    self.drop(c.len_utf8());
                    s.push(c)
                }
            }
        }
    }
}

impl<'a, 'de, D: Embeddable, N: NestedValue<D>, Dec: DomainParse<D>> Reader<'de, D, N> for TextReader<'a, D, Dec> {
    fn next(&mut self, read_annotations: bool) -> io::Result<Option<N>> {
        self.skip_whitespace();
        let c = match self.next_char() {
            Ok(c) => c,
            Err(e) if is_eof_error(&e) => return Ok(None),
            Err(e) => return Err(e.into()),
        };
        Ok(Some(match c {
            '-' => {
                let c1 = self.next_char()?;
                self.read_intpart("-".to_owned(), c1)?
            }
            '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' =>
                self.read_intpart(String::new(), c)?,
            '"' =>
                N::new(self.read_string('"')?),
            '|' =>
                Value::symbol(&self.read_string('|')?).wrap(),
            ';' | '@' => {
                self.undrop(1);
                if read_annotations {
                    let mut annotations = self.gather_annotations()?;
                    let (existing_annotations, v) =
                        Reader::<D, N>::demand_next(self, read_annotations)?.pieces();
                    annotations.extend_from_slice(existing_annotations.slice());
                    N::wrap(Annotations::new(Some(annotations)), v)
                } else {
                    self.skip_annotations()?;
                    self.demand_next(read_annotations)?
                }
            }
            ':' => {
                // return Err(io_syntax_error("Unexpected key/value separator between items")),
                return Err(io_syntax_error(&format!("Unexpected key/value separator between items (pos {:?})", self.pos)));
            }
            '#' => match self.next_char()? {
                'f' => N::new(false),
                't' => N::new(true),
                '{' => N::new(Set::from_iter(self.upto('}', read_annotations)?.into_iter())),
                '"' => self.read_literal_binary()?,
                'x' => if self.next_char()? == '"' {
                    self.read_hex_binary()?
                } else {
                    return Err(io_syntax_error("Expected open-quote at start of hex ByteString"));
                },
                '[' => self.read_base64_binary()?,
                '=' => {
                    let bs_val: N = self.demand_next(true)?;
                    if bs_val.annotations().slice().len() > 0 {
                        return Err(io_syntax_error("Annotations not permitted after #="));
                    }
                    match bs_val.value().as_bytestring() {
                        None =>
                            return Err(io_syntax_error("ByteString must follow #=")),
                        Some(bs) =>
                            crate::value::BytesBinarySource::new(bs)
                            .packed(ViaCodec::new(&mut self.dec))
                            .demand_next(read_annotations)?
                    }
                }
                '!' => {
                    let v = self.next_iovalue(read_annotations)?;
                    Value::Embedded(self.dec.parse_embedded(&v)?).wrap()
                }
                other => return Err(io_syntax_error(&format!("Invalid # syntax: {:?}", other))),
            },
            '<' => {
                let vs = self.upto('>', read_annotations)?;
                if vs.is_empty() {
                    return Err(io_syntax_error("Missing record label"));
                }
                Value::Record(Record(vs)).wrap()
            }
            '[' => N::new(self.upto(']', read_annotations)?),
            '{' => self.read_dictionary(read_annotations)?,
            '>' => return Err(io_syntax_error("Unexpected >")),
            ']' => return Err(io_syntax_error("Unexpected ]")),
            '}' => return Err(io_syntax_error("Unexpected }")),
            other => self.read_raw_symbol(other.to_string())?,
        }))
    }

    fn open_record(&mut self, arity: Option<usize>) -> ReaderResult<B::Type> {
        self.skip_annotations()?;
        if self.peek()? != '<' { return Err(self.expected::<N>(ExpectedKind::Record(arity))); }
        self.drop(1);
        let mut b = B::Type::default();
        Reader::<D, N>::ensure_more_expected(self, &mut b, &B::Item::RecordLabel)?;
        Ok(b)
    }

    fn open_sequence_or_set(&mut self) -> ReaderResult<B::Item> {
        self.skip_annotations()?;
        let mark = Reader::<D, N>::mark(self)?;
        match self.next_char()? {
            '#' => match self.next_char()? {
                '{' => return Ok(B::Item::SetValue),
                _ => (),
            },
            '[' => return Ok(B::Item::SequenceValue),
            _ => (),
        }
        Reader::<D, N>::restore(self, &mark)?;
        Err(self.expected::<N>(ExpectedKind::SequenceOrSet))
    }

    fn open_sequence(&mut self) -> ReaderResult<()> {
        self.skip_annotations()?;
        if self.peek()? != '[' { return Err(self.expected::<N>(ExpectedKind::Sequence)); }
        self.drop(1);
        Ok(())
    }

    fn open_set(&mut self) -> ReaderResult<()> {
        self.skip_annotations()?;
        let mark = Reader::<D, N>::mark(self)?;
        match self.next_char()? {
            '#' => match self.next_char()? {
                '{' => return Ok(()),
                _ => (),
            },
            _ => (),
        }
        Reader::<D, N>::restore(self, &mark)?;
        Err(self.expected::<N>(ExpectedKind::Set))
    }

    fn open_dictionary(&mut self) -> ReaderResult<()> {
        self.skip_annotations()?;
        if self.peek()? != '{' { return Err(self.expected::<N>(ExpectedKind::Dictionary)); }
        self.drop(1);
        Ok(())
    }

    #[inline]
    fn boundary(&mut self, b: &B::Type) -> ReaderResult<()> {
        match b {
            B::Type {
                closing: Some(B::Item::DictionaryKey),
                opening: Some(B::Item::DictionaryValue),
            } => {
                self.skip_whitespace();
                if self.next_char()? != ':' {
                    return Err(syntax_error("Missing expected key/value separator"));
                }
            },
            _ => (),
        }
        Ok(())
    }

    fn close_compound(&mut self, b: &mut B::Type, i: &B::Item) -> ReaderResult<bool> {
        self.skip_whitespace();
        match self.peek()? {
            '>' | ']' | '}' => {
                self.drop(1);
                Ok(true)
            }
            _ => {
                b.shift(Some(i.clone()));
                Reader::<D, N>::boundary(self, b)?;
                Ok(false)
            }
        }
    }

    fn open_embedded(&mut self) -> ReaderResult<()> {
        self.skip_annotations()?;
        let mark = Reader::<D, N>::mark(self)?;
        match self.next_char()? {
            '#' => match self.next_char()? {
                '!' => return Ok(()),
                _ => (),
            },
            _ => (),
        }
        Reader::<D, N>::restore(self, &mark)?;
        Err(self.expected::<N>(ExpectedKind::Embedded))
    }

    fn close_embedded(&mut self) -> ReaderResult<()> {
        Ok(())
    }

    type Mark = usize;

    fn mark(&mut self) -> io::Result<Self::Mark> {
        Ok(self.pos)
    }

    fn restore(&mut self, mark: &Self::Mark) -> io::Result<()> {
        self.pos = *mark;
        Ok(())
    }

    fn next_token(&mut self, read_embedded_annotations: bool) -> io::Result<Token<D, N>> {
        self.skip_annotations()?;
        let mark = Reader::<D, N>::mark(self)?;
        Ok(match self.next_char()? {
            '<' => Token::Compound(CompoundClass::Record),
            '[' => Token::Compound(CompoundClass::Sequence),
            '{' => Token::Compound(CompoundClass::Dictionary),
            '>' => Token::End,
            ']' => Token::End,
            '}' => Token::End,
            '#' => match self.next_char()? {
                '!' => {
                    let v = self.next_iovalue(read_embedded_annotations)?;
                    Token::Embedded(self.dec.parse_embedded(&v)?)
                }
                '{' => Token::Compound(CompoundClass::Set),
                _ => {
                    Reader::<D, N>::restore(self, &mark)?;
                    Token::Atom(self.demand_next(false)?)
                }
            },
            _ => {
                Reader::<D, N>::restore(self, &mark)?;
                Token::Atom(self.demand_next(false)?)
            }
        })
    }

    fn next_annotations_and_token(&mut self) -> io::Result<(Vec<N>, Token<D, N>)> {
        let annotations = self.gather_annotations()?;
        Ok((annotations, self.next_token(true)?))
    }
}