"use strict";

const print_stats = {
    stats_to_string: function(cpu)
    {
        return print_stats.print_misc_stats(cpu) +
            print_stats.print_instruction_counts(cpu);
    },

    print_misc_stats: function(cpu)
    {
        let text = "";

        const stat_names = [
            "COMPILE",
            "COMPILE_SKIPPED_NO_NEW_ENTRY_POINTS",
            "COMPILE_SUCCESS",
            "COMPILE_WRONG_ADDRESS_SPACE",
            "COMPILE_CUT_OFF_AT_END_OF_PAGE",
            "COMPILE_WITH_LOOP_SAFETY",
            "COMPILE_PAGE",
            "COMPILE_PAGE/COMPILE_SUCCESS",
            "COMPILE_PAGE_SKIPPED_NO_NEW_ENTRY_POINTS",
            "COMPILE_BASIC_BLOCK",
            "COMPILE_DUPLICATED_BASIC_BLOCK",
            "COMPILE_WASM_BLOCK",
            "COMPILE_WASM_LOOP",
            "COMPILE_DISPATCHER",
            "COMPILE_ENTRY_POINT",
            "COMPILE_WASM_TOTAL_BYTES",
            "COMPILE_WASM_TOTAL_BYTES/COMPILE_PAGE",
            "JIT_CACHE_OVERRIDE",
            "JIT_CACHE_OVERRIDE_DIFFERENT_STATE_FLAGS",
            "RUN_INTERPRETED",
            "RUN_INTERPRETED_PENDING",
            "RUN_INTERPRETED_NEAR_END_OF_PAGE",
            "RUN_INTERPRETED_DIFFERENT_STATE",
            "RUN_INTERPRETED_MISSED_COMPILED_ENTRY_RUN_INTERPRETED",
            "RUN_INTERPRETED_MISSED_COMPILED_ENTRY_LOOKUP",
            "RUN_INTERPRETED_STEPS",
            "RUN_FROM_CACHE",
            "RUN_FROM_CACHE_STEPS",
            "RUN_FROM_CACHE_STEPS/RUN_FROM_CACHE",
            "RUN_FROM_CACHE_STEPS/RUN_INTERPRETED_STEPS",
            "DIRECT_EXIT",
            "INDIRECT_JUMP",
            "INDIRECT_JUMP_NO_ENTRY",
            "NORMAL_PAGE_CHANGE",
            "NORMAL_FALLTHRU",
            "NORMAL_FALLTHRU_WITH_TARGET_BLOCK",
            "NORMAL_BRANCH",
            "NORMAL_BRANCH_WITH_TARGET_BLOCK",
            "CONDITIONAL_JUMP",
            "CONDITIONAL_JUMP_PAGE_CHANGE",
            "CONDITIONAL_JUMP_EXIT",
            "CONDITIONAL_JUMP_FALLTHRU",
            "CONDITIONAL_JUMP_FALLTHRU_WITH_TARGET_BLOCK",
            "CONDITIONAL_JUMP_BRANCH",
            "CONDITIONAL_JUMP_BRANCH_WITH_TARGET_BLOCK",
            "DISPATCHER_SMALL",
            "DISPATCHER_LARGE",
            "LOOP",
            "LOOP_SAFETY",
            "CONDITION_OPTIMISED",
            "CONDITION_UNOPTIMISED",
            "FAILED_PAGE_CHANGE",
            "SAFE_READ_FAST",
            "SAFE_READ_SLOW_PAGE_CROSSED",
            "SAFE_READ_SLOW_NOT_VALID",
            "SAFE_READ_SLOW_NOT_USER",
            "SAFE_READ_SLOW_IN_MAPPED_RANGE",
            "SAFE_WRITE_FAST",
            "SAFE_WRITE_SLOW_PAGE_CROSSED",
            "SAFE_WRITE_SLOW_NOT_VALID",
            "SAFE_WRITE_SLOW_NOT_USER",
            "SAFE_WRITE_SLOW_IN_MAPPED_RANGE",
            "SAFE_WRITE_SLOW_READ_ONLY",
            "SAFE_WRITE_SLOW_HAS_CODE",
            "SAFE_READ_WRITE_FAST",
            "SAFE_READ_WRITE_SLOW_PAGE_CROSSED",
            "SAFE_READ_WRITE_SLOW_NOT_VALID",
            "SAFE_READ_WRITE_SLOW_NOT_USER",
            "SAFE_READ_WRITE_SLOW_IN_MAPPED_RANGE",
            "SAFE_READ_WRITE_SLOW_READ_ONLY",
            "SAFE_READ_WRITE_SLOW_HAS_CODE",
            "PAGE_FAULT",
            "TLB_MISS",
            "DO_RUN",
            "DO_MANY_CYCLES",
            "CYCLE_INTERNAL",
            "INVALIDATE_ALL_MODULES_NO_FREE_WASM_INDICES",
            "INVALIDATE_MODULE_WRITTEN_WHILE_COMPILED",
            "INVALIDATE_MODULE_UNUSED_AFTER_OVERWRITE",
            "INVALIDATE_MODULE_DIRTY_PAGE",
            "INVALIDATE_PAGE_HAD_CODE",
            "INVALIDATE_PAGE_HAD_ENTRY_POINTS",
            "DIRTY_PAGE_DID_NOT_HAVE_CODE",
            "RUN_FROM_CACHE_EXIT_SAME_PAGE",
            "RUN_FROM_CACHE_EXIT_NEAR_END_OF_PAGE",
            "RUN_FROM_CACHE_EXIT_DIFFERENT_PAGE",
            "CLEAR_TLB",
            "FULL_CLEAR_TLB",
            "TLB_FULL",
            "TLB_GLOBAL_FULL",
            "MODRM_SIMPLE_REG",
            "MODRM_SIMPLE_REG_WITH_OFFSET",
            "MODRM_SIMPLE_CONST_OFFSET",
            "MODRM_COMPLEX",
            "SEG_OFFSET_OPTIMISED",
            "SEG_OFFSET_NOT_OPTIMISED",
        ];

        let j = 0;
        const stat_values = {};
        for(let i = 0; i < stat_names.length; i++)
        {
            const name = stat_names[i];
            let value;
            if(name.includes("/"))
            {
                j++; // skip profiler_stat_get
                const [left, right] = name.split("/");
                value = stat_values[left] / stat_values[right];
            }
            else
            {
                let stat = stat_values[name] = cpu.wm.exports["profiler_stat_get"](i - j);
                value = stat >= 100e6 ? Math.round(stat / 1e6) + "m" : stat >= 100e3 ? Math.round(stat / 1e3) + "k" : stat;
            }
            text += name + "=" + value + "\n";
        }

        text += "\n";

        const tlb_entries = cpu.wm.exports["get_valid_tlb_entries_count"]();
        const global_tlb_entries = cpu.wm.exports["get_valid_global_tlb_entries_count"]();
        const nonglobal_tlb_entries = tlb_entries - global_tlb_entries;

        text += "TLB_ENTRIES=" + tlb_entries + " (" + global_tlb_entries + " global, " + nonglobal_tlb_entries + " non-global)\n";
        text += "WASM_TABLE_FREE=" + cpu.wm.exports["jit_get_wasm_table_index_free_list_count"]() + "\n";
        text += "JIT_CACHE_SIZE=" + cpu.wm.exports["jit_get_cache_size"]() + "\n";
        text += "FLAT_SEGMENTS=" + cpu.wm.exports["has_flat_segmentation"]() + "\n";

        text += "do_many_cycles avg: " + (do_many_cycles_total / do_many_cycles_count || 0) + "\n";
        text += "wasm memory size: " + (cpu.wasm_memory.buffer.byteLength >> 20) + "m\n";

        text += "Config:\n";
        text += "MAX_PAGES=" + cpu.wm.exports["get_config"](0) + "\n";
        text += "JIT_USE_LOOP_SAFETY=" + cpu.wm.exports["get_config"](1) + "\n";
        text += "MAX_EXTRA_BASIC_BLOCKS=" + cpu.wm.exports["get_config"](2) + "\n";

        return text;
    },

    print_instruction_counts: function(cpu)
    {
        return [
            print_stats.print_instruction_counts_offset(cpu, false, false, false, false),
            print_stats.print_instruction_counts_offset(cpu, true, false, false, false),
            print_stats.print_instruction_counts_offset(cpu, false, true, false, false),
            print_stats.print_instruction_counts_offset(cpu, false, false, true, false),
            print_stats.print_instruction_counts_offset(cpu, false, false, false, true),
        ].join("\n\n");
    },

    print_instruction_counts_offset: function(cpu, compiled, jit_exit, unguarded_register, wasm_size)
    {
        let text = "";

        const counts = [];

        const label =
            compiled ? "compiled" :
            jit_exit ? "jit exit" :
            unguarded_register ? "unguarded register" :
            wasm_size ? "wasm size" :
            "executed";

        for(let opcode = 0; opcode < 0x100; opcode++)
        {
            for(let fixed_g = 0; fixed_g < 8; fixed_g++)
            {
                for(let is_mem of [false, true])
                {
                    const count = cpu.wm.exports["get_opstats_buffer"](compiled, jit_exit, unguarded_register, wasm_size, opcode, false, is_mem, fixed_g);
                    counts.push({ opcode, count, is_mem, fixed_g });

                    const count_0f = cpu.wm.exports["get_opstats_buffer"](compiled, jit_exit, unguarded_register, wasm_size, opcode, true, is_mem, fixed_g);
                    counts.push({ opcode: 0x0f00 | opcode, count: count_0f, is_mem, fixed_g });
                }
            }
        }

        let total = 0;
        const prefixes = new Set([
            0x26, 0x2E, 0x36, 0x3E,
            0x64, 0x65, 0x66, 0x67,
            0xF0, 0xF2, 0xF3,
        ]);
        for(let { count, opcode } of counts)
        {
            if(!prefixes.has(opcode))
            {
                total += count;
            }
        }

        if(total === 0)
        {
            return "";
        }

        const per_opcode = new Uint32Array(0x100);
        const per_opcode0f = new Uint32Array(0x100);

        for(let { opcode, count } of counts)
        {
            if((opcode & 0xFF00) == 0x0F00)
            {
                per_opcode0f[opcode & 0xFF] += count;
            }
            else
            {
                per_opcode[opcode & 0xFF] += count;
            }
        }

        text += "------------------\n";
        text += "Total: " + total + "\n";

        const factor = total > 1e7 ? 1000 : 1;

        const max_count = Math.max.apply(Math,
            counts.map(({ count }) => Math.round(count / factor))
        );
        const pad_length = String(max_count).length;

        text += `Instruction counts ${label} (in ${factor}):\n`;

        for(let i = 0; i < 0x100; i++)
        {
            text += h(i, 2).slice(2) + ":" + v86util.pads(Math.round(per_opcode[i] / factor), pad_length);

            if(i % 16 == 15)
                text += "\n";
            else
                text += " ";
        }

        text += "\n";
        text += `Instruction counts ${label} (0f, in ${factor}):\n`;

        for(let i = 0; i < 0x100; i++)
        {
            text += h(i & 0xFF, 2).slice(2) + ":" + v86util.pads(Math.round(per_opcode0f[i] / factor), pad_length);

            if(i % 16 == 15)
                text += "\n";
            else
                text += " ";
        }
        text += "\n";

        const top_counts = counts.filter(({ count }) => count).sort(({ count: count1 }, { count: count2 }) => count2 - count1);

        for(let { opcode, is_mem, fixed_g, count } of top_counts.slice(0, 200))
        {
            let opcode_description = opcode.toString(16) + "_" + fixed_g + (is_mem ? "_m" : "_r");
            text += opcode_description + ":" + (count / total * 100).toFixed(2) + " ";
        }
        text += "\n";

        return text;
    },
};

if(typeof module !== "undefined" && typeof module.exports !== "undefined")
{
    module.exports["print_stats"] = print_stats;
}