// Greyscale PNG encoding, 8-bit and 16-bit.
//
// Both are here because the Unreal landscape export needs both - a 16-bit height and an 8-bit weightmap
// per paint layer per tile - and because a canvas cannot produce either. toBlob writes 8-bit RGBA and
// Unreal's landscape importer wants single-channel, so the weightmaps would have to be un-RGBA'd on the
// way in; the heights have no 16-bit canvas path at all. Writing the chunks directly is less code than
// working around either.
//
// Compression is CompressionStream('deflate'), which is the zlib wrapper PNG asks for, not the raw
// DEFLATE that 'deflate-raw' would give. Filter 0 (None) on every scanline: the rows here are either
// smooth height ramps or near-flat weight fields, and Paeth would cost a pass over the image to save a
// few per cent of a file that is written once and read once.

const _crc32Table = (() => {
    const t = new Uint32Array(256);
    for (let n = 0; n < 256; n++) {
        let c = n;
        for (let k = 0; k < 8; k++) c = (c & 1) ? (0xEDB88320 ^ (c >>> 1)) : (c >>> 1);
        t[n] = c;
    }
    return t;
})();

function crc32(buf) {
    let crc = 0xFFFFFFFF;
    for (let i = 0; i < buf.length; i++) crc = _crc32Table[(crc ^ buf[i]) & 0xFF] ^ (crc >>> 8);
    return (crc ^ 0xFFFFFFFF) >>> 0;
}

function chunk(type, data) {
    const out = new Uint8Array(4 + 4 + data.length + 4);
    const dv = new DataView(out.buffer);
    dv.setUint32(0, data.length);
    for (let i = 0; i < 4; i++) out[4 + i] = type.charCodeAt(i);
    out.set(data, 8);
    dv.setUint32(8 + data.length, crc32(out.subarray(4, 8 + data.length)));
    return out;
}

async function assemble(width, height, bitDepth, raw) {
    const ihdr = new Uint8Array(13);
    const iv = new DataView(ihdr.buffer);
    iv.setUint32(0, width);
    iv.setUint32(4, height);
    ihdr[8] = bitDepth;
    ihdr[9] = 0;            // colour type 0: greyscale

    const cs = new CompressionStream('deflate');
    const writer = cs.writable.getWriter();
    writer.write(raw);
    writer.close();
    const body = new Uint8Array(await new Response(cs.readable).arrayBuffer());

    const parts = [
        new Uint8Array([137, 80, 78, 71, 13, 10, 26, 10]),
        chunk('IHDR', ihdr),
        chunk('IDAT', body),
        chunk('IEND', new Uint8Array(0)),
    ];
    const png = new Uint8Array(parts.reduce((n, p) => n + p.length, 0));
    let at = 0;
    for (const part of parts) { png.set(part, at); at += part.length; }
    return new Blob([png], { type: 'image/png' });
}

/** 16-bit greyscale PNG from a Uint16Array of width * height, row-major. Big-endian, as PNG requires. */
export async function encodeGray16(width, height, data) {
    const rowLen = 1 + width * 2;
    const raw = new Uint8Array(height * rowLen);
    for (let y = 0; y < height; y++) {
        const off = y * rowLen;
        raw[off] = 0;
        for (let x = 0; x < width; x++) {
            const v = data[y * width + x];
            raw[off + 1 + x * 2] = (v >> 8) & 0xFF;
            raw[off + 2 + x * 2] = v & 0xFF;
        }
    }
    return assemble(width, height, 16, raw);
}

/** 8-bit greyscale PNG from a Uint8Array of width * height, row-major. */
export async function encodeGray8(width, height, data) {
    const rowLen = 1 + width;
    const raw = new Uint8Array(height * rowLen);
    for (let y = 0; y < height; y++) {
        const off = y * rowLen;
        raw[off] = 0;
        raw.set(data.subarray(y * width, (y + 1) * width), off + 1);
    }
    return assemble(width, height, 8, raw);
}