use std::convert::From;

use crate::{
    expressions::{Expr, Value},
    syntax::*,
};

#[cfg(test)]
mod tests;

/// In the case of expecting multiple expressions but actually getting one,
/// flatten the list of one expression to a single expression
macro_rules! flatten {
    (multiple $exprs:expr) => {
        flatten!(Expr::Multiple, $exprs)
    };
    (rpn of $exprs:expr) => {
        flatten!(Expr::Rpn, $exprs)
    };
    ($ctor:expr, $exprs:expr) => {
        if $exprs.len() == 1 {
            $exprs.pop().unwrap()
        } else {
            $ctor($exprs)
        }
    };
}

type ParsingError = String;

pub(crate) struct Parser {
    buf: Vec<Token>,
    pos: usize,
}

impl From<Vec<Token>> for Parser {
    fn from(buf: Vec<Token>) -> Self {
        Parser { buf, pos: 0 }
    }
}

impl Parser {
    fn has_next(&self) -> bool {
        self.pos < self.buf.len()
    }

    fn peek_next(&self) -> Option<TokenType> {
        if self.has_next() {
            Some(self.buf[self.pos].r#type)
        } else {
            None
        }
    }

    fn next(&mut self) -> TokenType {
        let t = self.buf[self.pos].r#type;
        self.pos += 1;
        t
    }

    fn assert_next(&mut self, pred: impl Fn(TokenType) -> bool) -> Result<(), ParsingError> {
        match self.peek_next() {
            Some(actual) if pred(actual) => Ok(()),
            // TODO: add ln:col
            Some(t) => Err(format!("Unexpected token {:?}", t)),
            _ => Err("Unexpected end of input".to_owned()),
        }
    }

    fn unexpected_tok_err(&self) -> Result<Option<Expr>, ParsingError> {
        let t = self.buf[self.pos];
        Err(format!("Unexpected token {:?} at {}:{}", t, t.ln, t.col))
    }

    // TODO: destructuring
    fn parse_declaration(&mut self) -> Result<Option<Expr>, ParsingError> {
        self.pos += 1;
        self.assert_next(|t| t.type_eq(TokenType::Ident { start: 0, end: 0 }))?;

        let name = if let TokenType::Ident { start, end } = self.next() {
            (start, end)
        } else {
            // this will never happen, just have to satisfy the compiler..
            return Err("..".to_owned());
        };

        self.assert_next(|t| t == TokenType::Punct(Punct::Assign))?;
        self.pos += 1;

        let val = if let Some(expr) = self.parse()? {
            Box::new(expr)
        } else {
            return self.unexpected_tok_err();
        };

        Ok(Some(Expr::Declaration { name, val }))
    }

    fn parse_numeric(&mut self) -> Result<Option<Expr>, ParsingError> {
        use Punct::*;

        let mut q = Vec::new();
        let mut s = Vec::new();

        while self.has_next() {
            let t = self.next();

            match t {
                TokenType::Num(x) => q.push(Expr::Value(Value::Num(x))),
                TokenType::Punct(Punct::OpenParen) => s.push(Punct::OpenParen),
                TokenType::Punct(Punct::CloseParen) => {
                    while let Some(p) = s.pop() {
                        match p {
                            Punct::OpenParen => break,
                            _ => q.push(Expr::Op(p)),
                        };
                    }
                }
                // TODO: find a better syntax for this
                TokenType::Punct(p @ Add)
                | TokenType::Punct(p @ Sub)
                | TokenType::Punct(p @ Mul)
                | TokenType::Punct(p @ Div)
                | TokenType::Punct(p @ Pow) => {
                    while s.last().map_or(false, |&op| {
                        p.precedence() > op.precedence()
                            || (p.precedence() == op.precedence() && p.left_associative())
                    }) {
                        q.push(Expr::Op(s.pop().unwrap()));
                    }
                    s.push(p);
                }
                _ => {
                    if t != TokenType::Term {
                        self.pos -= 1;
                    }

                    break;
                }
            };
        }

        s.reverse();
        s.iter().for_each(|&p| q.push(Expr::Op(p)));

        Ok(Some(flatten!(rpn of q)))
    }

    fn parse_list(&mut self) -> Result<Option<Expr>, ParsingError> {
        self.pos += 1;
        self.assert_next(|t| match t {
            TokenType::Ident { .. }
            | TokenType::Num(_)
            | TokenType::Str { .. }
            | TokenType::Bool(_)
            | TokenType::Punct(_)
            // | TokenType::Comment { .. } TODO: handle comments
            => true,
            _ => false,
        })?;

        let from = Box::new(self.parse()?.unwrap());

        self.assert_next(|t| t == TokenType::Punct(Punct::Range))?;

        self.pos += 1;

        let to = Box::new(self.parse()?.unwrap());

        self.pos += 1;

        Ok(Some(Expr::Range { from, to }))
    }

    pub fn parse_all(&mut self) -> Result<Expr, ParsingError> {
        let mut exprs = Vec::new();

        while self.has_next() {
            if let Some(expr) = self.parse()? {
                exprs.push(expr);
            }
        }

        Ok(flatten!(multiple exprs))
    }

    fn parse(&mut self) -> Result<Option<Expr>, ParsingError> {
        let t = match self.peek_next() {
            Some(t) => t,
            _ => return Err("Abrupt end".to_owned()),
        };

        match t {
            TokenType::Term | TokenType::Comment { .. } => {
                self.pos += 1;
                while let Some(TokenType::Term) | Some(TokenType::Comment { .. }) = self.peek_next()
                {
                    self.pos += 1;
                }

                Ok(None)
            }
            TokenType::Keyword(Keyword::Let) => self.parse_declaration(),
            TokenType::Punct(Punct::OpenParen) => {
                // TODO: handle out of index
                if let TokenType::Num(_) = self.buf[self.pos + 1].r#type {
                    // a numeric expr
                    self.parse_numeric()
                } else {
                    // a tuple
                    unimplemented!()
                }
            }
            TokenType::Punct(Punct::OpenBracket) => self.parse_list(),
            TokenType::Num(_) => self.parse_numeric(),
            TokenType::Str { start, end } => {
                self.pos += 1;
                Ok(Some(Expr::Value(Value::Str { start, end })))
            }
            _ => self.unexpected_tok_err(),
        }
    }
}