pub const AstNodeType = enum {
    Program,
    BinOp,
    Number,
};

pub const AstNode = union(AstNodeType) {
    Program: []AstNode,
    BinOp: AstBinOp,
    Number: AstNumber,
};

pub const BinOpType = enum {
    Equality,
};

pub const AstBinOp = struct {
    optype: BinOpType,

    // TODO expression
    left: *AstNode,
    right: *AstNode,
};

pub const NumberType = enum {
    Integer32,
    Integer64,
    Unsigned32,
    Unsigned64,
    Float32,
    Float64,
};

pub const AstNumber = union(NumberType) {
    Integer32: i32,
    Integer64: i64,
    Unsigned32: u32,
    Unsigned64: u64,
    Float32: f32,
    Float64: f64,
};

pub fn printNode(stdout: var, node: AstNode) anyerror!void {
    switch (node) {
        .Program => |children| try printNodes(stdout, children),
        .BinOp => |bin_op| blk: {
            try stdout.print("(");
            switch (bin_op.optype) {
                .Equality => try stdout.write("=="),
            }

            try stdout.write(" ");
            try printNode(stdout, bin_op.left.*);
            try stdout.write(" ");
            try printNode(stdout, bin_op.right.*);
            try stdout.print(")");
        },
        .Number => |ast_num| {
            switch (ast_num) {
                .Integer32 => |num| try stdout.print("{}", num),
                .Integer64 => |num| try stdout.print("{}", num),
                .Unsigned32 => |num| try stdout.print("{}", num),
                .Unsigned64 => |num| try stdout.print("{}", num),
                .Float32 => |num| try stdout.print("{}", num),
                .Float64 => |num| try stdout.print("{}", num),
            }
        },
    }
}

fn printNodes(stdout: var, nodes: []AstNode) anyerror!void {
    try stdout.print("(");

    for (nodes) |node| {
        try stdout.print(" ");
        try printNode(stdout, node);
    }

    try stdout.print(")");
}