require_relative "error"
require_relative "expr"
require_relative "stmt"

module Lox
  class Parser

    def initialize(tokens)
      @tokens = tokens
      @current = 0
    end

    def parse!
      statements = []
      until eot?
        statements << declaration
      end
      statements
    rescue ParseError
      synchronize!
    end

    private

    def declaration
      return function("function") if match?(:FUN)
      return var_declaration if match?(:VAR)

      statement
    end

    def var_declaration
      name = consume!(:IDENTIFIER, "Expect variable name.")
      initializer = match?(:EQUAL) ? expression : nil
      consume!(:SEMICOLON, "Expect ';' after variable declaration.")

      Stmt::Var.new(name, initializer)
    end

    def while_stmt
      consume!(:LEFT_PAREN, "Expect '(' after 'if'.")
      cond = expression
      consume!(:RIGHT_PAREN, "Expect ')' after 'if'.")
      body = statement

      Stmt::While.new(cond, body)
    end

    def statement
      return for_stmt if match?(:FOR)
      return if_stmt if match?(:IF)
      return print if match?(:PRINT)
      return while_stmt if match?(:WHILE)
      return Stmt::Block.new(block) if match?(:LEFT_BRACE)

      expression_stmt
    end

    def for_stmt
      consume!(:LEFT_PAREN, "Expect '(' after 'if'.")

      initializer = if match?(:SEMICOLON)
                      nil
                    elsif match?(:VAR)
                      var_declaration
                    else
                      expression_stmt
                    end

      condition = !check?(:SEMICOLON) ? expression : Expr::Literal(true)
      consume!(:SEMICOLON, "Expect ';' after loop condition.")

      increment = !check?(:RIGHT_PAREN) ? expression : nil
      consume!(:RIGHT_PAREN, "Expect ')' after for clauses.")

      body = statement

      if increment
        body = Stmt::Block.new([
          body,
          Stmt::Expr.new(increment),
        ])
      end

      body = Stmt::While.new(condition, body);

      if initializer
        body = Stmt::Block.new([
          initializer,
          body,
        ])
      end

      body
    end

    def if_stmt
      consume!(:LEFT_PAREN, "Expect '(' after 'if'.")
      cond = expression
      consume!(:RIGHT_PAREN, "Expect ')' after 'if'.")

      then_stmt = statement
      else_stmt = match?(:ELSE) ? statement : nil

      Stmt::If.new(cond, then_stmt, else_stmt)
    end

    def print
      value = expression
      consume!(:SEMICOLON, "Expect ';' after value.")
      Stmt::Print.new(value)
    end

    def expression_stmt
      value = expression
      consume!(:SEMICOLON, "Expect ';' after value.")
      Stmt::Expr.new(value)
    end

    def function(kind)
      name = consume!(:IDENTIFIER, "Expect #{kind} name.")
      consume!(:LEFT_PAREN, "Expect '(' after #{kind} name.")
      params = []
      unless check?(:RIGHT_PAREN)
        loop do
          raise ParseError.new(peek, "Can't have more than 255 parameters.") if params.size >= 255

          params << consume!(:IDENTIFIER, "Expect parameter name.")
          break unless match?(:COMMA)
        end
      end
      consume!(:RIGHT_PAREN, "Expect ')' after parameters.")

      consume!(:LEFT_BRACE, "Expect '{' before #{kind} body.")
      body = block

      Stmt::Function.new(name, params, body)
    end

    def block
      statements = []
      until check?(:RIGHT_BRACE) || eot?
        statements << declaration
      end
      consume!(:RIGHT_BRACE, "Expect '}' after block.")
      statements
    end

    def assignment
      expr = or_

      if match?(:EQUAL)
        eq = prev
        value = assignment

        raise ParseError.new(eq, "Invalid assignment target.") unless expr.instance_of?(Expr::Variable)

        return Expr::Assign.new(expr.name, value)
      end

      expr
    end

    def or_
      expr = and_

      while match?(:OR)
        op = prev
        right = and_
        expr = Expr::Logical.new(expr, op, right)
      end

      expr
    end

    def and_
      expr = equality

      while match?(:AND)
        op = prev
        right = equality
        expr = Expr::Logical.new(expr, op, right)
      end

      expr
    end

    def expression = assignment

    def equality
      expr = comparison

      while match?(:BANG_EQUAL, :EQUAL_EQUAL)
        op = prev
        right = comparison
        expr = Expr::Binary.new(expr, op, right)
      end

      expr
    end

    def comparison
      expr = term

      while match?(:GREATER, :GREATER_EQUAL, :LESS, :LESS_EQUAL)
        op = prev
        right = term
        expr = Expr::Binary.new(expr, op, right)
      end

      expr
    end

    def term
      expr = factor

      while match?(:MINUS, :PLUS)
        op = prev
        right = factor
        expr = Expr::Binary.new(expr, op, right)
      end

      expr
    end

    def factor
      expr = unary

      while match?(:SLASH, :STAR)
        op = prev
        right = unary
        expr = Expr::Binary.new(expr, op, right)
      end

      expr
    end

    def unary
      return call unless match?(:BANG, :MINUS)

      op = prev
      right = unary
      Expr::Unary.new(op, right)
    end

    def call
      expr = primary

      loop do
        if match?(:LEFT_PAREN)
          expr = finish_call(expr)
        else
          break
        end
      end

      expr
    end

    def finish_call(callee)
      args = []
      if !check?(:RIGHT_PAREN)
        loop do
          raise ParseError.new(peek,  "Can't have more than 255 arguments.") if args.size >= 255

          args << expression
          break unless match?(:COMMA)
        end
      end

      paren = consume!(:RIGHT_PAREN, "Expect ')' after arguments.")

      Expr::Call.new(callee, paren, args)
    end

    def primary
      return Expr::Literal.new(false) if match?(:FALSE)
      return Expr::Literal.new(true) if match?(:TRUE)
      return Expr::Literal.new(nil) if match?(:NIL)
      return Expr::Literal.new(prev.literal) if match?(:NUMBER, :STRING)
      return Expr::Variable.new(prev) if match?(:IDENTIFIER)

      if match?(:LEFT_PAREN)
        expr = expression
        consume!(:RIGHT_PAREN, "Expect ')' after expression.")
        return Expr::Grouping.new(expr)
      end

      raise ParseError.new(peek, "Expect expression.")
    end

    private

    def match?(*types)
      return false unless check?(*types)

      advance!
      return true
    end

    def consume!(type, message)
      raise ParseError.new(peek, message) unless check?(type)

      advance!
    end

    def check?(*types)
      return false if eot?

      types.include?(peek.type)
    end

    def advance!
      @current += 1 unless eot?
      prev
    end

    def eot? = peek.type === :EOF
    def peek = @tokens.fetch(@current)
    def prev = @tokens.fetch(@current - 1)

    def synchronize!
      advance!

      until eot?
        return if prev.type == :SEMICOLON
        return if %i[CLASS FUN VAR FOR IF WHILE PRINT RETURN].include?(peek.type)

        advance!
      end
    end

  end
end