#include <assert.h>
#include <stddef.h>
#include <stdio.h>
#include "parallel_nand.h"
#include "parallel_nand_gas.h"

typedef struct { char kind; unsigned int value; } event_t;
static event_t events[64];
static unsigned int event_count;
static pnand_octet_t input_data[32];
static unsigned int input_count;
static unsigned int input_pos;

static void record(char kind, unsigned int value)
{
    events[event_count].kind = kind;
    events[event_count].value = value;
    event_count++;
}
static int fake_init(void) { return 0; }
static void fake_select(void) { record('S', 0); }
static void fake_deselect(void) { record('D', 0); }
static void fake_cmd(pnand_octet_t v) { record('C', v); }
static void fake_addr(pnand_octet_t v) { record('A', v); }
static void fake_write(pnand_octet_t v) { record('W', v); }
static pnand_octet_t fake_read(void)
{
    return input_pos < input_count ? input_data[input_pos++] : 0xFFU;
}
static int fake_ready(void) { return 1; }
static void fake_wp(int enabled) { record('P', (unsigned int)enabled); }
static void fake_delay(unsigned long us) { (void)us; }

static const parallel_nand_port_t fake_port = {
    fake_init, fake_select, fake_deselect, fake_cmd, fake_addr, fake_write,
    fake_read, fake_ready, fake_wp, fake_delay
};

static void clear_events(void) { event_count = 0U; }

int main(void)
{
    parallel_nand_t nand;
    pnand_octet_t id[2];
    pnand_octet_t bytes[2];
    parallel_nand_gas_t gas;
    unsigned int reg;

    assert(parallel_nand_init(&nand, &fake_port,
                              &parallel_nand_mt29f1g08_geometry) == PNAND_OK);
    assert(events[0].kind == 'D');
    assert(events[1].kind == 'P' && events[1].value == 1U);

    clear_events();
    input_data[0] = 0x2CU;
    input_data[1] = 0xF1U;
    input_count = 2U;
    input_pos = 0U;
    assert(parallel_nand_read_id(&nand, 0U, id, 2U) == PNAND_OK);
    assert(id[0] == 0x2CU && id[1] == 0xF1U);
    assert(events[1].kind == 'C' && events[1].value == 0x90U);
    assert(events[2].kind == 'A' && events[2].value == 0U);

    clear_events();
    input_data[0] = 0x12U;
    input_data[1] = 0x34U;
    input_count = 2U;
    input_pos = 0U;
    assert(parallel_nand_read_page_slice(&nand, 0x1234UL, 0x56UL,
                                         bytes, 2UL) == PNAND_OK);
    assert(bytes[0] == 0x12U && bytes[1] == 0x34U);
    assert(events[1].kind == 'C' && events[1].value == 0x00U);
    assert(events[2].kind == 'A' && events[2].value == 0x56U);
    assert(events[3].kind == 'A' && events[3].value == 0x00U);
    assert(events[4].kind == 'A' && events[4].value == 0x34U);
    assert(events[5].kind == 'A' && events[5].value == 0x12U);
    assert(events[6].kind == 'C' && events[6].value == 0x30U);

    parallel_nand_gas_init(&gas, &nand, PNAND_GAS_DEFAULT_BASE);
    assert(parallel_nand_gas_read(&gas, 0xE000U, &reg) == PNAND_GAS_OK);
    assert(reg == 0x4E44U);
    assert(parallel_nand_gas_write(&gas, 0xE005U, 0x1234U) ==
           PNAND_GAS_OK);
    assert(parallel_nand_gas_write(&gas, 0xE006U, 0x0001U) ==
           PNAND_GAS_OK);
    assert(gas.selected_page == 0x00011234UL);
    gas.main_data[0] = 0x34U;
    gas.main_data[1] = 0x12U;
    gas.status |= PNAND_GAS_STATUS_PAGE_VALID;
    assert(parallel_nand_gas_read(&gas, 0xE100U, &reg) == PNAND_GAS_OK);
    assert(reg == 0x1234U);
    assert(parallel_nand_gas_write(&gas, 0xE000U, 0U) ==
           PNAND_GAS_READ_ONLY);

    puts("parallel_nand: OK");
    return 0;
}