const std = @import("std");
const scanners = @import("scanners.zig");
const main = @import("main.zig");
const ast = @import("ast.zig");
const tokens = @import("tokens.zig");
const ereport = @import("errors.zig");
const printer = @import("ast_printer.zig");

const Allocator = std.mem.Allocator;
const Scanner = scanners.Scanner;
const Token = tokens.Token;
const TokenType = tokens.TokenType;

pub const ParseError = error{
    CompileError,
    UnknownOperator,
    InvalidInteger,
};

const Node = ast.Node;
const Expr = ast.Expr;
const Stmt = ast.Stmt;

const TokenList = std.ArrayList(Token);

const operator_tokens = [_][]const u8{
    "+", "-", "*", "/", "%", ">", ">=", "<", "<=", "==",
};

const operator_values = [_]ast.BinaryOperator{
    .Add,
    .Sub,
    .Mul,
    .Div,
    .Mod,

    .Greater,
    .GreaterEqual,
    .Less,
    .LessEqual,

    .Equal,
};

fn toBinaryOperator(op: Token) !ast.BinaryOperator {
    const lex = op.lexeme;

    inline for (operator_tokens) |op_str, idx| {
        if (std.mem.eql(u8, lex, op_str)) return operator_values[idx];
    }

    // special cases: && + and => .And and || + or => .Or
    if (std.mem.eql(u8, lex, "&&") or std.mem.eql(u8, lex, "and")) return .And;
    if (std.mem.eql(u8, lex, "||") or std.mem.eql(u8, lex, "or")) return .Or;

    return ParseError.UnknownOperator;
}

const unary_operator_tokens = [_][]const u8{
    "!", "-",
};

const unary_operators = [_]ast.UnaryOperator{
    .Not, .Negate,
};

fn toUnaryOperator(op: Token) !ast.UnaryOperator {
    const lex = op.lexeme;

    inline for (unary_operator_tokens) |op_str, idx| {
        if (std.mem.eql(u8, lex, op_str)) return unary_operators[idx];
    }

    return ParseError.UnknownOperator;
}

pub const Parser = struct {
    allocator: *Allocator,
    scanner: *Scanner,
    tokens: TokenList,

    hadError: bool = false,
    err_ctx: ?[]const u8 = null,

    pub fn init(allocator: *Allocator, scanner: *Scanner) Parser {
        return Parser{
            .allocator = allocator,
            .scanner = scanner,
            .tokens = TokenList.init(allocator),
        };
    }

    pub fn deinit(self: *@This()) void {
        self.tokens.deinit();
    }

    fn setErrContext(self: *Parser, comptime fmt: ?[]const u8, args: anytype) void {
        if (fmt == null) {
            self.err_ctx = null;
            return;
        }

        var buf = self.allocator.alloc(u8, 256) catch unreachable;
        self.err_ctx = std.fmt.bufPrint(buf, fmt.?, args) catch unreachable;
    }

    fn doError(self: *Parser, comptime fmt: []const u8, args: anytype) ParseError {
        self.hadError = true;

        std.debug.warn("parser error at line {}", .{self.scanner.line});
        if (self.err_ctx) |ctx| {
            std.debug.warn(" on {}", .{ctx});
        }

        std.debug.warn("\n\t", .{});

        std.debug.warn(fmt, args);
        std.debug.warn("\n", .{});

        return ParseError.CompileError;
    }

    fn synchronize(self: *Parser) !void {
        // TODO is it nextToken()?
        _ = try self.nextToken();

        while (!self.isAtEnd()) {
            if (self.previous().typ == .Semicolon) return;

            // TODO add more "stmt"-"starting" tokens here
            switch (self.peek().typ) {
                .Fn => return,
                else => {},
            }

            _ = try self.nextToken();
        }
    }

    fn peek(self: *Parser) Token {
        return self.tokens.items[self.tokens.items.len - 1];
    }

    fn previous(self: *Parser) Token {
        return self.tokens.items[self.tokens.items.len - 2];
    }

    fn tokenError(self: *Parser, token: Token, msg: []const u8) ParseError {
        std.debug.warn("ctx: '{}'\n", .{self.err_ctx});
        if (token.typ == .EOF) {
            ereport.report(token.line, " at end", self.err_ctx, msg);
        } else {
            ereport.reportFmt(token.line, self.err_ctx, " at '{}': {}", .{
                token.lexeme,
                msg,
            });
        }

        return ParseError.CompileError;
    }

    fn isAtEnd(self: *Parser) bool {
        return self.peek().typ == .EOF;
    }

    fn check(self: *Parser, typ: TokenType) bool {
        if (self.isAtEnd()) return false;
        return self.peek().typ == typ;
    }

    fn nextToken(self: *Parser) !Token {
        var token: Token = undefined;

        while (true) {
            var next_token_opt = try self.scanner.nextToken();
            if (next_token_opt) |token_nice| {
                token = token_nice;
                break;
            }
        }

        try self.tokens.append(token);
        std.debug.warn("skip to {}\n", .{token});
        return token;
    }

    /// Consume the current token type, then walk to the next token.
    /// Returns the consumed token.
    fn consume(self: *Parser, ttype: TokenType, comptime msg: []const u8) !Token {
        if (self.check(ttype)) {
            var tok = self.peek();
            _ = try self.nextToken();
            return tok;
        }

        return self.tokenError(self.peek(), msg);
    }

    /// Consume the current token. Gives default error messages
    fn consumeSingle(self: *Parser, ttype: TokenType) !Token {
        if (self.check(ttype)) {
            var cur = self.peek();
            _ = try self.nextToken();
            return cur;
        }

        // TODO maybe this could be entirely comptime?
        var buf_main: [1000]u8 = undefined;
        var buf = try std.fmt.bufPrint(&buf_main, "expected {}, got {}", .{
            ttype,
            self.peek().typ,
        });

        return self.tokenError(self.peek(), buf);
    }

    /// check() against multiple tokens
    fn compareAnyOf(self: *@This(), ttypes: []const TokenType) bool {
        for (ttypes) |typ| {
            if (self.check(typ)) return true;
        }

        return false;
    }

    // TODO maybe move helper functions to ast_helper.zig?

    fn mkConstDecl(self: *Parser, consts: ast.ConstList) !*ast.Node {
        var node = try self.allocator.create(Node);
        node.* = Node{ .ConstDecl = consts };
        return node;
    }

    fn mkBlock(self: *Parser, stmts: ast.StmtList) !*ast.Node {
        var node = try self.allocator.create(Node);
        node.* = Node{ .Block = stmts };
        return node;
    }

    fn mkStmtExpr(self: *Parser, expr: *Expr) !*Stmt {
        var stmt = try self.allocator.create(Stmt);
        stmt.* = Stmt{ .Expr = expr };
        return stmt;
    }

    fn mkGrouping(self: *Parser, expr: *Expr) !*ast.Expr {
        var grouping = try self.allocator.create(Expr);
        grouping.* = Expr{ .Grouping = expr };
        return grouping;
    }

    fn mkUnary(self: *Parser, op: ast.UnaryOperator, right: *Expr) !*Expr {
        var expr = try self.allocator.create(Expr);
        expr.* = Expr{
            .Unary = ast.UnaryExpr{
                .op = op,
                .right = right,
            },
        };
        return expr;
    }

    fn mkBinary(self: *Parser, left: *Expr, op: ast.BinaryOperator, right: *Expr) !*Expr {
        var expr = try self.allocator.create(Expr);
        expr.* = Expr{
            .Binary = ast.BinaryExpr{
                .left = left,
                .op = op,
                .right = right,
            },
        };

        return expr;
    }

    fn mkAssign(self: *Parser, name: Token, value: *Expr) !*Expr {
        var expr = try self.allocator.create(Expr);
        expr.* = Expr{
            .Assign = ast.AssignExpr{
                .name = name,
                .value = value,
            },
        };

        return expr;
    }

    fn mkCall(self: *@This(), callee: *Expr, paren: Token, args: ast.ExprList) !*Expr {
        var expr = try self.allocator.create(Expr);
        expr.* = Expr{
            .Call = ast.CallExpr{
                .callee = callee,
                .paren = paren,
                .arguments = args,
            },
        };

        return expr;
    }

    fn mkStructExpr(self: *@This(), name: Token, args: ast.StructInitList) !*Expr {
        var expr = try self.allocator.create(Expr);
        expr.* = Expr{
            .Struct = ast.StructExpr{
                .name = name,
                .inits = args,
            },
        };

        return expr;
    }

    fn mkGet(self: *@This(), target: *Expr, name: Token) !*Expr {
        var expr = try self.allocator.create(Expr);
        expr.* = Expr{
            .Get = ast.GetExpr{
                .target = target,
                .name = name,
            },
        };

        return expr;
    }

    fn mkSet(self: *@This(), struc: *Expr, field: Token, value: *Expr) !*Expr {
        var expr = try self.allocator.create(Expr);
        expr.* = Expr{
            .Set = ast.SetExpr{
                .struc = struc,
                .field = field,
                .value = value,
            },
        };

        return expr;
    }

    fn mkBool(self: *Parser, val: bool) !*ast.Expr {
        var expr = try self.allocator.create(Expr);
        expr.* = Expr{
            .Literal = ast.LiteralExpr{
                .Bool = val,
            },
        };

        return expr;
    }

    fn mkInt32(self: *Parser, val: i32) !*ast.Expr {
        var expr = try self.allocator.create(Expr);
        expr.* = Expr{
            .Literal = ast.LiteralExpr{
                .Integer32 = val,
            },
        };

        return expr;
    }

    fn mkInt64(self: *Parser, val: i64) !*ast.Expr {
        var expr = try self.allocator.create(Expr);
        expr.* = Expr{
            .Literal = ast.LiteralExpr{
                .Integer64 = val,
            },
        };

        return expr;
    }

    fn mkFloat(self: *Parser, val: []const u8) !*ast.Expr {
        var expr = try self.allocator.create(Expr);
        expr.* = Expr{
            .Literal = ast.LiteralExpr{
                .Float = val,
            },
        };

        return expr;
    }

    fn mkString(self: *Parser, val: []const u8) !*ast.Expr {
        var expr = try self.allocator.create(Expr);
        expr.* = Expr{
            .Literal = ast.LiteralExpr{
                .String = val,
            },
        };

        return expr;
    }

    fn mkArray(self: *Parser, exprs: ast.ExprList) !*ast.Expr {
        var expr = try self.allocator.create(Expr);
        expr.* = Expr{
            .Literal = ast.LiteralExpr{
                .Array = exprs,
            },
        };

        return expr;
    }

    fn mkVariable(self: *Parser, tok: Token) !*ast.Expr {
        var expr = try self.allocator.create(Expr);
        expr.* = Expr{ .Variable = tok };

        return expr;
    }

    pub fn parse(self: *Parser) !?*ast.Node {
        var root = try Node.mkRoot(self.allocator);

        var token_opt: ?Token = null;

        while (true) {
            if (token_opt == null) {
                token_opt = try self.nextToken();
            } else {
                token_opt = self.peek();
            }

            var token = token_opt.?;
            if (token.typ == .EOF) break;

            var node = self.parseTopDecl() catch |err| {
                if (err == ParseError.CompileError) return null;
                return err;
            };
            try root.Root.append(node.*);
        }

        if (self.hadError) {
            return error.ParseError;
        }

        return root;
    }

    /// Copy a token with a different lexeme.
    fn mkToken(self: *@This(), ttype: TokenType, lexeme: []const u8, line: usize) !Token {
        const owned_lexeme = try std.mem.dupe(self.allocator, u8, lexeme);
        return Token{
            .typ = ttype,
            .lexeme = owned_lexeme,
            .line = line,
        };
    }

    fn parseFnDecl(self: *@This()) !*Node {
        var param_list = ast.ParamList.init(self.allocator);
        errdefer param_list.deinit();

        var method: ?*ast.MethodData = null;

        _ = try self.consumeSingle(.Fn);

        if (self.check(.LeftParen)) {
            method = try self.parsePreMethod();
        }

        const orig_name = try self.consumeSingle(.Identifier);

        const name = if (std.mem.eql(u8, orig_name.lexeme, "main")) blk: {
            break :blk try self.mkToken(.Identifier, "__rayoko_main", orig_name.line);
        } else blk: {
            break :blk orig_name;
        };

        self.setErrContext("function {}", .{name.lexeme});

        _ = try self.consumeSingle(.LeftParen);

        while (self.peek().typ != .RightParen) {
            const param_name = try self.consumeSingle(.Identifier);
            _ = try self.consumeSingle(.Colon);
            const param_type = try self.consumeSingle(.Identifier);

            try param_list.append(ast.ParamDecl{
                .name = param_name,
                .typ = param_type,
            });

            if (self.check(.Comma)) _ = try self.consumeSingle(.Comma);
        }

        _ = try self.consumeSingle(.RightParen);

        // the return type is default void if a type
        // is not provided
        var return_type: Token = undefined;
        if (self.check(.Identifier)) {
            return_type = try self.consumeSingle(.Identifier);
        } else {
            return_type = try self.mkToken(.Identifier, "void", name.line);
        }

        var block_node = try self.parseBlock();
        return try Node.mkFnDecl(
            self.allocator,
            name,
            param_list,
            return_type,
            block_node.Block,
            method,
        );
    }

    /// parse the (v T) part of the method (defined here
    /// as a premethod)
    fn parsePreMethod(self: *@This()) !?*ast.MethodData {
        _ = try self.consumeSingle(.LeftParen);

        const variable = try self.consumeSingle(.Identifier);
        const typ = try self.consumeSingle(.Identifier);

        _ = try self.consumeSingle(.RightParen);

        // create method data and assign the values we got into it
        var method = try self.allocator.create(ast.MethodData);
        method.* = ast.MethodData{
            .variable = variable,
            .typ = typ,
        };

        return method;
    }

    fn parseConstDecl(self: *@This()) !*Node {
        var consts = ast.ConstList.init(self.allocator);
        errdefer consts.deinit();

        self.setErrContext("const", .{});

        _ = try self.consumeSingle(.Const);
        _ = try self.consumeSingle(.LeftParen);

        while (self.peek().typ != .RightParen) {
            const const_name = try self.consumeSingle(.Identifier);
            self.setErrContext("const {}", .{const_name});

            _ = try self.consumeSingle(.Equal);

            // const declarations dont have type, a future type system must
            // check the output type of the expression and assign it to the
            // const later on.

            var expr = try self.parseExpr();
            try consts.append(ast.SingleConst{
                .name = const_name,
                .expr = expr,
            });
        }

        _ = try self.consumeSingle(.RightParen);
        return self.mkConstDecl(consts);
    }

    fn parseStructDecl(self: *@This()) !*Node {
        var fields = ast.FieldList.init(self.allocator);
        errdefer fields.deinit();
        self.setErrContext("struct", .{});

        _ = try self.consumeSingle(.Struct);
        var name = try self.consumeSingle(.Identifier);

        self.setErrContext("struct {}", .{name});

        _ = try self.consumeSingle(.LeftBrace);

        while (!self.check(.RightBrace)) {
            const field_name = try self.consumeSingle(.Identifier);
            self.setErrContext("struct {} field {}", .{ name, field_name });

            const field_type = try self.consumeSingle(.Identifier);
            try fields.append(ast.StructField{
                .name = field_name,
                .typ = field_type,
            });
        }

        _ = try self.consumeSingle(.RightBrace);

        return Node.mkStructDecl(self.allocator, name, fields);
    }

    fn parseEnumDecl(self: *@This()) !*Node {
        var fields = ast.TokenList.init(self.allocator);
        errdefer fields.deinit();

        self.setErrContext("enum", .{});

        _ = try self.consumeSingle(.Enum);
        const name = try self.consumeSingle(.Identifier);

        self.setErrContext("enum {}", .{name});

        _ = try self.consumeSingle(.LeftBrace);

        while (!self.check(.RightBrace)) {
            try fields.append(try self.consumeSingle(.Identifier));
        }

        _ = try self.consumeSingle(.RightBrace);

        return try Node.mkEnumDecl(self.allocator, name, fields);
    }

    fn parseTopDecl(self: *@This()) !*Node {
        self.setErrContext(null, .{});

        return switch (self.peek().typ) {
            .Fn => try self.parseFnDecl(),
            .Const => try self.parseConstDecl(),
            .Struct => try self.parseStructDecl(),
            .Enum => try self.parseEnumDecl(),

            else => |typ| blk: {
                return self.doError("expected Fn, Const, Struct, got {}\n", .{typ});
            },
        };
    }

    fn parseBlockInternal(self: *@This(), comptime T: type) !T {
        var stmts = T.init(self.allocator);
        errdefer stmts.deinit();

        _ = try self.consumeSingle(.LeftBrace);

        while (self.peek().typ != .RightBrace) {
            var stmt = try self.parseStmt();
            printer.printStmt(0, stmt);

            if (self.check(.Semicolon))
                _ = try self.consumeSingle(.Semicolon);
            try stmts.append(stmt.*);
        }

        _ = try self.consumeSingle(.RightBrace);

        return stmts;
    }

    fn parseStmt(self: *@This()) anyerror!*Stmt {
        return switch (self.peek().typ) {
            .Var => try self.parseVarDecl(),
            .If => try self.parseIfStmt(),
            .Loop => try self.parseLoop(),
            .For => try self.parseForStmt(),
            .Println => try self.parsePrintln(),
            .Return => try self.parseReturn(),
            else => try self.parseStmtExpr(),
        };
    }

    fn parseVarDecl(self: *@This()) !*Stmt {
        _ = try self.consumeSingle(.Var);
        var name = try self.consumeSingle(.Identifier);
        _ = try self.consumeSingle(.Equal);
        var value = try self.parseExpr();
        return try Stmt.mkVarDecl(self.allocator, name, value);
    }

    /// Parse a list of statements.
    fn parseBlock(self: *@This()) !*Node {
        var stmts = try self.parseBlockInternal(ast.StmtList);
        return try self.mkBlock(stmts);
    }

    /// parse blocks inside statements
    fn parseStmtBlock(self: *@This()) !ast.Block {
        var block = try self.parseBlockInternal(ast.Block);
        return block;
    }

    fn parseIfStmt(self: *@This()) !*Stmt {
        _ = try self.consumeSingle(.If);
        _ = try self.consumeSingle(.LeftParen);
        var condition = try self.parseExpr();
        _ = try self.consumeSingle(.RightParen);

        const then_branch = try self.parseStmtBlock();

        var else_branch: ?ast.Block = null;

        if (self.check(.Else)) {
            _ = try self.consumeSingle(.Else);
            else_branch = try self.parseStmtBlock();
        }

        return try Stmt.mkIfStmt(
            self.allocator,
            condition,
            then_branch,
            else_branch,
        );
    }

    fn parseForStmt(self: *@This()) !*Stmt {
        // There are two types of for in vig's V subset:
        //  - for x in y
        //  - for idx, x in y
        _ = try self.consumeSingle(.For);

        var index_var: ?Token = null;
        var value_var: Token = undefined;

        const subject_1 = try self.consumeSingle(.Identifier);

        if (self.check(.Comma)) {
            _ = try self.consumeSingle(.Comma);

            const subject_2 = try self.consumeSingle(.Identifier);
            index_var = subject_1;
            value_var = subject_2;
        } else {
            value_var = subject_1;
        }

        _ = try self.consumeSingle(.In);

        // MUST be identifier
        var array = try self.consumeSingle(.Identifier);
        var block = try self.parseStmtBlock();

        return try Stmt.mkFor(
            self.allocator,
            index_var,
            value_var,
            array,
            block,
        );
    }

    fn parseLoop(self: *@This()) !*Stmt {
        _ = try self.consumeSingle(.Loop);
        var expr: ?*Expr = null;
        var body: ast.Block = undefined;

        // 'loop {' = infinite loop
        if (self.check(.LeftBrace)) {
            body = try self.parseStmtBlock();
        } else {
            expr = try self.parseExpr();
            body = try self.parseStmtBlock();
        }

        return try Stmt.mkLoop(self.allocator, expr, body);
    }

    fn parseReturn(self: *@This()) !*Stmt {
        const tok = try self.consumeSingle(.Return);
        // TODO if (self.check(.Semicolon)) insert a void literal?
        const expr = try self.parseExpr();
        return try Stmt.mkReturn(self.allocator, tok, expr);
    }

    fn parsePrintln(self: *@This()) !*Stmt {
        _ = try self.consumeSingle(.Println);

        _ = try self.consumeSingle(.LeftParen);
        var expr = try self.parseExpr();
        _ = try self.consumeSingle(.RightParen);

        return try Stmt.mkPrintln(self.allocator, expr);
    }

    fn parseStmtExpr(self: *@This()) !*Stmt {
        var expr = try self.parseExpr();
        return try self.mkStmtExpr(expr);
    }

    fn parseExpr(self: *@This()) anyerror!*Expr {
        return try self.parseAssignment();
    }

    fn parseAssignment(self: *@This()) anyerror!*Expr {
        // there can be two assignments coming out of this function:
        //  - an assignment to a variable with =
        //  - an update to a variable with +=, -=
        var expr = try self.parseOr();

        if (self.compareAnyOf(&[_]TokenType{
            .Equal,      .PlusEqual, .MinusEqual, .StarEqual,
            .SlashEqual,
        })) {
            return try self.finishAssignment(expr);
        }

        return expr;
    }

    fn finishAssignment(
        self: *@This(),
        expr: *Expr,
    ) !*Expr {
        var op_tok = self.peek();
        _ = try self.nextToken();

        var value = try self.parseAssignment();

        // expr can be a (Variable|Set)
        // op_tok can be one of two categories:
        //  - Equal, parses to (Assign|Set)
        //  - Inplace (+=, -=, *=, /=), parses to (Assign|Set)

        // however, when dealing with inplace operators, we want those to parse
        // to an assign/set with a binary expression with the undelying operator
        // instead of the infix operator.
        // e.g 'x += 1' parses down to 'x = x + 1'

        // TODO do we add %=?
        const binop: ?ast.BinaryOperator = switch (op_tok.typ) {
            .PlusEqual => ast.BinaryOperator.Add,
            .MinusEqual => .Sub,
            .StarEqual => .Mul,
            .SlashEqual => .Div,
            else => null,
        };

        switch (expr.*) {
            .Variable => {
                switch (op_tok.typ) {
                    .Equal => return try self.mkAssign(expr.Variable, value),

                    .PlusEqual, .MinusEqual, .StarEqual, .SlashEqual => {
                        return try self.mkAssign(
                            expr.Variable,
                            try self.mkBinary(expr, binop.?, value),
                        );
                    },

                    else => unreachable,
                }
            },

            .Get => |get| {
                switch (op_tok.typ) {
                    // TODO remove .ColonEqual from language
                    .ColonEqual => {
                        return self.doError("can not initialize struct field", .{});
                    },

                    .Equal => return try self.mkSet(get.target, get.name, value),

                    .PlusEqual, .MinusEqual, .StarEqual, .SlashEqual => {
                        return try self.mkSet(
                            get.target,
                            get.name,
                            try self.mkBinary(expr, binop.?, value),
                        );
                    },

                    else => unreachable,
                }
            },

            else => |expr_typ| {
                return self.doError("Invalid assignment target {}", .{expr_typ});
            },
        }
    }

    fn parseOr(self: *@This()) !*Expr {
        var expr = try self.parseAnd();

        while (self.check(.Or)) {
            var op = self.peek();
            _ = try self.nextToken();

            var right = try self.parseAnd();
            expr = try self.mkBinary(expr, try toBinaryOperator(op), right);
        }

        return expr;
    }

    fn parseAnd(self: *@This()) !*Expr {
        var expr = try self.parseEquality();

        while (self.check(.And)) {
            var op = self.peek();
            _ = try self.nextToken();

            var right = try self.parseEquality();
            expr = try self.mkBinary(expr, try toBinaryOperator(op), right);
        }

        return expr;
    }

    fn parseEquality(self: *@This()) !*Expr {
        var expr = try self.parseComparison();

        while (self.check(.EqualEqual)) {
            var op = self.peek();
            _ = try self.nextToken();

            var right = try self.parseComparison();
            expr = try self.mkBinary(expr, .Equal, right);
        }

        return expr;
    }

    fn parseComparison(self: *@This()) !*Expr {
        var expr = try self.parseAddition();

        while (self.compareAnyOf(&[_]TokenType{
            .Greater,
            .GreaterEqual,
            .Less,
            .LessEqual,
        })) {
            var op = self.peek();
            _ = try self.nextToken();

            var right = try self.parseAddition();
            expr = try self.mkBinary(expr, try toBinaryOperator(op), right);
        }

        return expr;
    }

    fn parseAddition(self: *@This()) !*Expr {
        var expr = try self.parseMultiplication();

        while (self.compareAnyOf(&[_]TokenType{
            .Minus, .Plus,
        })) {
            var op = self.peek();
            _ = try self.nextToken();

            var right = try self.parseMultiplication();
            expr = try self.mkBinary(expr, try toBinaryOperator(op), right);
        }

        return expr;
    }

    fn parseMultiplication(self: *@This()) !*Expr {
        var expr = try self.parseUnary();

        while (self.compareAnyOf(&[_]TokenType{
            .Star, .Slash,
        })) {
            var op = self.peek();
            _ = try self.nextToken();
            var right = try self.parseUnary();

            expr = try self.mkBinary(expr, try toBinaryOperator(op), right);
        }

        return expr;
    }

    fn parseUnary(self: *@This()) anyerror!*Expr {
        if (self.compareAnyOf(&[_]TokenType{ .Bang, .Minus })) {
            var op = self.peek();
            _ = try self.nextToken();
            var right = try self.parseCall();

            return try self.mkUnary(try toUnaryOperator(op), right);
        }

        var expr = try self.parseCall();
        return expr;
    }

    /// Parse either:
    ///  - A function call
    ///  - A struct initialization (Point.{...})
    ///  - A struct Get expression (p.x)
    fn parseCall(self: *@This()) !*Expr {
        var expr = try self.parsePrimary();

        while (true) {
            if (self.check(.LeftParen)) {
                _ = try self.consumeSingle(.LeftParen);
                expr = try self.finishCall(expr);
            } else if (self.check(.Dot)) {
                _ = try self.consumeSingle(.Dot);

                if (self.check(.LeftBrace)) {
                    _ = try self.consumeSingle(.LeftBrace);
                    expr = try self.finishStructVal(expr);
                } else {
                    var name = try self.consume(
                        .Identifier,
                        "Expect property name after '.'",
                    );

                    expr = try self.mkGet(expr, name);
                }
            } else {
                //return self.tokenError(self.peek(), "Expect expression.");
                break;
            }
        }

        return expr;
    }

    fn finishCall(self: *@This(), callee: *Expr) !*Expr {
        var args = ast.ExprList.init(self.allocator);
        errdefer args.deinit();

        if (!self.check(.RightParen)) {

            // emulating do-while really badly
            var arg = try self.parseExpr();
            try args.append(arg.*);

            while (self.check(.Comma)) {
                _ = try self.consumeSingle(.Comma);

                arg = try self.parseExpr();
                try args.append(arg.*);
            }
        }

        var paren = try self.consume(.RightParen, "Expected ')' after arguments");

        return self.mkCall(callee, paren, args);
    }

    fn finishStructVal(self: *@This(), expr: *Expr) !*Expr {
        // <expr>{a: 10 b: 10}
        // for this to work properly, <expr> must be Variable, since its a type.
        const expr_type = @as(ast.ExprType, expr.*);
        if (expr_type != .Variable) {
            return self.doError("Expected variable for struct type, got {}", .{expr_type});
        }

        var inits = ast.StructInitList.init(self.allocator);
        errdefer inits.deinit();

        while (!self.check(.RightBrace)) {
            const field_name = try self.consumeSingle(.Identifier);
            // TODO check .Comma for the quick initialization {val,val,val}

            _ = try self.consumeSingle(.Colon);
            const field_value = try self.parseExpr();

            try inits.append(ast.StructInit{
                .field = field_name,
                .expr = field_value,
            });
        }

        _ = try self.consumeSingle(.RightBrace);

        return try self.mkStructExpr(expr.Variable, inits);
    }

    fn parsePrimary(self: *@This()) !*Expr {
        const curtype = self.peek().typ;
        const lexeme = self.peek().lexeme;

        var expr = switch (curtype) {
            .False => try self.mkBool(false),
            .True => try self.mkBool(true),

            .Integer => blk: {
                // hacky, but it works. the old approach was doing
                // parseInt(i64) on the catch block of parseInt(i32)
                var i32_num_opt: ?i32 = std.fmt.parseInt(i32, lexeme, 10) catch null;
                var i64_num: i64 = std.fmt.parseInt(i64, lexeme, 10) catch |err| {
                    return self.doError("Invalid integer (not 32bit or 64bit) '{}': {}", .{
                        lexeme,
                        err,
                    });
                };

                if (i32_num_opt) |i32_num| {
                    break :blk try self.mkInt32(i32_num);
                } else {
                    break :blk try self.mkInt64(i64_num);
                }

                // old one

                //break :blk try self.mkInt32(std.fmt.parseInt(i32, lexeme, 10) catch |err32| {
                //    break :blk try self.mkInt64(std.fmt.parseInt(i64, lexeme, 10) catch |err64| {
                //        return self.doError(
                //            "Invalid integer (not 32bit or 64bit) '{}': {}",
                //            lexeme,
                //            err64,
                //        );
                //    });
                //});
            },

            // TODO std.fmt.parseFloat
            .Float => try self.mkFloat(lexeme),

            .String => try self.mkString(lexeme),
            .Identifier => try self.mkVariable(self.peek()),

            // type checking for arrays happens at later stages
            .LeftSquare => {
                _ = try self.consumeSingle(.LeftSquare);

                var exprs = ast.ExprList.init(self.allocator);
                errdefer exprs.deinit();

                while (!self.check(.RightSquare)) {
                    try exprs.append((try self.parseExpr()).*);
                    if (self.check(.Comma)) _ = try self.consumeSingle(.Comma);
                }

                _ = try self.consumeSingle(.RightSquare);
                return try self.mkArray(exprs);
            },

            .LeftParen => {
                _ = try self.nextToken();
                var expr = try self.parseExpr();
                _ = try self.consume(.RightParen, "Expected ')' after expression");

                // for groupings, we don't want to skip tokens as we already
                // consumed RightParen.
                return try self.mkGrouping(expr);
            },

            else => blk: {
                return self.doError("expected literal, got {}", .{curtype});
            },
        };

        _ = try self.nextToken();
        return expr;
    }
};