import { Instruction } from "./ir";
import { Expr } from "./parsed";
import { assertExhaustive } from "./utils";


export class Compiler {
    public result: Instruction[] = [];

    public compileExpr(expr: Expr) {
        switch (expr.exprType) {
            case "int": {
                this.result.push({ type: "load", register: "acc", value: expr.value })
                break;
            }
            case "unary": {
                this.compileExpr(expr.subject);
                switch (expr.unaryType) {
                    case "plus": {
                        break;
                    }
                    case "negate": {
                        this.result.push({ type: "negate", src: "acc", dest: "acc" })
                        break;
                    }
                }
                break;
            }
            case "binary": {
                this.compileExpr(expr.right);
                this.result.push({ type: "push", register: "acc" })
                this.compileExpr(expr.left);
                this.result.push({ type: "pop", register: "op" });
                let binaryType: "add" | "sub" | "mul" | "div";
                switch (expr.binaryType) {
                    case "add": {
                        binaryType = "add";
                        break;
                    }
                    case "subtract": {
                        binaryType = "sub";
                        break;
                    }
                    case "multiply": {
                        binaryType = "mul";
                        break;
                    }
                    case "divide": {
                        binaryType = "div";
                        break;
                    }
                }
                this.result.push({ type: binaryType, left: "acc", right: "op", dest: "acc" });
                break;
            }
            case "if": {
                this.compileExpr(expr.condition);

                const jumpToFalsyIndex = this.result.length;
                this.result.push({ type: "jump_zero", register: "acc", location: 0 });

                this.compileExpr(expr.truthy);

                const skipFalsyIndex = this.result.length;
                this.result.push({ type: "jump", location: 0 });

                let jumpToFalsyRef = this.result[jumpToFalsyIndex];
                if (jumpToFalsyRef.type !== "jump_zero") throw new Error("unreachable");
                jumpToFalsyRef.location = this.result.length;

                this.compileExpr(expr.falsy);

                let skipFalsyRef = this.result[skipFalsyIndex];
                if (skipFalsyRef.type !== "jump") throw new Error("unreachable");
                skipFalsyRef.location = this.result.length;

                break;
            }
            case "block": {
                this.compileExpr(expr.expr);
                break;
            }
            default: {
                assertExhaustive(expr);
            }
        }
    }
}

export function locateAndSetJumpedToInstructions(instructions: Instruction[]) {
    let nextLabel = 0;
    for (const ins of instructions) {
        if (ins.type === "jump_zero" || ins.type === "jump") {
            instructions[ins.location] = {
                ...instructions[ins.location],
                jumpedTo: true,
                label: nextLabel,
            };
            nextLabel += 1;
        }
    }
}