let traces = {};
let config = {};
let raster_tile = {'x': 0, 'y': 0};
let max_stage_cycles = 0;

onmessage = (e) => {
    const msg = e.data;

    if (msg.type === 'init') {
        config = msg.config;
    } else if (msg.type === 'import') {
        const text = msg.text;
        if (parse(text)) {
            traces['0'].geo = generate('0');
            delete traces['0'].raw;
            postMessage({'type': 'trace', 'data': traces['0']});
        }
    }
}

function parse(text) {
    // https://github.com/shioyadan/Konata/blob/master/docs/kanata-log-format.md

    const before = performance.now();

    let line_start = 0;
    let line_index = 0;
    let c = -1;

    const instructions = {};

    //console.log(text);

    for (let i = 0; i < text.length; ++i) {
        const last_percent = Math.round((i - 1) / text.length * 100);
        const this_percent = Math.round(i / text.length * 100);
        
        if (this_percent != last_percent) {
            postMessage({'type': 'progress_parse', 'data': this_percent})
        }

        if (text[i] === '\n') {
            // TODO: speed
            const line_copy = text.substring(line_start, i);
            const line_parts = line_copy.split(/\t/);

            if (line_parts.length === 0) {
                console.error('Parser error: empty line');
            }

            const command = line_parts[0];
            switch (command) {
                case 'C=': {
                    // Specify the number of cycles since the start of simulation.
                    if (!assert_arglen(line_parts, 1, 'C=')) return false;

                    const cycles = Number(line_parts[1]);
                    c = cycles;

                    break;
                }

                case 'C': {
                    // Specifies the number of elapsed cycles since the last output of any commands.
                    if (!assert_arglen(line_parts, 1, 'C')) return false;

                    const cycles = Number(line_parts[1]);
                    
                    if (c === -1) {
                        c = 0;
                    } else {
                        c += cycles;
                    }

                    break;
                }

                case 'I': {
                    if (!assert_arglen(line_parts, 3, 'I')) return false;

                    const insn_id_in_file = Number(line_parts[1]);
                    const insn_id_in_sim = Number(line_parts[2]);
                    const thread_id = Number(line_parts[3]);

                    instructions[insn_id_in_file] = {
                        'cycle': c,
                        'file_id': insn_id_in_file,
                        'sim_id': insn_id_in_sim,
                        'thread_id': thread_id,
                        'text': '',
                        'popover_text': '',
                        'lanes': {'0': [], '1': []},
                    };

                    break;
                }

                case 'L': {
                    if (!assert_arglenmin(line_parts, 3, 'L')) return false;

                    const id = Number(line_parts[1]);
                    const type = Number(line_parts[2]);
                    const text = line_parts[3].replaceAll('\\n', '\n');

                    if (id in instructions) {
                        if (type === 0) {
                            instructions[id].text += text;
                        } else {
                            instructions[id].popover_text += text;
                        }
                    } else {
                        console.error('Parser error: label for an instruction that does not exist');
                    }

                    break;
                }

                case 'S': {
                    if (!assert_arglen(line_parts, 3, 'S')) return false;

                    const id = Number(line_parts[1]);
                    const lane = Number(line_parts[2]);
                    const stage = line_parts[3];


                    if (id in instructions) {
                        if (!(lane in instructions[id].lanes)) {
                            instructions[id].lanes[lane] = [];
                        }

                        instructions[id].lanes[lane].push({
                            'name': stage,
                            'c': c,
                        });
                    } else {
                        console.error('Parser error: pipeline start for an instruction that does not exist');
                    }


                    break;
                }

                case 'E': {
                    if (!assert_arglen(line_parts, 3, 'E')) return false;

                    const id = Number(line_parts[1]);
                    const lane = Number(line_parts[2]);
                    const stage = line_parts[3];

                    // This command can be ommited

                    break;
                }

                case 'R': {
                    if (!assert_arglen(line_parts, 3, 'R')) return false;

                    const id = Number(line_parts[1]);
                    const retire_id = Number(line_parts[2]);
                    const type = Number(line_parts[3]);

                    if (id in instructions) {
                        if (type === 0) {
                            instructions[id].retired = true;
                        } else {
                            instructions[id].retired = false;
                        }
                        instructions[id].retcyc = c;
                    } else {
                        console.error('Parser error: retire for an instruction that does not exist');
                    }

                    break;
                }

                case 'W': {
                    if (!assert_arglen(line_parts, 3, 'W')) return false;

                    const consumer_id = Number(line_parts[1]);
                    const producer_id = Number(line_parts[2]);
                    const type = Number(line_parts[3]);
                    
                    // TODO

                    break;
                }

                default: {
                    console.error('Parser error: unexpected command', command);
                }
            }

            line_start = i + 1;
            line_index += 1;
        }
    }

    traces['0'] = {
        // The fact these are sorted is used extensively over the code
        'raw': Object.values(instructions).sort((a, b) => a.cycle - b.cycle),
    };

    const after = performance.now();
    console.log(`Parsed in ${Math.round(after - before)}ms`);


    return true;
}

function assert_arglen(args, arglen, command) {
    if (args.length !== arglen + 1) {
        console.error(`Parser error: command ${command} requires ${arglen} argument(s)`);
        return false;
    }

    return true;
}

function assert_arglenmin(args, arglen, command) {
    if (args.length < arglen + 1) {
        console.error(`Parser error: command ${command} requires at least ${arglen} argument(s)`);
        return false;
    }

    return true;
}

let colors = {};
let rasterized = {};

// https://stackoverflow.com/a/17243070
function hsv_to_rgb(h, s, v) {
    let r, g, b;

    const i = Math.floor(h * 6);
    const f = h * 6 - i;
    const p = v * (1 - s);
    const q = v * (1 - f * s);
    const t = v * (1 - (1 - f) * s);

    switch (i % 6) {
        case 0: r = v, g = t, b = p; break;
        case 1: r = q, g = v, b = p; break;
        case 2: r = p, g = v, b = t; break;
        case 3: r = p, g = q, b = v; break;
        case 4: r = t, g = p, b = v; break;
        case 5: r = v, g = p, b = q; break;
    }

    return [
        Math.round(r * 255),
        Math.round(g * 255),
        Math.round(b * 255)
    ];
}

function get_color(stage_name) {
    if (stage_name in config.predefined_colors) {
        return config.predefined_colors[stage_name];
    }

    if (stage_name in colors) {
        return colors[stage_name];
    }

    colors[stage_name] = hsv_to_rgb(Math.random(), 0.56, 0.56); 

    return colors[stage_name];
}

function rasterize_and_pack(text) {
    // TODO: handle texture is full or stuff don't fit (unlikely)

    const key = text;

    if (key in rasterized) {
        return rasterized[key];
    }

    const u = raster_tile.x * config.w / config.raster_texture_size;
    const v = raster_tile.y * config.h / config.raster_texture_size;

    postMessage({'type': 'rasterize', 'data': { 'text': text, 'at': {'x': raster_tile.x, 'y': raster_tile.y}}});

    raster_tile.x += 1;

    if (raster_tile.x === config.raster_texture_size / config.w) {
        raster_tile.x = 0;
        raster_tile.y += 1;
    }

    rasterized[key] = [u, v];

    return [u, v];
}

function pack_instruction(instruction, positions, sizes, colors, uvs, starts, y) {
    starts.push(positions.length);
    
    for (let i = 0; i < instruction.lanes['0'].length; ++i) {
        const stage = instruction.lanes['0'][i];
        let stage_cycles;

        if (i < instruction.lanes['0'].length - 1) {
            const next_stage = instruction.lanes['0'][i + 1];
            stage_cycles = next_stage.c - stage.c;
        } else {
            stage_cycles = instruction.retcyc - stage.c;
        }

        if (stage_cycles > max_stage_cycles) {
            max_stage_cycles = stage_cycles;
        }

        let [r, g, b] = get_color(stage.name);
        let a = 255;

        if (!instruction.retired) {
            a = 80;
        }

        const [u, v] = rasterize_and_pack(stage.name);

        sizes.push(stage_cycles * config.w + (stage_cycles - 1) * config.padding, 1 * config.h);
        positions.push(config.w * stage.c + config.padding * (stage.c - 1), config.h * y + config.padding * (y - 1)); 
        colors.push(r, g, b, a);
        uvs.push(u, v);
    }

    return instruction.lanes['0'].length;
}

function generate(trace_id) {
    const before = performance.now();

    const result = {
        'count': 0,
    };

    const positions = [];
    const sizes = [];
    const colors = [];
    const uvs = [];
    const starts = [];

    let instructions = {};

    if (trace_id in traces) {
        instructions = traces[trace_id].raw;
    }

    let y = 0;

    for (let i = 0; i < instructions.length; ++i) {
        const last_percent = Math.round((i - 1) / instructions.length * 100);
        const this_percent = Math.round(i / instructions.length * 100);

        if (this_percent !== last_percent) {
            postMessage({'type': 'progress_generate', 'data': this_percent})
        }

        const instruction = instructions[i];
        // TODO: make all quads same size, abuse this fact 
        result.count += pack_instruction(instruction, positions, sizes, colors, uvs, starts, y);
        if (config.limit > 0 && result.count >= config.limit) {
            break;
        }
        ++y;
    }

    postMessage({'type': 'rasterize_numbers', 'up_to': max_stage_cycles});

    starts.push(positions.length);

    console.log(`Total geometry: ${Math.round(result.count * config.bytes_per_quad / 1024 / 1024)}MB`);

    if (config.show_texture) {
        result.pos = new Float32Array([0, 0]);
        result.size = new Float32Array([config.raster_texture_size, config.raster_texture_size]);
        result.color = new Uint8Array([0, 0, 0, 255]);
        result.uv = new Float32Array([0, 0]);
        result.count = 1;
        result.trace_id = trace_id;
        result.uploaded = false;
    } else {
        result.pos = new Float32Array(positions);
        result.size = new Float32Array(sizes);
        result.color = new Uint8Array(colors);
        result.uv = new Float32Array(uvs);
        result.trace_id = trace_id;
        result.uploaded = false;
        result.start = new Int32Array(starts);
    }

    const after = performance.now();

    console.log(`Generated geometry in ${Math.round(after - before)}ms`);

    return result;
}