import { R8 } from "../sm83/cpu"
import { Loc, LocType } from "../ir/loc"
import type { Operand, SSA, SSABinary, SSACopy, SSAUnary } from "../ir/ssa"
import type { RegAlloc } from "../regalloc"
import { UnaryOp } from "../ast"

export const generateBlock = (alloc: RegAlloc, block: Array<SSA>): Array<string> => {
    const output: Array<string> = []

    block.forEach(ssa => {
        output.push(...generateSSA(alloc, ssa))
    })

    return output
}

export const generateSSA = (alloc: RegAlloc, ssa: SSA): Array<string> => {
    let output: Array<string> = []

    if ("source1" in ssa) {
        output = generateSSA_Binary(alloc, ssa)
    } else if ("op" in ssa) {
        output = generateSSA_Unary(alloc, ssa)
    } else {
        output = generateSSA_Copy(alloc, ssa)
    }

    return output
}

export const generateSSA_Copy = (alloc: RegAlloc, ssa: SSACopy): Array<string> => {
    const output: Array<string> = []

    const source = typeof ssa.source === 'number'
        ? ssa.source.toString()
        : getAlloc(alloc, ssa.source).name

    switch (ssa.dest.type) {
        case LocType.TEMPORARY:
            const dest = getAlloc(alloc, ssa.dest)
            // TODO: Remove later with peephole optimizer
            if (dest.name !== source) {
                output.push(`LD ${dest.name}, ${source}`)
            }
            break

        case LocType.REGISTER:
            if (isA(ssa.dest) && typeof ssa.source !== 'number' && ssa.source.type === LocType.VARIABLE) {
                output.push(`LD A, (${ssa.source.name})`)

                // TODO: Remove check with peephole optimizer
            } else if (source !== ssa.dest.name) {
                output.push(`LD ${ssa.dest.name}, ${source}`)
            }
            break

        case LocType.VARIABLE:
            if (source !== R8.A) {
                console.log(source, ssa)
                throw new Error("unsupported")
            }
            output.push(`LD (${ssa.dest.name}), A`)
            break

        default:
            throw new Error(`unsupported destination type \`${ssa.dest.type}'`)
    }

    return output
}

const getAlloc = (alloc: RegAlloc, loc: Loc): Loc => {
    const destAlloc = alloc[loc.toString()]
    if (typeof destAlloc === "object") {
        throw new Error("stack variables not yet supported")
    }

    return Loc.reg(destAlloc)
}

export const generateSSA_Unary = (alloc: RegAlloc, ssa: SSAUnary): Array<string> => {
    if (!isA(ssa.dest)) {
        throw new Error("Unexpected form for unary operation")
    }

    const output: Array<string> = []
    if (typeof ssa.source === "number") {
        output.push(`LD A, ${ssa.source}`)
    } else if (ssa.source.type === LocType.REGISTER) {
        if (!isA(ssa.dest)) {
            output.push(`LD A, ${ssa.source.name}`)
        }
    } else {
        // TODO: ??
        output.push(`LD A, ${alloc[ssa.source.toString()]}`)
    }

    const ops = unaryOps[ssa.op]
    if (!ops) {
        throw new Error(`unsupported unary op \`${ssa.op}'`)
    }

    return output.concat(ops)
}

const unaryOps = {
    "arith_negate": ["CPL", "INC A"],
    "bit_negate": ["CPL"]
}

export const generateSSA_Binary = (alloc: RegAlloc, ssa: SSABinary): Array<string> => {
    if (!isA(ssa.dest) || !isA(ssa.source)) {
        throw new Error("Unexpected form for binary operation")
    }

    const output: Array<string> = []
    const source = typeof ssa.source1 === 'number'
        ? ssa.source1
        : getAlloc(alloc, ssa.source1).name

    switch (ssa.op) {
        case "add":
            output.push(`ADD ${source}`)
            break

        default:
            throw new Error(`unsupported binary op \`${ssa.op}'`)
    }

    return output
}

const isA = (loc: Operand): boolean =>
    typeof loc === "object" && loc.type === LocType.REGISTER && loc.name === R8.A