/**
 * Tom Harte test data based test suite
 *
 * Uses test files from https://github.com/TomHarte/ProcessorTests
 * To use, set TOM_HARTE_TEST_PATH to local copy of that repository
 */

import fs from 'fs';

import CPU6502, { FLAVOR_ROCKWELL_65C02, FLAVOR_WDC_65C02 } from 'js/cpu6502';
import { toHex } from 'js/util';
import type { byte, word } from 'js/types';

import { toReadableState } from './util/cpu';
import { TestMemory } from './util/memory';

// JEST_DETAIL=true converts decimal values to hex before testing
// expectations, for better readability at the expense of speed.
const detail = !!process.env.JEST_DETAIL;

/**
 * Types for JSON tests
 */

/**
 * Memory address and value
 */
type MemoryValue = [address: word, value: byte];

/**
 * Represents initial and final CPU and memory states
 */
 interface TestState {
    /** Program counter */
    pc: word
    /** Stack register */
    s: byte
    /** Accumulator */
    a: byte
    /** X index */
    x: byte
    /** Y index */
    y: byte
    /** Processor status register */
    p: byte
    /** M */
    ram: MemoryValue[]
}

/**
 * CPU cycle memory operation
 */
type Cycle = [address: word, value: byte, type: 'read'|'write'];

/**
 * One test record
 */
interface Test {
    /** Test name */
    name: string
    /** Initial CPU register and memory state */
    initial: TestState
    /**  Final CPU register and memory state */
    final: TestState
    /** Detailed CPU cycles */
    cycles: Cycle[]
}

/**
 * Initialize cpu and memory before test
 *
 * @param cpu Target cpu instance
 * @param state Initial test state
 */
function initState(cpu: CPU6502, state: TestState) {
    const { pc, s, a, x, y, p, ram } = state;
    cpu.setState({ cycles: 0, pc, sp: s, a, x, y, s: p });

    for (let idx = 0; idx < ram.length; idx++) {
        const [address, mem] = ram[idx];
        cpu.write(address, mem);
    }
}

/**
 * Pretty print 'address: val' if detail is turned on,
 * or passes through raw test data if not.
 *
 * @returns string or raw test data
 */
function toAddrValHex([address, val]: MemoryValue) {
    if (detail) {
        return `${toHex(address, 4)}: ${toHex(val)}`;
    } else {
        return [address, val];
    }
}

/**
 * Pretty print 'address: val (read|write)' if detail is turned on,
 * or passes through raw test data if not.
 *
 * @returns string or raw test data
 */
function toAddrValHexType([address, val, type]: Cycle) {
    if (detail) {
        return `${toHex(address, 4)}: ${toHex(val)} ${type}`;
    } else {
        return [address, val, type];
    }
}

/**
 * Compare end state and read write behavior of test run
 *
 * @param cpu Test CPU
 * @param memory Test memory
 * @param test Test data to compare against
 */
function expectState(cpu: CPU6502, memory: TestMemory, test: Test) {
    const { pc, s, a, x, y, p, ram } = test.final;
    expect(
        toReadableState(cpu.getState())
    ).toEqual(
        toReadableState({cycles: test.cycles.length, pc, sp: s, a, x, y, s: p })
    );

    // Retrieve relevant memory locations and values
    const result = [];
    for (let idx = 0; idx < ram.length; idx++) {
        const [address] = ram[idx];
        result.push([address, cpu.read(address)]);
    }
    expect(
        result.map(toAddrValHex)
    ).toEqual(
        ram.map(toAddrValHex)
    );

    expect(
        memory.getLog().map(toAddrValHexType)
    ).toEqual(
        test.cycles.map(toAddrValHexType)
    );
}

interface OpTest {
    op: string
    name: string
    mode: string
}

const testPath = process.env.TOM_HARTE_TEST_PATH;

// There are 10,0000 tests per test file, which would take several hours
// in jest. 16 is a manageable quantity that still gets good coverage.
const maxTests = 16;

if (testPath) {
    const testPath6502 = `${testPath}/6502/v1/`;
    const testPathWDC65C02 = `${testPath}/wdc65c02/v1/`;
    const testPathRW65C02 = `${testPath}/rockwell65c02/v1/`;

    const opAry6502: OpTest[] = [];
    const opAryRW65C02: OpTest[] = [];
    const opAryWDC65C02: OpTest[] = [];

    const buildOpArrays = () => {
        const cpu = new CPU6502();

        for (const op in cpu.OPS_6502) {
            const { name, mode } = cpu.OPS_6502[op];
            const test = { op: toHex(+op), name, mode };
            opAry6502.push(test);
            opAryRW65C02.push(test);
            opAryWDC65C02.push(test);
        }

        for (const op in cpu.OPS_NMOS_6502) {
            const { name, mode } = cpu.OPS_NMOS_6502[op];
            const test = { op: toHex(+op), name, mode };
            opAry6502.push(test);
        }

        for (const op in cpu.OPS_65C02) {
            const { name, mode } = cpu.OPS_65C02[op];
            const test = { op: toHex(+op), name, mode };
            opAryRW65C02.push(test);
            opAryWDC65C02.push(test);
        }

        // WDC 65C02 NOPs
        [
            '03', '0b', '13', '1b', '23', '2b', '33', '3b',
            '43', '4b', '53', '5b', '63', '6b', '73', '7b',
            '83', '8b', '93', '9b', 'a3', 'ab', 'b3', 'bb',
            'c3',       'd3',       'e3', 'eb', 'f3', 'fb'
        ].forEach((op) =>
            opAryWDC65C02.push({ op, name: 'nop', mode: 'implied'})
        );

        // Rockwell 65C02 NOPs
        [
            '03', '0b', '13', '1b', '23', '2b', '33', '3b',
            '43', '4b', '53', '5b', '63', '6b', '73', '7b',
            '83', '8b', '93', '9b', 'a3', 'ab', 'b3', 'bb',
            'c3', 'cb', 'd3', 'db', 'e3', 'eb', 'f3', 'fb'
        ].forEach((op) =>
            opAryRW65C02.push({ op, name: 'nop', mode: 'implied'})
        );
    };

    buildOpArrays();

    describe('Tom Harte', function() {
        let cpu: CPU6502;
        let memory: TestMemory;

        describe('NMOS 6502', function() {
            beforeAll(function() {
                cpu = new CPU6502();
                memory = new TestMemory(256);
                cpu.addPageHandler(memory);
            });

            describe.each(opAry6502)('Test op $op $name $mode', ({op}) => {
                const data = fs.readFileSync(`${testPath6502}${op}.json`, 'utf-8');
                const tests = JSON.parse(data) as Test[];

                it.each(tests.slice(0, maxTests))('Test $name', (test) => {
                    initState(cpu, test.initial);
                    memory.logStart();
                    cpu.step();
                    memory.logStop();
                    expectState(cpu, memory, test);
                });
            });
        });

        describe('Rockwell 65C02', function() {
            beforeAll(function() {
                cpu = new CPU6502({ flavor: FLAVOR_ROCKWELL_65C02 });
                memory = new TestMemory(256);
                cpu.addPageHandler(memory);
            });

            describe.each(opAryRW65C02)('Test op $op $name $mode', ({op}) => {
                const data = fs.readFileSync(`${testPathRW65C02}${op}.json`, 'utf-8');
                const tests = JSON.parse(data) as Test[];

                it.each(tests.slice(0, maxTests))('Test $name', (test) => {
                    initState(cpu, test.initial);
                    memory.logStart();
                    cpu.step();
                    memory.logStop();
                    expectState(cpu, memory, test);
                });
            });
        });

        describe('WDC 65C02', function() {
            beforeAll(function() {
                cpu = new CPU6502({ flavor: FLAVOR_WDC_65C02 });
                memory = new TestMemory(256);
                cpu.addPageHandler(memory);
            });

            describe.each(opAryWDC65C02)('Test op $op $name $mode', ({op}) => {
                const data = fs.readFileSync(`${testPathWDC65C02}${op}.json`, 'utf-8');
                const tests = JSON.parse(data) as Test[];

                it.each(tests.slice(0, maxTests))('Test $name', (test) => {
                    initState(cpu, test.initial);
                    memory.logStart();
                    cpu.step();
                    memory.logStop();
                    expectState(cpu, memory, test);
                });
            });
        });
    });
} else {
    test('Skipping Tom Harte tests', () => { expect(testPath).toBeFalsy(); });
}