if (!exec_args[1]) {
    printerrln("Usage: decodeipf input.ipf")
    return 1
}

let filename = exec_args[1]

const MAGIC = [0x1F, 0x54, 0x53, 0x56, 0x4D, 0x69, 0x50, 0x46]
const port = filesystem._toPorts("A")[0]


com.sendMessage(port, "DEVRST\x17")
com.sendMessage(port, `OPENR"${filename}",1`)
let statusCode = com.getStatusCode(port)

if (statusCode != 0) {
    printerrln(`No such file (${statusCode})`)
    return statusCode
}

com.sendMessage(port, "READ")
statusCode = com.getStatusCode(port)
if (statusCode != 0) {
    printerrln("READ failed with "+statusCode)
    return statusCode
}

con.clear(); con.curs_set(0)

let readCount = 0

function readBytes(length) {
    let ptr = sys.malloc(length)
    let requiredBlocks = Math.floor((readCount + length) / 4096) - Math.floor(readCount / 4096)

    let completedReads = 0

    //serial.println(`readBytes(${length}); readCount = ${readCount}`)

    for (let bc = 0; bc < requiredBlocks + 1; bc++) {
        if (completedReads >= length) break

        if (readCount % 4096 == 0) {
            //serial.println("READ from serial")
            // pull the actual message
            sys.poke(-4093 - port, 6);sys.sleep(0) // spinning is required as Graal run is desynced with the Java side

            let blockTransferStatus = ((sys.peek(-4085 - port*2) & 255) | ((sys.peek(-4086 - port*2) & 255) << 8))
            let thisBlockLen = blockTransferStatus & 4095
            if (thisBlockLen == 0) thisBlockLen = 4096 // [1, 4096]
            let hasMore = (blockTransferStatus & 0x8000 != 0)


            //serial.println(`block: (${thisBlockLen})[${[...Array(thisBlockLen).keys()].map(k => (sys.peek(-4097 - k) & 255).toString(16).padStart(2,'0')).join()}]`)

            let remaining = Math.min(thisBlockLen, length - completedReads)

            //serial.println(`Pulled a block (${thisBlockLen}); readCount = ${readCount}, completedReads = ${completedReads}, remaining = ${remaining}`)

            // copy from read buffer to designated position
            sys.memcpy(-4097, ptr + completedReads, remaining)

            // increment readCount properly
            readCount += remaining
            completedReads += remaining
        }
        else {
            let padding = readCount % 4096
            let remaining = length - completedReads
            let thisBlockLen = Math.min(4096 - padding, length - completedReads)

            //serial.println(`padding = ${padding}; remaining = ${remaining}`)

            //serial.println(`block: (${thisBlockLen})[${[...Array(thisBlockLen).keys()].map(k => (sys.peek(-4097 - padding - k) & 255).toString(16).padStart(2,'0')).join()}]`)

            //serial.println(`Reusing a block (${thisBlockLen}); readCount = ${readCount}, completedReads = ${completedReads}`)

            // copy from read buffer to designated position
            sys.memcpy(-4097 - padding, ptr + completedReads, thisBlockLen)

            // increment readCount properly
            readCount += thisBlockLen
            completedReads += thisBlockLen
        }
    }

    //serial.println(`END readBytes(${length}); readCount = ${readCount}\n`)

    return ptr
}

function readInt() {
    let b = readBytes(4)
    let i = (sys.peek(b) & 255) | ((sys.peek(b+1) & 255) << 8) | ((sys.peek(b+2) & 255) << 16) | ((sys.peek(b+3) & 255) << 24)

    //serial.println(`readInt(); bytes: ${sys.peek(b)}, ${sys.peek(b+1)}, ${sys.peek(b+2)}, ${sys.peek(b+3)} = ${i}\n`)

    sys.free(b)
    return i
}

function readShort() {
    let b = readBytes(2)
    let i = (sys.peek(b) & 255) | ((sys.peek(b+1) & 255) << 8)

    //serial.println(`readShort(); bytes: ${sys.peek(b)}, ${sys.peek(b+1)} = ${i}\n`)

    sys.free(b)
    return i
}

function readByte() {
    let b = readBytes(1)
    let i = (sys.peek(b) & 255)

    //serial.println(`readShort(); bytes: ${sys.peek(b)}, ${sys.peek(b+1)} = ${i}\n`)

    sys.free(b)
    return i
}


let magic = readBytes(8)
let magicMatching = true

// check if magic number matches
MAGIC.forEach((b,i) => {
    let testb = sys.peek(magic + i) & 255 // for some reason this must be located here
    if (testb != b) {
        magicMatching = false
    }
})
sys.free(magic)
if (!magicMatching) {
    println("Not an IPF file (MAGIC mismatch)")
    return 1
}

let imgw = readShort()
let imgh = readShort()
let hasAlpha = (readShort() != 0)
sys.free(readBytes(10)) // skip 10 bytes

// TODO: gzip

function clampRGB(f) {
    return (f > 1.0) ? 1.0 : (f < 0.0) ? 0.0 : f
}

function ycocgToRGB(co1, co2, cg1, cg2, ys, as) { // ys: 4 Y-values
    // return [R1|G1, B1|A1, R2|G2, B2|A2, R3|G3, B3|A3, R4|G4, B4|A4]

//    cocg = 0x7777
//    ys = 0x7777

    co1 = (co1 - 7) / 8.0
    co2 = (co2 - 7) / 8.0
    cg1 = (cg1 - 7) / 8.0
    cg2 = (cg2 - 7) / 8.0

    let y1 = (ys & 15) / 15.0
    let a1 = as & 15
    let tmp = y1 - cg1 / 2.0
    let g1 = clampRGB(cg1 + tmp)
    let b1 = clampRGB(tmp - co1 / 2.0)
    let r1 = clampRGB(b1 + co1)

    let y2 = ((ys >>> 4) & 15) / 15.0
    let a2 = (as >>> 4) & 15
    tmp = y2 - cg1 / 2.0
    let g2 = clampRGB(cg1 + tmp)
    let b2 = clampRGB(tmp - co1 / 2.0)
    let r2 = clampRGB(b2 + co1)

    let y3 = ((ys >>> 8) & 15) / 15.0
    let a3 = (as >>> 8) & 15
    tmp = y3 - cg2 / 2.0
    let g3 = clampRGB(cg2 + tmp)
    let b3 = clampRGB(tmp - co2 / 2.0)
    let r3 = clampRGB(b3 + co2)

    let y4 = ((ys >>> 12) & 15) / 15.0
    let a4 = (as >>> 12) & 15
    tmp = y4 - cg2 / 2.0
    let g4 = clampRGB(cg2 + tmp)
    let b4 = clampRGB(tmp - co2 / 2.0)
    let r4 = clampRGB(b4 + co2)

    return [
        (Math.round(r1 * 15) << 4) | Math.round(g1 * 15),
        (Math.round(b1 * 15) << 4) | a1,
        (Math.round(r2 * 15) << 4) | Math.round(g2 * 15),
        (Math.round(b2 * 15) << 4) | a2,
        (Math.round(r3 * 15) << 4) | Math.round(g3 * 15),
        (Math.round(b3 * 15) << 4) | a3,
        (Math.round(r4 * 15) << 4) | Math.round(g4 * 15),
        (Math.round(b4 * 15) << 4) | a4,
    ]
}

graphics.setGraphicsMode(4)

for (let blockY = 0; blockY < Math.ceil(imgh / 4.0); blockY++) {
for (let blockX = 0; blockX < Math.ceil(imgw / 4.0); blockX++) {
    let rg = new Uint8Array(16) // [R1G1, R2G2, R3G3, R4G4, ...]
    let ba = new Uint8Array(16)

    let co = readInt()
    let cg = readInt()
    let y1 = readShort()
    let y2 = readShort()
    let y3 = readShort()
    let y4 = readShort()

    let a1 = 65535; let a2 = 65535; let a3 = 65535; let a4 = 65535

    if (hasAlpha) {
        a1 = readShort()
        a2 = readShort()
        a3 = readShort()
        a4 = readShort()
    }

    let corner = ycocgToRGB(co & 15, (co >> 8) & 15, cg & 15, (cg >> 8) & 15, y1, a1)
    rg[0] = corner[0];ba[0] = corner[1]
    rg[1] = corner[2];ba[1] = corner[3]
    rg[4] = corner[4];ba[4] = corner[5]
    rg[5] = corner[6];ba[5] = corner[7]

    corner = ycocgToRGB((co >> 4) & 15, (co >> 12) & 15, (cg >> 4) & 15, (cg >> 12) & 15, y2, a2)
    rg[2] = corner[0];ba[2] = corner[1]
    rg[3] = corner[2];ba[3] = corner[3]
    rg[6] = corner[4];ba[6] = corner[5]
    rg[7] = corner[6];ba[7] = corner[7]

    corner = ycocgToRGB((co >> 16) & 15, (co >> 24) & 15, (cg >> 16) & 15, (cg >> 24) & 15, y3, a3)
    rg[8] = corner[0];ba[8] = corner[1]
    rg[9] = corner[2];ba[9] = corner[3]
    rg[12] = corner[4];ba[12] = corner[5]
    rg[13] = corner[6];ba[13] = corner[7]

    corner = ycocgToRGB((co >> 20) & 15, (co >> 28) & 15, (cg >> 20) & 15, (cg >> 28) & 15, y4, a4)
    rg[10] = corner[0];ba[10] = corner[1]
    rg[11] = corner[2];ba[11] = corner[3]
    rg[14] = corner[4];ba[14] = corner[5]
    rg[15] = corner[6];ba[15] = corner[7]


    // move decoded pixels into memory
    for (let py = 0; py < 4; py++) { for (let px = 0; px < 4; px++) {
        let ox = blockX * 4 + px
        let oy = blockY * 4 + py
        let offset = oy * 560 + ox
        sys.poke(-1048577 - offset, rg[py * 4 + px])
        sys.poke(-1310721 - offset, ba[py * 4 + px])
    }}
}}