#include "sys_log.h"
#include "sys_crc.h"
#include <string.h>
#include "mod_sys.h"

#include "hal_flash.h"


#define    PARA_INIT(ID, LEN, VALUE)    {ID, LEN, &VALUE}

static sys_para_t g_s_sys_params;

static const sys_para_t g_s_sys_params_default = {
    .ble_mac = PARA_DEFAULT_BLE_MAC,
    .ble_name = PARA_DEFAULT_BLE_NAME,
    .ble_adv_interval = PARA_DEFAULT_BLE_ADV_INTERVAL,
};

typedef struct para_tlv_s
{
    uint8_t id;
    uint8_t len;
    void *value;
} PARA_TLV_S;

const PARA_TLV_S fwParaTLV[] =
{
    PARA_INIT(PARA_BLE_MAC,          6,    g_s_sys_params.ble_mac),
    PARA_INIT(PARA_BLE_NAME,         10,   g_s_sys_params.ble_name),
    PARA_INIT(PARA_BLE_ADV_INTERVAL, 4,    g_s_sys_params.ble_adv_interval),
};


static void MOD_SysFlashInit(void)
{
    HAL_FlashInit(NULL);
}

static int MOD_SysFlashWriteData(uint32_t addr, void *buf, uint16_t size)
{
    DLOG_I("write addr:0x%x, len:%d", addr, size);
    return HAL_FlashWriteBytes(addr, (uint8_t* )buf, size);
}

static int MOD_SysFlashReadData(uint32_t addr, void *buf, uint16_t size)
{
    return HAL_FlashReadBytes(addr, (uint8_t* )buf, size);
}

static int MOD_SysFlashEraseData(uint32_t addr)
{
    DLOG_I("erase addr:0x%x", addr);
    return HAL_FlashSectorErase(addr);
}

int MOD_SysCheckSector(uint32_t addr)
{
    /*检查扇区是否需要擦除*/
    int i;
    uint32_t tmp_data;

    for (i=0; i<FLASH_SECTOR_SIZE/4; i++)
    {
        MOD_SysFlashReadData(addr+4*i, &tmp_data, 4);
        if(tmp_data != 0xFFFFFFFF)
        {
            break;
        }
    }
    if(i < FLASH_SECTOR_SIZE/4)
    {
        DLOG_I("there is data");
        return 1;
    }
    DLOG_I("sector empty");
    return 0;
}


int MOD_SysWritePara(sys_para_t* para, int len)
{
    uint16_t tmp_crc = 0;
    int ret_len;
    uint8_t is_ok;

    if(NULL == para)
    {
        return 1;
    }

    para->para_size = len;

    tmp_crc = UTIL_CRC((uint8_t *)&para->para_size, len-2);
    para->para_crc = tmp_crc;

    if(0 != MOD_SysCheckSector(FLASH_MAIN_PARA_ADDR))
    {
        MOD_SysFlashEraseData(FLASH_MAIN_PARA_ADDR);
    }
    ret_len = MOD_SysFlashWriteData(FLASH_MAIN_PARA_ADDR, para, len);
    if (0 == ret_len)
    {
        is_ok |= 0x01;
    }

    if(0 != MOD_SysCheckSector(FLASH_BACKUP_PARA_ADDR))
    {
        MOD_SysFlashEraseData(FLASH_BACKUP_PARA_ADDR);
    }
    ret_len = MOD_SysFlashWriteData(FLASH_BACKUP_PARA_ADDR, para, len);
    if (0 == ret_len)
    {
        is_ok |= 0x02;
    }

    if(0x03 != is_ok)
    {
        return 2;
    }
    return 0;
}

static void MOD_SysLoadPara(void)
{
    uint8_t para_is_ok = 0;
    sys_para_t main_para_t, backup_para_t;

    if(0 == HAL_FlashReadBytes(FLASH_MAIN_PARA_ADDR, (uint8_t* )&main_para_t, sizeof(sys_para_t)))
    {
        if(main_para_t.para_crc == UTIL_CRC((uint8_t* )&main_para_t.para_size, sizeof(sys_para_t)-2))
        {
            DLOG_I("main para ok");
            para_is_ok |= 0x01;
        }
        else
        {
            DLOG_I("main para not ok");
        }
    }

    if(0 == HAL_FlashReadBytes(FLASH_BACKUP_PARA_ADDR, (uint8_t* )&backup_para_t, sizeof(sys_para_t)))
    {
        if(backup_para_t.para_crc == UTIL_CRC((uint8_t* )&backup_para_t.para_size, sizeof(sys_para_t)-2))
        {
            DLOG_I("backup para ok");
            para_is_ok |= 0x02;
        }
        else
        {
            DLOG_I("backup para not ok");
        }
    }

    if(0 == para_is_ok)
    {
        /*说明两个扇区内数据都不完整,写入默认配置*/
        memset(&g_s_sys_params, 0, sizeof(sys_para_t));
        memcpy(&g_s_sys_params, &g_s_sys_params_default, sizeof(sys_para_t));
        MOD_SysWritePara(&g_s_sys_params, sizeof(sys_para_t));
    }
    else if(0x01 == para_is_ok)
    {
        memcpy(&g_s_sys_params, &main_para_t, sizeof(sys_para_t));
        if(0 != MOD_SysCheckSector(FLASH_BACKUP_PARA_ADDR))
        {
            MOD_SysFlashEraseData(FLASH_BACKUP_PARA_ADDR);
        }
        MOD_SysFlashWriteData(FLASH_BACKUP_PARA_ADDR, &g_s_sys_params, sizeof(sys_para_t));
    }
    else if(0x02 == para_is_ok)
    {
        memcpy(&g_s_sys_params, &backup_para_t, sizeof(sys_para_t));
        if(0 != MOD_SysCheckSector(FLASH_MAIN_PARA_ADDR))
        {
            MOD_SysFlashEraseData(FLASH_MAIN_PARA_ADDR);
        }
        MOD_SysFlashWriteData(FLASH_MAIN_PARA_ADDR, &g_s_sys_params, sizeof(sys_para_t));
    }
    else
    {
        memcpy(&g_s_sys_params, &main_para_t, sizeof(sys_para_t));
        DLOG_I("all para is ok");
    }
}

static inline int MOD_SysGetMin(int a, int b)
{
    return (a < b) ? a : b;
}

static int16_t MOD_SysBinarySearch(uint8_t id)
{
    uint16_t low, high, mid;

    low = 0;
    high = sizeof(fwParaTLV) / sizeof(PARA_TLV_S);

    while (low <= high)
    {
        mid = (low + high) >> 1;
        if (id < fwParaTLV[mid].id)
        {
            high = mid - 1;
        }
        else if (id > fwParaTLV[mid].id)
        {
            low = mid + 1;
        }
        else
        {
            return mid;
        }
    }
    return -1;
}

void *MOD_SysGetPara(uint8_t id)
{
    int16_t para_num;
    para_num = MOD_SysBinarySearch(id);

    if (-1 == para_num)
    {
        DLOG_E("para Err");
        return NULL;
    }
    else
    {
        return fwParaTLV[para_num].value;
    }
}

int8_t MOD_SysSetPara(uint8_t id, uint8_t len, void *buffer)
{
    int16_t para_num;
    if ((NULL == buffer) || (0 == len))
    {
        DLOG_E("parameter error");
        return -1;
    }

    if (0 == memcmp(buffer, MOD_SysGetPara(id), len))
    {
        DLOG_I("para_id[%d],para not changed", id);
        return 0;
    }

    para_num = MOD_SysBinarySearch(id);
    if (-1 == para_num)
    {
        DLOG_E("para Err");
        return -2;
    }
    memset(fwParaTLV[para_num].value, 0, fwParaTLV[para_num].len);
    memcpy(fwParaTLV[para_num].value, buffer, MOD_SysGetMin(fwParaTLV[para_num].len, len));

    MOD_SysWritePara(&g_s_sys_params, sizeof(sys_para_t));

    return 0;
}

void MOD_SysInit(void)
{
    MOD_SysFlashInit();
    MOD_SysLoadPara();
}


void MOD_SysShowPara(void)
{
    DLOG_I("para_crc:0x%x, para_size:0x%x", g_s_sys_params.para_crc, g_s_sys_params.para_size);
    DLOG_I("ble_mac:0x%x0x%x0x%x0x%x0x%x0x%x0x%x0x%x",g_s_sys_params.ble_mac[0],g_s_sys_params.ble_mac[1],
                                                    g_s_sys_params.ble_mac[2],g_s_sys_params.ble_mac[3],
                                                    g_s_sys_params.ble_mac[4],g_s_sys_params.ble_mac[5]);
    DLOG_I("ble_name:%s", g_s_sys_params.ble_name);
    DLOG_I("ble_adv_Interval:%d", g_s_sys_params.ble_adv_interval);
}