using System;
using System.Collections.Generic;

using Lexer;

namespace Parser
{
    public class Parser
    {
        Lexer.Lexer lexer;

        public Parser(string prg)
        {
            lexer = new Lexer.Lexer(prg);
        }

        public Parser(Lexer.Lexer lexer)
        {
            this.lexer = lexer;
        }

        public bool LookUp(Token.Type type)
        {
            if (lexer.Peek().type == type) return true;
            else return false;
        }

        public bool LookUp(String s)
        {
            if (lexer.Peek().lexeme == s) return true;
            else return false;
        }

        public Token GetToken()
        {
            var t = lexer.Next();
            return t;
        }

        public Statement Parse()
        {
            if (LookUp(Token.Type.EOF))
            {
                GetToken();
                return null ;
            }


            var head = StmtU();
            var tail = StmtT();
            if (tail == null)
            {
                return head;
            }
            return new SequenceStatement(head, tail);
        }

        public Statement StmtT()
        {
            if (LookUp(Token.Type.SEP) && LookUp(";"))
            {
                GetToken();                 // ;
                var head = StmtU();
                var tail = StmtT();
                if (tail == null)
                {
                    return head;
                }
                return new SequenceStatement(head, tail);
            }
            else
            {
                return null;
            }
        }


        public Statement StmtU()
        {
            if (LookUp(Token.Type.ID))
            {
                var asn = Asn();
                return asn;
            }
            else if (LookUp(Token.Type.KEYW))
            {
                var pr = Print();
                return pr;
            }
            else
            {
                var t = GetToken();
                throw new Exception("Expected ID or print: " + t.type + " " + t.lexeme + " c: " + t.column + " l: " + t.line);
            }
        }

        public AssignmentStatement Asn()
        {
            var id = GetToken().lexeme;
            GetToken();         // :=
            var expr = ExprE();
            return new AssignmentStatement(id, expr);
        }

        public PrintStatement Print()
        {
            GetToken();             // print
            GetToken();             // (
            var exprList = ExprL();
            GetToken();             // )
            return new PrintStatement(exprList);
        }

        public Expression ExprE()
        {
            if (LookUp(Token.Type.ID) || LookUp(Token.Type.NUM) || LookUp(Token.Type.SEP))
            {
                var g = ExprG();
                var f = ExprF();

                if (f == null)
                {
                    return g;
                }
                else
                {
                    return new BinaryOperatorExpression(BinaryOperatorExpression.Type.ADD, g, f);
                }

            }
            var t = GetToken();
            throw new Exception("Ex ID, num or LetExpression: " + t.type + " " + t.lexeme + " c: " + t.column + " l: " + t.line);
        }

        public Expression ExprF()
        {
            if (LookUp(Token.Type.OP) && LookUp("+"))
            {
                GetToken();             // +
                var g = ExprG();
                var f = ExprF();

                if (f == null)
                {
                    return g;
                }
                else
                {
                    return new BinaryOperatorExpression(BinaryOperatorExpression.Type.ADD, g, f);
                }
            }
            else return null;
        }

        public Expression ExprG()
        {
            if (LookUp(Token.Type.ID))
            {
                return Ident();
            }
            else if (LookUp(Token.Type.NUM))
            {
                return Num();
            }
            else if (LookUp(Token.Type.SEP))
            {
                return LE();
            }
            var t = GetToken();
            throw new Exception("Expected ID, num or LetExpression: " + t.type + " " + t.lexeme + " c: " + t.column + " l: " + t.line);

        }

        public IdentifierExpression Ident()
        {
            var id = GetToken().lexeme;
            return new IdentifierExpression(id);
        }

        public NumberExpression Num()
        {
            var n = GetToken().lexeme;
            return new NumberExpression(n);
        }

        public LetExpression LE()
        {
            GetToken();             // (
            var st = Parse();

            GetToken();             // ,
            var ex = ExprE();

            GetToken();              // )


            return new LetExpression(st, ex);
        }



        public LinkedList<Expression> ExprL()
        {
            var head = ExprE();
            var tail = ExprM();
            if (tail == null)
            {
                var list = new LinkedList<Expression>();
                list.AddFirst(head);
                return list;
            }
            tail.AddFirst(head);
            return tail;
        }

        public LinkedList<Expression> ExprM()
        {
            if (LookUp(","))
            {
                GetToken();             // ,
                var head = ExprE();

                var tail = ExprM();
                if (tail == null)
                {
                    var list = new LinkedList<Expression>();
                    list.AddFirst(head);
                    return list;
                }
                tail.AddFirst(head);
                return tail;
            }
            else
            {
                return null;
            }
        }
    }
}