/*----------------------------------------------------------------------------
 * Copyright (c) Fenda Technologies Co., Ltd. 2020. All rights reserved.
 *
 * Description: log_api.c 
 *
 * Author: saimen
 *
 * Create: 2022-7-16
 *--------------------------------------------------------------------------*/
//lib
#include <stdio.h>
#include <string.h>
#include <stdarg.h>
#include <assert.h>
//os
//sdk
#include "apollo4b.h"
//#include "am_mcu_apollo.h"
//drv
#include "sys_typedef.h"
#include "sys_config.h"
//user
#include "crc32.h"
#include "log_api.h"
#include "log_port.h"


#define ENABLE_STATIC_PRINT     false
extern uint32_t am_util_stdio_printf(const char *pcFmt, ...);
#define static_print_remind(...)     am_util_stdio_printf(__VA_ARGS__)
#if ENABLE_STATIC_PRINT
#define static_print_info(...)    am_util_stdio_printf(__VA_ARGS__)
#else
#define static_print_info(...)
#endif

#define ENABLE_PRINT_FILE_TXT   OFF
/**
TODO:Update
增加缓冲机制,该缓冲空间同时用于行为日志,错误日志及hardfault日志记录.
1.用于行为日志及错误日志是为了优化写入性能;
2.用于hardfault日志是避免在hardfault中断中动态申请空间引发其他错误(不使用栈空间是避免过多侵入式修改cmbacktrace库);
3.行为日志及错误日志同时存在两块cache,一块等待读出保存时,另一块进行写入.
4.用户调用接口时,只将数据打包放入缓冲,缓冲满时发消息给任务处理保存到文件.
5.空间分配如下图示意所示.
|----------------------|
|  Log cache Block 1   |
|----------------------|
|  Log cache Block 2   |
|----------------------|
*/
//可自定义
#define HEAD_ACTION             0xFA        //行为日志的标记头
#define HEAD_ERROR              0xFB        //错误日志的标记头
#define HEAD_FAULT              0xFB        //硬件错误日志的标记头
#define LOG_BUF_TOTAL_SIZE      2048        //日志缓冲总大小

//
#define LOG_INFO_VERSION        1           //日志系统版本
#define LOG_DATA_STRUCT_LEN     12          //日志数据结构体大小.
#define LOG_BUF_BLOCK_NUMBER    2           //行为日志及错误日志需要双缓冲,把缓冲分成两个块
#define LOG_BUF_BLOCK_INVALID   0xFF        //标记该缓冲块是无效的
#define LOG_BUF_BLOCK_SIZE      ((LOG_BUF_TOTAL_SIZE)/ LOG_BUF_BLOCK_NUMBER) //日志单个缓冲块大小
//日志描述单条可写入最大尺寸
#define LOG_DATA_DES_MAX_LEN    (LOG_BUF_BLOCK_SIZE - LOG_DATA_STRUCT_LEN)
#define LOG_FILE_PATH_MAX       64          //日志数据文件绝对路径的最大长度

//日志种类枚举
typedef enum {
    ACTION_EVT_TYPE,    //行为日志
    ERROR_EVT_TYPE,     //错误日志
    FAULT_EVT_TYPE,     //Fault日志
} DATA_LOG_TYPE;

#pragma pack(1) //编译时按1个字节对齐
typedef union {
    uint32_t val;
    struct _field {
        uint32_t info3:8;   //小类
        uint32_t info2:8;   //中类
        uint32_t info1:8;   //大类
        uint32_t evtId:8;   //事件ID
    } detail;
} LogInfoField;

typedef struct {
    uint8_t head;       //日志头
    uint8_t rev;        //保留
    uint16_t len;       //日志内容长度
    uint32_t timestamp; //日志内容:时间戳
    LogInfoField field; //日志内容:详情
    //char dsc[0];        //日志内容:描述(可选)
} log_data_t;
#pragma pack()  //编译时恢复默认字节对齐

//日志缓冲结构体定义
typedef struct {
    uint32_t init_flag:8;                           //标记模块是否初始化。=0 无效数据；=1 正常数据；=2 恢复数据。
    uint32_t version:8;                             //结构体版本
    uint32_t curUseBlockId:8;                       //正在使用的缓冲块ID
    uint32_t needSaveBlockId:8;                     //需要保存的缓冲块ID
    uint32_t blockWrtMaxSize;                       //缓冲块可写入的最大数量
    uint32_t blockStartTime[LOG_BUF_BLOCK_NUMBER];  //缓冲块所存数据的起始时间戳
    uint8_t *pBufBlock[LOG_BUF_BLOCK_NUMBER];       //指向缓冲块的指针数组
    uint32_t blockBufIdx[LOG_BUF_BLOCK_NUMBER];     //缓冲块指针偏移
    uint32_t crc32;
    uint32_t log_buf[LOG_BUF_TOTAL_SIZE/4];         //所有日志的缓冲
} log_info_t;

static log_info_t g_log_info;                       //存储行为日志缓冲块相关信息
static uint32_t g_log_count = 0;                    //日志流水号
static char g_full_path[LOG_FILE_PATH_MAX] = {0};

//debug start------------------------------------------------------
static void DEBUGHex(const uint8_t *dat, uint16_t len)
{
    uint16_t i;
    uint8_t column = 0;
    uint8_t length = 0;
    char buf[50];
    
    for(i = 0; i < len; i++) {
        length += snprintf(&buf[length], 50 - length, "%02X ", dat[i]);
        column++;
        if(column >= 16) {
            column = 0;
            length = 0;
            static_print_info("%s\r\n", buf);
        } else if((i+1) >= len){
            static_print_info("%s\r\n", buf);
        }
    }
}

/**
 * @brief   打印结构化的日志数据.
 * @param   path:const char *|日志路径.
 * @param   startAddrOft:UINT32|起始地址偏移.
 * @param   logNumlimit:UINT16|限制读取的结构块个数,0表示不限制.
 * @retval  void|无.
 * @note    只能打印ACTION_EVT_TYPE及ERROR_EVT_TYPE两类,fault日志不符合结构化数据.
 */
void log_print_bin_file(char *path, uint32_t startAddrOft, uint16_t logNumlimit)
{
#if 1
    int err = 0;
    uint32_t offset = startAddrOft;
    log_data_t logDat;
    char dsc[LOG_DATA_DES_MAX_LEN + 1]={0};
    uint16_t cnt = 0;
    uint16_t i = 0;
    
    do
    {
        err = log_port_read_file(path, offset, (uint8_t*)&logDat, sizeof(log_data_t));
        if(err == 0) 
        {
            static_print_info("%s find EOF before read head info\r\n", path);
            break;
        }
        else if(err == sizeof(log_data_t)) 
        {
            offset += err;
            if(logDat.head == HEAD_ACTION || logDat.head == HEAD_ERROR)
            {
                if(logDat.len > LOG_DATA_STRUCT_LEN)
                {
                    err = log_port_read_file(path, offset, (uint8_t*)dsc, (logDat.len - LOG_DATA_STRUCT_LEN));
                    if(err == 0)
                    {
                        static_print_info("%s find EOF before read description info\r\n", path);
                        break;
                    }
                    else if(err == (logDat.len - LOG_DATA_STRUCT_LEN))
                    {
                        dsc[err] = '\0';
                        offset += err;
                    }
                    else
                    {
                        static_print_remind("read description failed, invalid length [%d|%d]\r\n",(logDat.len - LOG_DATA_STRUCT_LEN), err);
                        break;
                    }
                    static_print_info("offset:0x%x len:%d TM:%d Code:%08X Dsc:%s\r\n", offset, logDat.len, logDat.timestamp, logDat.field.val, dsc);
                }
                else
                {
                    static_print_info("offset:0x%x len:%d TM:%d Code:%08X Dsc:NULL\r\n", offset, logDat.len, logDat.timestamp, logDat.field.val);
                }
            }
            else
            {
                static_print_info("error:offset:0x%x logDat.head=0x%x\r\n", offset, logDat.head);
                break;
            }
            
            cnt++;
            if(logNumlimit != 0 && cnt >= logNumlimit)
            {
                static_print_info("!!! read log number reach limit %d, exit read file\r\n", logNumlimit);
                break;
            }
        }
        else
        {
            static_print_remind("read head info failed, file:[%s] err:%d\r\n", path, err);
            break;
        }
    } while(1);
#endif
}

//debug end------------------------------------------------------
/**
 * @brief   将日志数据写入到缓冲.
 * @param   type:DATA_LOG_TYPE|日志种类.
 * @param   path:const char *|文件的绝对路径.
 * @param   dat:const uint8_t *|数据指针.
 * @param   len:UINT16|数据的长度.
 * @param   timestamp:UINT32|该条日志对应的时间.
 * @retval  int|返回写入的数据长度,负数表示错误码.
 */
static int log_write_to_buffer(DATA_LOG_TYPE type, uint32_t timestamp, uint8_t evtId, uint8_t info1, uint8_t info2, uint8_t info3, const char *dsc)
//static int log_write_to_buffer(DATA_LOG_TYPE type, const uint8_t *dat, uint16_t len, uint32_t timestamp)
{
    bool switch_block = false;
    uint8_t *p_cur_block;
    log_info_t *pLogBuf = NULL;
    log_data_t *p_log_data;
    uint16_t len = 0;
    uint16_t des_len = 0;
    
    pLogBuf = &g_log_info;
    
    if(dsc)
    {
        des_len = strlen(dsc);
        des_len = (des_len+3)&0xfffc;//四字节对齐
    }
    
    if(des_len >=LOG_DATA_DES_MAX_LEN) {
        static_print_info("log dsc info is too large, auto truncation length:(%d -> %d)\r\n", des_len, LOG_DATA_DES_MAX_LEN);
        des_len = LOG_DATA_DES_MAX_LEN;
    }
    
    len = LOG_DATA_STRUCT_LEN + des_len;
    
    if(pLogBuf->blockBufIdx[pLogBuf->curUseBlockId] + len > pLogBuf->blockWrtMaxSize)
    {
        pLogBuf->needSaveBlockId    = pLogBuf->curUseBlockId;
        pLogBuf->curUseBlockId      = ((pLogBuf->curUseBlockId + 1) % LOG_BUF_BLOCK_NUMBER);
        pLogBuf->blockBufIdx[pLogBuf->curUseBlockId] = 0;
        pLogBuf->blockStartTime[pLogBuf->curUseBlockId] = timestamp;
        switch_block = true;
        static_print_info("og cur use buf block is full, change block, block id info[using:%d|toSave:%d]\r\n", pLogBuf->curUseBlockId, pLogBuf->needSaveBlockId);
    }
    else
    {
        if(pLogBuf->blockBufIdx[pLogBuf->curUseBlockId] == 0)
        {
            static_print_info("type #%d# log cur block idx is 0, fill new buf start timestamp: %d\r\n", type, timestamp);
            pLogBuf->blockStartTime[pLogBuf->curUseBlockId] = timestamp;
        }
    }
    
    static_print_info("g_log_count:%d curUseBlockId:%d blockBufIdx:%d needSaveBlockId:%d\r\n", g_log_count,pLogBuf->curUseBlockId,pLogBuf->blockBufIdx[pLogBuf->curUseBlockId],pLogBuf->needSaveBlockId);
    p_cur_block = pLogBuf->pBufBlock[pLogBuf->curUseBlockId];
    p_log_data = (log_data_t*)&p_cur_block[pLogBuf->blockBufIdx[pLogBuf->curUseBlockId]];
    if(type == ACTION_EVT_TYPE) 
    {
        p_log_data->head = HEAD_ACTION;
    } 
    else if(type == ERROR_EVT_TYPE)
    {
        p_log_data->head = HEAD_ERROR;
    }
    else if(type == FAULT_EVT_TYPE)
    {
        p_log_data->head = HEAD_FAULT;
    }
    else
    {
        return 0;
    }
    
    p_log_data->rev = g_log_count++;
    p_log_data->field.detail.evtId = evtId;
    p_log_data->field.detail.info1 = info1;
    p_log_data->field.detail.info2 = info2;
    p_log_data->field.detail.info3 = info3;
    p_log_data->len = len-4;
    p_log_data->timestamp = timestamp;
    pLogBuf->blockBufIdx[pLogBuf->curUseBlockId] += LOG_DATA_STRUCT_LEN;
    
    if(des_len)
    {
        memcpy(&p_cur_block[pLogBuf->blockBufIdx[pLogBuf->curUseBlockId]], dsc, des_len);
        pLogBuf->blockBufIdx[pLogBuf->curUseBlockId] += des_len;
    }
    
    //if(switch_block==true)
    if(pLogBuf->needSaveBlockId != LOG_BUF_BLOCK_INVALID)//防止因为高优化级中断错过打点
    {
        #if 0
        //TODO:
        //!!!此处暂时直接同步保存缓冲数据到文件,因为多个锁的存在,可能存在死锁问题,后续测试若存在,需改成发送消息给任务,在任务中调用保存接口,同时避免长时间占用锁.
        static_print_info("!!! ready write buf[len:%d] to file\r\n", pLogBuf->blockBufIdx[pLogBuf->needSaveBlockId]);
        saveLen = SaveDataLogBufToFile(type);
        static_print_info("!!! write ret: %d\r\n", saveLen);
        #else
        //TODO:
        //!!!因需要支持硬中断打点,故不再适合使用同步写入方式,采用信号量实现异步写入
        if (__get_IPSR() == 0) {
            // not interrupt
            log_port_notify(LOG_EVENT_CACHE_FULL);
        }
        #endif
    }
    
    return 0;
}

/**
* @brief   将日志缓冲有效数据写入到文件.一般关机时使用
 * @retval  int|返回写入的数据长度,负数表示错误码.
 */
static int log_write_valid_cache_to_file(void)
{
    uint16_t ret=0;
    uint16_t len;
    uint32_t timestamp = 0;
    uint8_t *buf;
    log_info_t *pLogBuf = NULL;
    
    pLogBuf = &g_log_info;
    static_print_info("log using block=%d data len=%d,save block=%d\r\n", pLogBuf->curUseBlockId, pLogBuf->blockBufIdx[pLogBuf->curUseBlockId],pLogBuf->needSaveBlockId);
    if(pLogBuf->needSaveBlockId != LOG_BUF_BLOCK_INVALID)
    {
        timestamp = pLogBuf->blockStartTime[pLogBuf->needSaveBlockId];
        len = pLogBuf->blockBufIdx[pLogBuf->needSaveBlockId];
        buf = pLogBuf->pBufBlock[pLogBuf->needSaveBlockId];
        log_port_write_file(g_full_path, buf, len);
        ret += len;
//        memcpy(buf, pLogBuf->pBufBlock[pLogBuf->needSaveBlockId], len);
        static_print_info("log unsaved block %d data len %d\r\n", pLogBuf->needSaveBlockId, len);
    }
    
    if(pLogBuf->blockBufIdx[pLogBuf->curUseBlockId] > 0) 
    {
        timestamp = pLogBuf->blockStartTime[pLogBuf->curUseBlockId];
        len = pLogBuf->blockBufIdx[pLogBuf->curUseBlockId];
        buf = pLogBuf->pBufBlock[pLogBuf->curUseBlockId];
        log_port_write_file(g_full_path, buf, len);
        ret += len;
        static_print_info("log using block %d data len %d\r\n", pLogBuf->curUseBlockId, pLogBuf->blockBufIdx[pLogBuf->curUseBlockId]);
    }
    
    pLogBuf->blockStartTime[0] = 0;
    pLogBuf->blockStartTime[1] = 0;
    pLogBuf->blockBufIdx[0] = 0;
    pLogBuf->blockBufIdx[1] = 0;
    pLogBuf->curUseBlockId = 0;
    pLogBuf->needSaveBlockId = LOG_BUF_BLOCK_INVALID;
    return ret;
}

/**
 * @brief   获取选定日志所有未保存缓冲数据.
 * @param   type:DATA_LOG_TYPE|日志种类.
 * @param   buf:UINT8 *|用来保存缓冲数据的缓存指针.
 * @param   timestamp:UINT32 *|unix时间戳.
 * @retval  UINT32|返回数据长度,负数表示错误码.
 */
static int log_get_not_saved_cache(uint8_t *buf, uint32_t *timestamp)
{
    uint32_t len = 0;
    log_info_t *pLogBuf = NULL;
    
    pLogBuf = &g_log_info;
    
    if (__get_IPSR() == 0) {
        // not interrupt
        log_port_lock();
    }
    
    if(pLogBuf->needSaveBlockId != LOG_BUF_BLOCK_INVALID) {
        *timestamp = pLogBuf->blockStartTime[pLogBuf->needSaveBlockId];
        len = pLogBuf->blockBufIdx[pLogBuf->needSaveBlockId];
        memcpy(buf, pLogBuf->pBufBlock[pLogBuf->needSaveBlockId], len);
        static_print_info("get log unsaved block %d data len %d\r\n", pLogBuf->needSaveBlockId, len);
    } else {
        *timestamp = pLogBuf->blockStartTime[pLogBuf->curUseBlockId];
    }
    
    if(pLogBuf->blockBufIdx[pLogBuf->curUseBlockId] > 0) {
        memcpy(buf + len, pLogBuf->pBufBlock[pLogBuf->curUseBlockId], pLogBuf->blockBufIdx[pLogBuf->curUseBlockId]);
        len += pLogBuf->blockBufIdx[pLogBuf->curUseBlockId];
        static_print_info("get log using block %d data len %d\r\n", pLogBuf->curUseBlockId, pLogBuf->blockBufIdx[pLogBuf->curUseBlockId]);
    }
    
    if (__get_IPSR() == 0) {
        // not interrupt
        log_port_unlock();
    }
    
    return (len == 0) ? 0 : len;
}

static int log_api_restore(void)
{
    log_info_t *p_log_info = &g_log_info;
    
    static_print_info("log_api_restore\n");
    p_log_info->init_flag           = true;
    p_log_info->version             = LOG_INFO_VERSION;
    p_log_info->curUseBlockId       = 0;
    p_log_info->needSaveBlockId     = LOG_BUF_BLOCK_INVALID;
    p_log_info->blockWrtMaxSize     = LOG_BUF_BLOCK_SIZE;
    p_log_info->pBufBlock[0]        = (uint8_t *)&g_log_info.log_buf[0];
    p_log_info->pBufBlock[1]        = (uint8_t *)&g_log_info.log_buf[LOG_BUF_BLOCK_SIZE];
    p_log_info->blockStartTime[0]   = 0;
    p_log_info->blockStartTime[1]   = 0;
    p_log_info->blockBufIdx[0]      = 0;
    p_log_info->blockBufIdx[1]      = 0;
}
//log api start-------------------------------------------------
/**
 * @brief   创建日志模块嵌套互斥锁
 * @retval  int| 返回错误码,0=成功.
 */
int log_api_create_lock(void)
{
    return log_port_create_lock();
}

/**
 * @brief   初始化日志数据.
 * @retval  int|返回结果,0=成功,负数表示错误码.
 */
int log_api_init(void)
{
#if 1
    int err = 0;
    log_info_t *p_log_info = NULL;
    uint32_t ui32_crc;
    
    p_log_info = &g_log_info;
    //获取日志路径
    log_port_get_full_path(NULL, g_full_path);
    static_print_remind("[%s],sizeof(log_info_t) = %d\r\n",g_full_path,sizeof(log_info_t));
    
    if(sizeof(log_data_t) != LOG_DATA_STRUCT_LEN || sizeof(log_data_t) > LOG_BUF_TOTAL_SIZE)
    {
        err = true;
        static_print_remind("error:sizeof(log_data_t)");
    }
    
    if(LOG_BUF_BLOCK_NUMBER != 2)
    {
        err = true;
        static_print_remind("error:LOG_BUF_BLOCK_NUMBER");
    }
    
    if(err)
    {
        p_log_info->init_flag = false;
        return RET_ERROR;
    }
    
    ui32_crc = crc32_ex(0,(uint8_t*)&g_log_info, (sizeof(g_log_info) - 4- LOG_BUF_TOTAL_SIZE));
    if(ui32_crc != g_log_info.crc32 || g_log_info.version != LOG_INFO_VERSION)
    {
        log_api_restore();
    }
    
    //保存缓冲区数据
    log_write_valid_cache_to_file();
    //打几条log
//    log_print_bin_file(g_full_path,0,10);
    
    return RET_SUCCESS;
#endif
}

/**
 * @brief   将选定的缓冲数据保存到对应的日志文件.
 * @retval  int|返回写入的数据长度,负数表示错误码.
 */
int log_api_save_at_cache_full(void)
{
    int err = 0;
    char file_path[LOG_FILE_PATH_MAX];
    log_info_t *pLogBuf = NULL;
    
    pLogBuf = &g_log_info;
    
    static_print_info("log_api_save_at_cache_full()\r\n");
    if(pLogBuf->needSaveBlockId == LOG_BUF_BLOCK_INVALID || pLogBuf->needSaveBlockId >= LOG_BUF_BLOCK_NUMBER ||\
        pLogBuf->blockBufIdx[pLogBuf->needSaveBlockId] > pLogBuf->blockWrtMaxSize) {
        static_print_remind("save log to file failed, verify not passed\r\n");
        return -1;
    }

    err = log_port_write_file(g_full_path, pLogBuf->pBufBlock[pLogBuf->needSaveBlockId], \
            pLogBuf->blockBufIdx[pLogBuf->needSaveBlockId]);
    
    pLogBuf->blockBufIdx[pLogBuf->needSaveBlockId] = 0;
    pLogBuf->needSaveBlockId = LOG_BUF_BLOCK_INVALID;
    
    return err;
}

/**
 * @brief   在正常关机前保存所有未保存的缓冲数据.
 * @retval  UINT32|返回数据长度,负数表示错误码.
 */
int log_api_save_at_power_off(void)
{
    uint16_t len;
    uint32_t timestamp = 0;
    uint8_t *buf;
    log_info_t *pLogBuf = NULL;
    
    static_print_info("log_api_save_at_power_off()\r\n");
    pLogBuf = &g_log_info;
    
    if (__get_IPSR() == 0) {
        // not interrupt
        log_port_lock();
    }
    
    len = log_write_valid_cache_to_file();
    
    if (__get_IPSR() == 0) {
        // not interrupt
        log_port_unlock();
    }
    return len;
}

/**
 * @brief   记录单条行为日志.
 * @param   timestamp:UINT32|unix时间戳.
 * @param   evtId:UINT8|日志事件ID.
 * @param   info1:UINT8|日志事件大类.
 * @param   info2:UINT8|日志事件中类.
 * @param   info3:UINT8|日志事件小类.
 * @param   dsc:const char *|日志事件描述.
 * @retval  UINT16|返回记录的数据长度,负数表示错误码.
 */
int log_api_record_action(uint32_t timestamp, uint8_t evtId, uint8_t info1, uint8_t info2, uint8_t info3, const char *dsc)
{
    int err = 0;
    
    /*
    if (__get_IPSR() != 0) {
        static_print_info("!!! not support record action log in isr[%d:%d:%d:%d]\r\n", evtId, info1, info2, info3);
        return -1;
    } */
    
    if(g_log_info.init_flag == false)
    {
        static_print_info("!!! record action log failed, not initialization\r\n");
        return -1;
    }
    
    log_port_lock();
    log_write_to_buffer(ACTION_EVT_TYPE, timestamp, evtId, info1, info2, info3, dsc);
    log_port_unlock();
    
    static_print_info("action log:[0x%08X]\r\n", (evtId<<24)+(info1<<16)+(info2<<8)+info3);
    
    return err;
}

/**
 * @brief   记录单条错误日志.
 * @param   timestamp:UINT32|unix时间戳.
 * @param   evtId:UINT8|日志事件ID.
 * @param   info1:UINT8|日志事件大类.
 * @param   info2:UINT8|日志事件中类.
 * @param   info3:UINT8|日志事件小类.
 * @param   dsc:const char *|日志事件描述.
 * @retval  UINT16|返回记录的数据长度,负数表示错误码.
 */
int log_api_record_error(uint32_t timestamp, uint8_t evtId, uint8_t info1, uint8_t info2, uint8_t info3, const char *dsc)
{
    int err = 0;
    
    /*
    if (__get_IPSR() != 0) {
        static_print_info("!!! not support record error log in isr\r\n");
        return -1;
    } */
    
    if(g_log_info.init_flag == false) {
        static_print_info("!!! record error log failed, not initialization\r\n");
        return -1;
    }
    
    log_port_lock();
    log_write_to_buffer(ERROR_EVT_TYPE, timestamp, evtId, info1, info2, info3, dsc);
    log_port_unlock();
    static_print_info("error log:[0x%08X]\r\n", (evtId<<24)+(info1<<16)+(info2<<8)+info3);
    
    return err;
}

/**
 * @brief   记录单条行为日志.
 * @param   timestamp:UINT32|unix时间戳.
 * @param   evtId:UINT8|日志事件ID.
 * @param   info1:UINT8|日志事件大类.
 * @param   info2:UINT8|日志事件中类.
 * @param   info3:UINT8|日志事件小类.
 * @param   dsc:const char *|日志事件描述.
 * @retval  UINT16|返回记录的数据长度,负数表示错误码.
 */
int log_api_record_hardfault(uint32_t timestamp, uint8_t evtId, uint8_t info1, uint8_t info2, uint8_t info3, const char *dsc)
{
    int err = 0;
    /*
    if (__get_IPSR() != 0) {
        static_print_info("!!! not support record action log in isr[%d:%d:%d:%d]\r\n", evtId, info1, info2, info3);
        return -1;
    } */
    
    if(g_log_info.init_flag == false) {
        static_print_info("!!! record action log failed, not initialization\r\n");
        return -1;
    }
    
    log_port_lock();
    log_write_to_buffer(FAULT_EVT_TYPE, timestamp, evtId, info1, info2, info3, dsc);
    log_port_unlock();
    
    static_print_info("action log:[0x%08X]\r\n", (evtId<<24)+(info1<<16)+(info2<<8)+info3);
    return err;
}

//外部存储使用
void* log_api_get_info(uint32_t *len, char **path)
{
    g_log_info.crc32 = crc32_ex(0,(uint8_t*)&g_log_info, (sizeof(g_log_info) - 4- LOG_BUF_TOTAL_SIZE));
    *len = sizeof(g_log_info);
    *path = (char*)g_full_path;
    return &g_log_info;
}

void log_api_set_save_flag(uint8_t value)
{
    if(value == false)
    {
        log_api_restore();
    }
}

uint8_t log_api_get_save_flag(void)
{
    if(g_log_info.needSaveBlockId == LOG_BUF_BLOCK_INVALID && g_log_info.blockBufIdx[g_log_info.curUseBlockId]==0)
    {
        return false;
    }
    else
    {
        return true;
    }
}
//log api end-------------------------------------------------