#include "os_types.h"
#include "dbg_io.h"
#include "iot_io.h"
#include "flash.h"
#include "sfc.h"
#include "os_mem.h"
#include "iot_errno_api.h"

#define IOT_FLASH_TEST_PRINT_CYCLE  50
#define IOT_FLASH_TEST_DATA_LEN     1024
#define IOT_FLASH_TEST_PAGE_LEN     256
#define IOT_FLASH_TEST_SECTOR_LEN   4096
#define IOT_FLASH_TEST_OFFSET_TABLE {0x00009000}

uint8_t wbuf[IOT_FLASH_TEST_DATA_LEN];
uint8_t ebuf[IOT_FLASH_TEST_DATA_LEN];
uint8_t rbuf[IOT_FLASH_TEST_DATA_LEN];

void iot_flash_test_dump(char *buf, uint32_t len)
{
    uint32_t *p_data = (uint32_t *)buf, i;

    for (i = 0; i < len; i += 4) {
        if (0 == (i % 16)) {
            iot_printf("\r\n");
        }
        iot_printf("%08x ",p_data++);
    }

    return;
}

void iot_flash_test_write(uint8_t *buf, uint32_t offset, uint32_t buf_len)
{
    uint32_t len = buf_len, w_size, s_offset = offset;

    while(len > 0) {
        w_size = len > IOT_FLASH_TEST_PAGE_LEN ? IOT_FLASH_TEST_PAGE_LEN : len;
        g_sfc_ctrl->write(buf, s_offset, w_size, MOD_SFC_PROG_STAND, MOD_SW_MODE_DIS);
        len -= w_size;
        s_offset += w_size;
        buf += w_size;
    }

  return;
}

void iot_flash_test_read(uint8_t *buf, uint32_t offset, uint32_t buf_len)
{
    uint32_t len = buf_len, r_size, s_offset = offset;

    while(len > 0) {
        r_size = len > IOT_FLASH_TEST_PAGE_LEN ? IOT_FLASH_TEST_PAGE_LEN : len;
        g_sfc_ctrl->read(buf, s_offset, r_size, MOD_SFC_READ_SIG);
        len -= r_size;
        s_offset += r_size;
        buf += r_size;
    }

    return;
}

void iot_flash_test_erase(uint32_t offset, uint32_t min_len)
{
    uint32_t e_offset = offset + min_len;

    while(e_offset > offset) {
        g_sfc_ctrl->erase_sector(offset, MOD_SW_MODE_DIS);
        offset += IOT_FLASH_TEST_SECTOR_LEN;
    }

    return;
}

uint32_t iot_flash_test_mem_cmp_int32(void *src1, void *src2, uint32_t len_bytes)
{
    uint32_t *p1 = src1, *p2 = src2, *end = (p1 + len_bytes / sizeof(*p1));

    while (p1 < end) {
        if (*p1++ != *p2++) {
            return 1;
        }
    }

    return 0;
}

uint32_t iot_flash_test_write_cycle(uint32_t offset)
{
    iot_flash_test_erase(offset, IOT_FLASH_TEST_DATA_LEN);
    iot_flash_test_read(rbuf, offset, IOT_FLASH_TEST_DATA_LEN);

    if (iot_flash_test_mem_cmp_int32(ebuf, rbuf, IOT_FLASH_TEST_DATA_LEN)) {
        iot_printf("\r\nErase failed, offset = %p.\r\nData read :", offset);
        iot_flash_test_dump((char*)rbuf, IOT_FLASH_TEST_DATA_LEN);
        return ERR_FAIL;
    }

    iot_flash_test_write(wbuf,offset, IOT_FLASH_TEST_DATA_LEN);
    iot_flash_test_read(rbuf, offset, IOT_FLASH_TEST_DATA_LEN);
    if (iot_flash_test_mem_cmp_int32(wbuf, rbuf, IOT_FLASH_TEST_DATA_LEN)) {
        iot_printf("\r\nWrite failed, offset = %p.\r\nData read :", offset);
        iot_flash_test_dump((char*)rbuf, IOT_FLASH_TEST_DATA_LEN);
        return ERR_FAIL;
    }

    return ERR_OK;
}

void iot_flash_test_cpu_delay(uint32_t ms)
{
    volatile uint32_t delay = 7500 * ms, tmp = 0;
    while (--delay) tmp += delay;
    return;
}

int main(void)
{

    uint32_t test_offset[]=IOT_FLASH_TEST_OFFSET_TABLE, i, block_cnt, cycle = 0;

    dbg_uart_init();

    flash_init(1);

    os_mem_set(ebuf, 0xFF, IOT_FLASH_TEST_DATA_LEN);
    os_mem_set(wbuf, 0xA5, IOT_FLASH_TEST_DATA_LEN);

    block_cnt = (sizeof(test_offset) / sizeof(test_offset[0]));

    while(1) {
        for (i = 0; i < block_cnt; i++) {
            if (ERR_OK != iot_flash_test_write_cycle(test_offset[i])) {
                goto endness_loop;
            }
        }

        cycle++;

        if (0 == (cycle % IOT_FLASH_TEST_PRINT_CYCLE)) {
            iot_printf("\r\nCycle %d passed.", cycle);
        }
    }

endness_loop:

    while(1) {
        iot_flash_test_cpu_delay(2000);
        iot_printf("\r\nTEST STOPED @ ERROR BLOCK %p, CYCLE = %u.",
            test_offset[i], cycle);
    }
}