import {
    readFileSync,
    writeFileSync
} from 'fs';

import Jimp from 'Jimp';

function toLinear(val) {
    // use a 2.4 gamma approximation
    // this is BT.1886 compatible
    // and simpler than sRGB
    let unit = val / 255;
    unit **= 2.4;
    return unit * 255;
}

function fromLinear(val) {
    let unit = val / 255;
    unit **= (1 / 2.4);
    return unit * 255;
}

class RGB {
    constructor(r, g, b) {
        this.r = r;
        this.g = g;
        this.b = b;
    }

    static fromHex(val) {
        let r = (val >>> 16) & 0xff;
        let g = (val >>> 8) & 0xff;
        let b = val & 0xff;
        return new RGB(r,g,b);
    }

    toLinear() {
        return new RGB(
            toLinear(this.r),
            toLinear(this.g),
            toLinear(this.b)
        );
    }

    fromLinear() {
        return new RGB(
            fromLinear(this.r),
            fromLinear(this.g),
            fromLinear(this.b)
        );
    }

    cap() {
        if (this.r < 0) {
            this.r = 0;
        }
        if (this.g < 0) {
            this.g = 0;
        }
        if (this.b < 0) {
            this.b = 0;
        }
        if (this.r > 255) {
            this.r = 255;
        }
        if (this.g > 255) {
            this.g = 255;
        }
        if (this.b > 255) {
            this.b = 255;
        }
    }

    inc(other) {
        this.r += other.r;
        this.g += other.g;
        this.b += other.b;
        return this;
    }

    static add(a, b) {
        return new RGB(
            a.r + b.r,
            a.g + b.g,
            a.b + b.b
        );
    }

    add(other) {
        return RGB.add(this, other);
    }

    difference(other) {
        return new RGB(
            this.r - other.r,
            this.g - other.g,
            this.b - other.b
        );
    }

    divide(scalar) {
        return new RGB(
            this.r / scalar,
            this.g / scalar,
            this.b / scalar,
        );
    }

    magnitude() {
        return Math.sqrt(
            this.r * this.r +
            this.g * this.g +
            this.b * this.b
        );
    }
    
    distance(other) {
        return this.difference(other).magnitude();
    }
}

// snarfed from https://lospec.com/palette-list/atari-8-bit-family-gtia
// which was calculated with Retrospecs App's Atari 800 emulator
let atariRGB = [
    0x000000,
    0x111111,
    0x222222,
    0x333333,
    0x444444,
    0x555555,
    0x666666,
    0x777777,
    0x888888,
    0x999999,
    0xaaaaaa,
    0xbbbbbb,
    0xcccccc,
    0xdddddd,
    0xeeeeee,
    0xffffff,
    0x190700,
    0x2a1800,
    0x3b2900,
    0x4c3a00,
    0x5d4b00,
    0x6e5c00,
    0x7f6d00,
    0x907e09,
    0xa18f1a,
    0xb3a02b,
    0xc3b13c,
    0xd4c24d,
    0xe5d35e,
    0xf7e46f,
    0xfff582,
    0xffff96,
    0x310000,
    0x3f0000,
    0x531700,
    0x642800,
    0x753900,
    0x864a00,
    0x975b0a,
    0xa86c1b,
    0xb97d2c,
    0xca8e3d,
    0xdb9f4e,
    0xecb05f,
    0xfdc170,
    0xffd285,
    0xffe39c,
    0xfff4b2,
    0x420404,
    0x4f0000,
    0x600800,
    0x711900,
    0x822a0d,
    0x933b1e,
    0xa44c2f,
    0xb55d40,
    0xc66e51,
    0xd77f62,
    0xe89073,
    0xf9a183,
    0xffb298,
    0xffc3ae,
    0xffd4c4,
    0xffe5da,
    0x410103,
    0x50000f,
    0x61001b,
    0x720f2b,
    0x83203c,
    0x94314d,
    0xa5425e,
    0xb6536f,
    0xc76480,
    0xd87591,
    0xe986a2,
    0xfa97b3,
    0xffa8c8,
    0xffb9de,
    0xffcaef,
    0xfbdcf6,
    0x330035,
    0x440041,
    0x55004c,
    0x660c5c,
    0x771d6d,
    0x882e7e,
    0x993f8f,
    0xaa50a0,
    0xbb61b1,
    0xcc72c2,
    0xdd83d3,
    0xee94e4,
    0xffa5e4,
    0xffb6e9,
    0xffc7ee,
    0xffd8f3,
    0x1d005c,
    0x2e0068,
    0x400074,
    0x511084,
    0x622195,
    0x7332a6,
    0x8443b7,
    0x9554c8,
    0xa665d9,
    0xb776ea,
    0xc887eb,
    0xd998eb,
    0xe9a9ec,
    0xfbbaeb,
    0xffcbef,
    0xffdff9,
    0x020071,
    0x13007d,
    0x240b8c,
    0x351c9d,
    0x462dae,
    0x573ebf,
    0x684fd0,
    0x7960e1,
    0x8a71f2,
    0x9b82f7,
    0xac93f7,
    0xbda4f7,
    0xceb5f7,
    0xdfc6f7,
    0xf0d7f7,
    0xffe8f8,
    0x000068,
    0x000a7c,
    0x081b90,
    0x192ca1,
    0x2a3db2,
    0x3b4ec3,
    0x4c5fd4,
    0x5d70e5,
    0x6e81f6,
    0x7f92ff,
    0x90a3ff,
    0xa1b4ff,
    0xb2c5ff,
    0xc3d6ff,
    0xd4e7ff,
    0xe5f8ff,
    0x000a4d,
    0x001b63,
    0x002c79,
    0x023d8f,
    0x134ea0,
    0x245fb1,
    0x3570c2,
    0x4681d3,
    0x5792e4,
    0x68a3f5,
    0x79b4ff,
    0x8ac5ff,
    0x9bd6ff,
    0xace7ff,
    0xbdf8ff,
    0xceffff,
    0x001a26,
    0x002b3c,
    0x003c52,
    0x004d68,
    0x065e7c,
    0x176f8d,
    0x28809e,
    0x3991af,
    0x4aa2c0,
    0x5bb3d1,
    0x6cc4e2,
    0x7dd5f3,
    0x8ee6ff,
    0x9ff7ff,
    0xb0ffff,
    0xc1ffff,
    0x01250a,
    0x023610,
    0x004622,
    0x005738,
    0x05684d,
    0x16795e,
    0x278a6f,
    0x389b80,
    0x49ac91,
    0x5abda2,
    0x6bceb3,
    0x7cdfc4,
    0x8df0d5,
    0x9effe5,
    0xaffff1,
    0xc0fffd,
    0x04260d,
    0x043811,
    0x054713,
    0x005a1b,
    0x106b1b,
    0x217c2c,
    0x328d3d,
    0x439e4e,
    0x54af5f,
    0x65c070,
    0x76d181,
    0x87e292,
    0x98f3a3,
    0xa9ffb3,
    0xbaffbf,
    0xcbffcb,
    0x00230a,
    0x003510,
    0x044613,
    0x155613,
    0x266713,
    0x377813,
    0x488914,
    0x599a25,
    0x6aab36,
    0x7bbc47,
    0x8ccd58,
    0x9dde69,
    0xaeef7a,
    0xbfff8b,
    0xd0ff97,
    0xe1ffa3,
    0x001707,
    0x0e2808,
    0x1f3908,
    0x304a08,
    0x415b08,
    0x526c08,
    0x637d08,
    0x748e0d,
    0x859f1e,
    0x96b02f,
    0xa7c140,
    0xb8d251,
    0xc9e362,
    0xdaf473,
    0xebff82,
    0xfcff8e,
    0x1b0701,
    0x2c1801,
    0x3c2900,
    0x4d3b00,
    0x5f4c00,
    0x705e00,
    0x816f00,
    0x938009,
    0xa4921a,
    0xb2a02b,
    0xc7b43d,
    0xd8c64e,
    0xead760,
    0xf6e46f,
    0xfffa84,
    0xffff99,
].map((hex) => RGB.fromHex(hex).toLinear());

/**
 * Dither RGB input data with a target palette size.
 * If the number of used colors exceeds `n`, the
 * palette will be reduced until it fits.
 * @param {RGB[]} input source scanline data, in linear RGB
 * @param {number[]} palette - current working palette, as Atari 8-bit color values (low nybble luminance, high nybble hue)
 * @param {number} n - target color count
 * @param {RGB[]} inputError
 * @returns {{output: Uint8Array, palette: number[], error: RGB[]}}
 */
function decimate(input, palette, n, inputError) {
    // to brute-force, the possible palettes are:
    // 255 * 254 * 253 = 16,386,810
    //
    // we could brute force it but that's a lot :D
    // but can do some bisection :D
    //
    // need a fitness metric.
    // each pixel in the dithered line gives a distance
    // sum/average them? median? maximum?
    // summing evens out the ups/downs from dithering
    // but doesn't distinguish between two close and two distant options
    // consider median, 90th-percentile, and max of abs(distance)
    // consider doing the distance for each channel?

    let width = input.length;

    // Apply dithering with given palette and collect color usage stats
    let dither = (palette) => {
        let fitness = new Float64Array(width);
        let error = {
            cur: [],
            next: [],
        };
        for (let i = 0; i < width; i++) {
            error.cur[i] = new RGB(0, 0, 0);
            error.next[i] = new RGB(0, 0, 0);
        }

        let output = new Uint8Array(width);
        let popularity = new Int32Array(width);

        let nextError = new RGB(0, 0, 0);

        // Try dithering with this palette.
        for (let x = 0; x < width; x++) {
            let rgb = RGB.add(input[x], error.cur[x]);
            if (inputError) {
                rgb.inc(inputError[x]);
            }

            // find the closest possible color
            // @todo consider doing the difference scoring in luminance and hue spaces
            let shortest = Infinity;
            let pick = 1;

            for (let i = 0; i < palette.length; i++) {
                let diff = rgb.difference(atariRGB[palette[i]]);
                let dist = diff.magnitude();
                if (dist < shortest) {
                    nextError = diff;
                    shortest = dist;
                    pick = i;
                }
            }

            output[x] = pick;
            popularity[pick]++;

            let shares = 8;
            let single = nextError.divide(shares);
            let double = nextError.divide(shares / 2);
            error.cur[x + 1]?.inc(double);
            error.cur[x + 2]?.inc(single);

            error.next[x - 1]?.inc(single);
            error.next[x]?.inc(double);
            error.next[x + 1]?.inc(double);

            // 442 is the 3d distance across the rgb cube
            //fitness[x] = 442 - (nextError.magnitude());
            //fitness[x] = 442 / (442 - nextError.magnitude());
            fitness[x] = 255 / (256 - Math.max(0, nextError.r, nextError.g, nextError.b));
        }
        return {
            output,
            palette,
            fitness,
            popularity,
            error: error.next
        };
    };


    let decimated = palette.slice();

    while (decimated.length > n) {
        let {popularity, fitness, output} = dither(decimated);

        // Try dropping least used color on each iteration
        let least = Infinity;
        let pick = -1;
        for (let i = 1; i < decimated.length; i++) {

            //let coolFactor = popularity[i];

            let coolFactor = 0;
            if (popularity[i]) {
                for (let x = 0; x < width; x++) {
                    if (output[x] == i) {
                        // Scale up the scoring for close matches to prioritize
                        // color accuracy over raw linear usage.
                        //coolFactor += (fitness[x] ** 2);
                        coolFactor += (fitness[x] ** 4);
                    }
                }
            }

            if (coolFactor < least) {
                pick = i;
                least = coolFactor;
            }
        }
        decimated = decimated.filter((color, i) => {
            if (i == 0) {
                return true;
            }
            if (i == pick) {
                return false;
            }
            // Also drop any non-black unused colors to save trouble.
            // However -- this may change dither results.
            // Try this with/without later.
            if (popularity[i] == 0) {
                return false;
            }
            return true;
        });
    }

    // Palette fits
    return dither(decimated);
}

/**
 * Read an image file into a buffer
 * @param {string} src 
 * @returns {{width: number, height: number, rgba: Uint8Array}}
 */
async function loadImage(src) {
    let image = await Jimp.read(src);

    let width = image.bitmap.width;
    let height = image.bitmap.height;
    if (width != 160 || height != 160) {
        width = 160;
        height = 160;
        image = image.resize(width, height);
    }

    let rgba = image.bitmap.data.slice();
    return {
        width,
        height,
        rgba,
    };
}

function imageToLinearRGB(rgba) {
    let input = [];
    for (let i = 0; i < rgba.length; i += 4) {
        input.push(new RGB(
            rgba[i + 0],
            rgba[i + 1],
            rgba[i + 2]
        ).toLinear());
    }
    return input;
}

/**
 * Read an image file, squish to 160px if necessary,
 * and dither to 4 colors per scan line.
 *
 * @param {string} source path to source image file
 * @returns {{width: number, height: number, lines: {palette: Array, output: Uint8Array}[]}}
 */
async function convert(source, nbits, reps) {

    let {
        width,
        height,
        rgba
    } = await loadImage(source);

    if (width !== 160) {
        throw new Error(`expected 160px-compatible width, got ${width} pixels`);
    }

    if (height !== 160) {
        // @fixme support up to 240px
        throw new Error(`expected 160px height, got ${height} pixels`);
    }

    if (rgba.length != width * 4 * height) {
        console.log(`
        width: ${width}
        height: ${height}
        rgba.length: ${rgba.length}`)
        throw new Error('inconsistent data size');
    }

    if (reps > 1) {
        height *= reps;
        let rgba2 = new Uint8Array(rgba.length * reps);
        for (let i = 0; i < reps; i++) {
            rgba2.set(rgba, rgba.length * i);
        }
        rgba = rgba2;
    }

    let input = imageToLinearRGB(rgba);

    if (input.length != width * height) {
        console.log(`
        width: ${width}
        height: ${height}
        rgba.length: ${input.length}`)
        throw new Error('inconsistent data size on input');
    }

    // Start with all colors usable with regular CTIA modes
    // (not the 16-luminance special mode on GTIA)
    let allColors = [];
    for (let i = 0; i < 256; i += 2) {
        allColors.push(i);
    }

    let lines = [];
    for (let y = 0; y < height; y++) {
        let error = lines[y - 1]?.error;
        let inputLine = input.slice(y * width, (y + 1) * width);
        let line = decimate(inputLine, allColors, 4, error);
        lines.push(line);
    }
    return {
        width,
        height,
        lines
    };
}


function indexedToBitmap(width, nbits, src, dest) {
    let nbytes = width * nbits / 8;
    let x = 0;
    for (let i = 0; i < nbytes; i++) {
        let a = 0;
        for (let b = 0; b < 8; b += nbits) {
            a <<= nbits;
            a |= src[x++];
        }
        dest[i] = a;
    }
}

function byte2byte(arr) {
    let lines = [];
    for (let i=0; i < arr.length; i++) {
        lines.push(`.byte ${arr[i]}`);
    }
    return lines.join('\n');
}

function genAssembly(width, height, nbits, lines, reps) {
    let linesEach = height / reps;
    let stride = width * nbits / 8;
    let half = stride * linesEach / 2;
    let frames = [];

    for (let i = 0; i < reps; i ++) {
        let frame = frames[i] = {
            palette1: new Uint8Array(linesEach),
            palette2: new Uint8Array(linesEach),
            palette3: new Uint8Array(linesEach),
            bitmap: new Uint8Array(stride * linesEach),
        };
        for (let y = 0; y < linesEach; y++) {
            let base = linesEach * i;
            frame.palette1[y] = lines[y + base].palette[1];
            frame.palette2[y] = lines[y + base].palette[2];
            frame.palette3[y] = lines[y + base].palette[3];
            indexedToBitmap(
                width,
                nbits,
                lines[y + base].output,
                frame.bitmap.subarray(y * stride, (y + 1) * stride)
            );
        }
    }

    return `.data
.export frame1_top
.export frame1_bottom
.export frame1_palette1
.export frame1_palette2
.export frame1_palette3
.export frame2_top
.export frame2_bottom
.export frame2_palette1
.export frame2_palette2
.export frame2_palette3
.export displaylist

.segment "BUFFERS"

.align 4096
frame1_top:
${byte2byte(frames[0].bitmap.slice(0, half))}

.align 256
frame1_palette1:
${byte2byte(frames[0].palette1)}

.align 256
frame1_palette2:
${byte2byte(frames[0].palette2)}

.align 256
frame1_palette3:
${byte2byte(frames[0].palette3)}

.align 4096
frame1_bottom:
${byte2byte(frames[0].bitmap.slice(half))}



.align 4096
frame2_top:
${byte2byte(frames[1].bitmap.slice(0, half))}

.align 256
frame2_palette1:
${byte2byte(frames[1].palette1)}

.align 256
frame2_palette2:
${byte2byte(frames[1].palette2)}

.align 256
frame2_palette3:
${byte2byte(frames[1].palette3)}

.align 4096
frame2_bottom:
${byte2byte(frames[1].bitmap.slice(half))}

.align 1024
displaylist:
    ; 40 lines overscan
    .repeat 4
        .byte $70 ; 8 blank lines
    .endrep
    ; include a DLI to mark us as frame 0
    .byte $f0 ; 8 blank lines

    ; 160 lines graphics
    ; ANTIC mode e (160px 2bpp, 1 scan line per line)
    .byte $4e
    .addr frame1_top
    .repeat ${linesEach / 2 - 1}
        .byte $0e
    .endrep
    .byte $4e
    .addr frame1_bottom
    .repeat ${linesEach / 2 - 1}
        .byte $0e
    .endrep

    .byte $41 ; jump and blank
    .addr displaylist_part2

displaylist_part2:
    ; 40 lines overscan
    .repeat 5
        .byte $70 ; 8 blank lines
    .endrep

    ; 160 lines graphics
    ; ANTIC mode e (160px 2bpp, 1 scan line per line)
    .byte $4e
    .addr frame2_top
    .repeat ${linesEach / 2 - 1}
        .byte $0e
    .endrep
    .byte $4e
    .addr frame2_bottom
    .repeat ${linesEach / 2 - 1}
        .byte $0e
    .endrep

    .byte $41 ; jump and blank
    .addr displaylist
`;
}

/**
 * Double width and save as an image file
 * @param {number} width 
 * @param {number} height 
 * @param {{output: number[], palette: number[]}} lines 
 * @param {string} dest 
 */
async function saveImage(width, height, lines, dest) {
    let width2 = width * 2;
    let stride = width2 * 4;
    let rgba = new Uint8Array(stride * height);

    for (let y = 0; y < height; y++) {
        let {output, palette} = lines[y];
        for (let x = 0; x < width2; x++) {
            let i = x >> 1;
            if (i >= width) {
                throw new Error('i >= width');
            }
            let rgb = atariRGB[palette[output[i]]];

            rgba[y * stride + x * 4 + 0] = fromLinear(rgb.r);
            rgba[y * stride + x * 4 + 1] = fromLinear(rgb.g);
            rgba[y * stride + x * 4 + 2] = fromLinear(rgb.b);
            rgba[y * stride + x * 4 + 3] = 255;
        }
    }

    let image = await new Promise((resolve, reject) => {
        new Jimp({
            data: rgba,
            width: width2,
            height,
        }, (err, image) => {
            if (err) reject(err);
            resolve(image);
        });
    });
    await image.writeAsync(dest);
}

async function main() {
    if (process.argv.length < 3) {
        console.error("Usage: node dither-image.js source-image.jpg dest-asm.s");
        process.exit(1);
    }

    let nbits = 2;
    let reps = 2;

    let {width, height, lines} = await convert(process.argv[2], nbits, reps);

    let asm = genAssembly(width, height, nbits, lines, reps);
    writeFileSync(process.argv[3], asm, "utf-8");

    let heightPerFrame = height / reps;
    for (let i = 0; i < reps; i++) {
        let slice = lines.slice(i * heightPerFrame, (i + 1) * heightPerFrame);
        await saveImage(width, heightPerFrame, slice, `${process.argv[3]}.${i}.png`);
    }

    process.exit(0);
}

main();