#include <errno.h>
#include <string.h>
#include <stdlib.h>

#include "T1.h"
#include "phdriver.h"
#include "se_api.h"
#include "mk_misc.h"
#include "mk_trace.h"

static uint8_t gp_data_tx[270];
static uint8_t gp_data_tx_bck[270];
uint8_t gp_data_rx[270];
static T1_params g_T1_params;
static uint8_t g_all_data_buf[1024];

atr_info g_atr = {
    .len = 0x13,
    .vendor_ID = {0x00},
    .dll_IC = 0x01,
    .bgt = {0x00, 0x01},
    .bwt = {0x03, 0xE8},
    .max_freq = {0x4E, 0x20},
    .checksum = 0x00,
    .default_IFSC = 0xFE,
    .num_channels = 0x01,
    .max_IFSC = {0x00, 0xFF},
    .capbilities = {0x00, 0x14}, // Extended frame length feature doesn't support
};

uint32_t g_recv_total_len = 0;

static uint8_t t1_calculate_LRC(uint8_t *p_data, uint16_t offset, uint16_t len);
static uint16_t t1_calculate_CRC(uint8_t *p_data, uint16_t offset, uint16_t len);
static void t1_set_epilogue(uint8_t *p_data, uint16_t offset, uint16_t len);

static ESESTATUS t1_read(uint16_t *p_data_len);

static uint8_t set_info_len(uint8_t *p_data, uint16_t info_len);
static uint16_t get_info_len(uint8_t *p_data);
static ESESTATUS decode_ATR(uint8_t *p_data, bool is_CIP);
static void free_tx_part_mem(void);
static void reset_for_resync_rsp(void);

static ESESTATUS do_T1_recovery_at_decode_Iframe(void);
static ESESTATUS do_T1_recovery_at_decode_Sframe(void);
static ESESTATUS do_T1_recovery_at_decode_Rframe(void);
static ESESTATUS t1_recv_data_store_in_list(uint8_t *p_data, uint16_t data_len, uint16_t total_len);
static void t1_recv_data_list_destroy(void);
static void reset_ATR(void);

/******************************************************************************
 * @Function     Transmit_receive_process
 * @Returns      On success return ESESTATUS_SUCCESS or else ESESTATUS error.
 ******************************************************************************/
ESESTATUS Transmit_receive_process(void)
{
    ESESTATUS status = ESESTATUS_SUCCESS;
    g_ese_ctx.is_read_done = false;

    g_recv_total_len = 0;
    while (STATE_IDEL != g_ese_ctx.next_T1_state)
    {
        switch (g_ese_ctx.p_T1_params->tx_frame_type)
        {
            case IFRAME:
            {
                status = t1_send_Iframe();
                break;
            }

            case RFRAME:
            {
                status = t1_send_Rframe();
                break;
            }

            case SFRAME:
            {
                status = t1_send_Sframe();
                break;
            }
            case FRAME_TYPE_INVALID_MAX:
            case FRAME_TYPE_INVALID_MIN:
            {
                status = ESESTATUS_INVALID_PARAMETER;
                LOG_INFO(TRACE_MODULE_SE, "%s : invalid T1 frame type: %d\r\n", __FUNCTION__, g_ese_ctx.p_T1_params->tx_frame_type);
            }
        }

        if (ESESTATUS_SUCCESS == status)
        {
#ifdef DBG_LEVEL_STACK
            gDumpStackFlag = false;
#endif
            g_ese_ctx.p_T1_params->blk_retry_cnt = 0;
            status = response_process();
            // Do not need handle the status value
        }
        else
        {
            if (((ESESTATUS_PH_IO != status) && (ESESTATUS_MEM_EXCEPTION != status)) || (g_ese_ctx.p_T1_params->blk_retry_cnt >= g_ese_ctx.max_blk_retry_cnt))
            {
                LOG_INFO(TRACE_MODULE_SE, "%s: send frame failed, frameType = %d, status = %d, retryCnt = %d\r\n", __FUNCTION__,
                         g_ese_ctx.p_T1_params->tx_frame_type, status, g_ese_ctx.max_blk_retry_cnt);
                g_ese_ctx.next_T1_state = STATE_IDEL;
                break;
            }
            else
            {
                // resend
                g_ese_ctx.p_T1_params->blk_retry_cnt++;
            }
        }
    }

    return status;
}

/******************************************************************************
 * @Function     response_process
 * @Returns      On success return ESESTATUS_SUCCESS or else ESESTATUS error.
 ******************************************************************************/
ESESTATUS response_process(void)
{
    ESESTATUS status = ESESTATUS_SUCCESS;
    uint16_t data_len = 0;

    // LOG_INFO(TRACE_MODULE_SE, "%s: enter\r\n", __FUNCTION__);
    status = t1_read(&data_len);

    if (ESESTATUS_SUCCESS == status)
    {
        status = t1_chk_epilogue(gp_data_rx, 0, data_len);
        if (status == ESESTATUS_SUCCESS)
        {
            status = t1_decode_frame(data_len);

            if (ESESTATUS_SUCCESS == status)
            {
            }
        }
        else
        {
            do_T1_recovery_at_undecode();
        }
    }
    else if (ESESTATUS_FATAL_ERROR == status)
    {
        g_ese_ctx.next_T1_state = STATE_IDEL;
    }
    else
    {
        do_T1_recovery_at_undecode();
    }

    return status;
}

/******************************************************************************
 * @Function         t1_send_Sframe
 * @Returns          On success return ESESTATUS_SUCCESS or else ESESTATUS error.
 ******************************************************************************/
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wswitch-enum"
#endif
ESESTATUS t1_send_Sframe(void)
{
    ESESTATUS status = ESESTATUS_SUCCESS;
    int ret = -1;
    uint8_t frame_len = 0;

    if (SFRAME_TYPE_INVALID == g_ese_ctx.p_T1_params->tx_sub_Sframe_type)
    {
        LOG_INFO(TRACE_MODULE_SE, "%s : invalid S-block frame type: %d\r\n", __FUNCTION__, g_ese_ctx.p_T1_params->tx_sub_Sframe_type);
        return ESESTATUS_INVALID_PARAMETER;
    }
    else
    {
        frame_len = get_header_len(true);
    }

    // memset(gp_data_tx, 0, sizeof(gp_data_tx));
    switch (g_ese_ctx.p_T1_params->tx_sub_Sframe_type)
    {
        case RESYNC_REQ:
        {
            gp_data_tx[T1_PCB_OFFSET] = (T1_S_BLOCK_REQ_MASK | RESYNC_REQ);
            break;
        }

        case IFS_REQ:
        {
            uint8_t len_offset = 0, info_len = 0x02;
            frame_len += info_len;
            gp_data_tx[T1_PCB_OFFSET] = (T1_S_BLOCK_REQ_MASK | IFS_REQ);
            len_offset = set_info_len(gp_data_tx, info_len);
            gp_data_tx[len_offset + 1] = (uint8_t)(g_ese_ctx.max_IFSD >> 8);
            gp_data_tx[len_offset + 2] = (uint8_t)(g_ese_ctx.max_IFSD & 0xFF);
            break;
        }

        case IFS_RSP:
        {
            uint8_t len_offset = 0, info_len = 0;
            info_len = (uint8_t)get_info_len(gp_data_rx);
            frame_len += info_len;
            gp_data_tx[T1_PCB_OFFSET] = (T1_S_BLOCK_REQ_MASK | IFS_REQ);
            len_offset = set_info_len(gp_data_tx, info_len);
            memcpy(&gp_data_tx[len_offset + 1], &gp_data_rx[len_offset + 1], info_len);
            break;
        }

        case ABORT_REQ:
        {
            gp_data_tx[T1_PCB_OFFSET] = (T1_S_BLOCK_REQ_MASK | ABORT_REQ);
            break;
        }
        case WTX_RSP:
        {
            uint8_t len_offset = 0, info_len = 1;
            frame_len += info_len;
            gp_data_tx[T1_PCB_OFFSET] = (T1_S_BLOCK_REQ_MASK | WTX_RSP);
            len_offset = set_info_len(gp_data_tx, info_len);
            gp_data_tx[len_offset + 1] = g_ese_ctx.p_T1_params->wtx_info;
            break;
        }

        case CIP_REQ:
        {
            /* Note:T1 CIP_REQ for ATR, the frame's INFO length should be 1 byte,
             */
            gp_data_tx[T1_PCB_OFFSET] = (T1_S_BLOCK_REQ_MASK | CIP_REQ);
            break;
        }

        case PROP_END_APDU_REQ:
        {
            gp_data_tx[T1_PCB_OFFSET] = (T1_S_BLOCK_REQ_MASK | PROP_END_APDU_REQ);
            break;
        }

        case HARD_RESET_REQ:
        {
            break;
        }

        case ATR_REQ:
        {
            gp_data_tx[T1_PCB_OFFSET] = (T1_S_BLOCK_REQ_MASK | ATR_REQ);
            break;
        }

        default:
        {
            LOG_INFO(TRACE_MODULE_SE, "%s : invalid S-block frame type: %X\r\n", __FUNCTION__, g_ese_ctx.p_T1_params->tx_sub_Sframe_type);
            break;
        }
    }

    gp_data_tx[T1_NAD_OFFSET] = NAD_D2C;
    // caculate LRC or CRC and set it to pFramebuff
    t1_set_epilogue(gp_data_tx, 0, frame_len);

    ret = phdriver_write(gp_data_tx, frame_len);
    if (-1 == ret)
    {
        status = ESESTATUS_PH_IO;
        LOG_INFO(TRACE_MODULE_SE, "write fail: %s, errno = %d, ret = %d\r\n", __FUNCTION__, errno, ret);
    }

    return status;
}
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif

/******************************************************************************
 * @Function         t1_send_Iframe
 * @Returns          On success return ESESTATUS_SUCCESS or else ESESTATUS error.
 ******************************************************************************/
ESESTATUS t1_send_Iframe(void)
{
    ESESTATUS status = ESESTATUS_SUCCESS;
    int ret = -1;
    uint16_t frame_len = 0;
    uint8_t *p_frame_buf = NULL;
    uint16_t len_offset = 0;
    uint16_t send_len = 0;
    uint16_t tx_data_offset = 0;

    if (g_ese_ctx.p_T1_params->recovery_cnt > g_ese_ctx.max_recovery_cnt)
    {
        LOG_INFO(TRACE_MODULE_SE, "%s fatal error, recovery_cnt = %d\r\n", __FUNCTION__, g_ese_ctx.p_T1_params->recovery_cnt);
        status = ESESTATUS_FATAL_ERROR;
        goto cleanup;
    }
    else if ((g_ese_ctx.p_T1_params->p_data_tx_part != NULL))
    {
        // LOG_INFO(TRACE_MODULE_SE, "%s retry_send_part, tx_len_part = %u\r\n", __FUNCTION__, g_ese_ctx.p_T1_params->tx_len_part);
        p_frame_buf = g_ese_ctx.p_T1_params->p_data_tx_part;
        frame_len = g_ese_ctx.p_T1_params->tx_len_part;
        goto retry_send_part;
    }

    tx_data_offset = g_ese_ctx.p_T1_params->tx_data_offset;

    frame_len = (g_ese_ctx.is_T1_ext_hdr_len ? T1_EXT_HEADER_LEN : T1_HEADER_LEN) + ((LRC == g_atr.checksum) ? T1_LRC_LEN : T1_CRC_LEN);

    if ((g_ese_ctx.p_T1_params->tx_len - tx_data_offset) > g_ese_ctx.max_IFSC)
    {
        g_ese_ctx.p_T1_params->is_device_chaining = true;
        send_len = g_ese_ctx.max_IFSC;
        tx_data_offset += g_ese_ctx.max_IFSC;
    }
    else
    {
        g_ese_ctx.p_T1_params->is_device_chaining = false;
        send_len = g_ese_ctx.p_T1_params->tx_len - tx_data_offset;
        tx_data_offset += send_len;
    }

    frame_len += send_len;
    // memset(gp_data_tx, 0, sizeof(gp_data_tx));
    p_frame_buf = gp_data_tx;

    p_frame_buf[T1_NAD_OFFSET] = NAD_D2C;
    len_offset = set_info_len(p_frame_buf, send_len);
    memcpy((p_frame_buf + len_offset + 1), (g_ese_ctx.p_T1_params->p_data_tx + g_ese_ctx.p_T1_params->tx_data_offset), send_len);
    g_ese_ctx.p_T1_params->tx_data_offset = tx_data_offset;

    // memset(gp_data_tx_bck, 0, sizeof(gp_data_tx_bck));
    memcpy(gp_data_tx_bck, p_frame_buf, frame_len);
    g_ese_ctx.p_T1_params->p_data_tx_part = gp_data_tx_bck;
    g_ese_ctx.p_T1_params->tx_len_part = frame_len;

retry_send_part:
    p_frame_buf[T1_PCB_OFFSET] = 0x00;
    if (g_ese_ctx.p_T1_params->is_device_chaining)
    {
        p_frame_buf[T1_PCB_OFFSET] |= T1_CHAINING_MASK;
    }
    p_frame_buf[T1_PCB_OFFSET] |= (g_ese_ctx.seq_num_device << 6);

    t1_set_epilogue(p_frame_buf, 0, frame_len);

    ret = phdriver_write(p_frame_buf, frame_len);
    if (-1 == ret)
    {
        status = ESESTATUS_PH_IO;
        LOG_INFO(TRACE_MODULE_SE, "write fail: %s, errno = %d, ret = %d\r\n", __FUNCTION__, errno, ret);
    }

cleanup:

    if (S_ABORT_RSP == g_ese_ctx.next_T1_state)
    {
        g_ese_ctx.next_T1_state = STATE_IDEL;
        free_tx_part_mem();
    }

    return status;
}

/******************************************************************************
 * @Function         t1_send_Rframe
 * @Returns          On success return ESESTATUS_SUCCESS or else ESESTATUS error.
 ******************************************************************************/
ESESTATUS t1_send_Rframe(void)
{
    ESESTATUS status = ESESTATUS_SUCCESS;
    int ret = -1;
    uint8_t frame_len = 0;
    uint8_t *p_frame_buff = gp_data_tx;

    if (RNACK_INVALID_ERROR == g_ese_ctx.p_T1_params->tx_sub_Rframe_type)
    {
        LOG_INFO(TRACE_MODULE_SE, "%s : invalid R-block frame type: %d\r\n", __FUNCTION__, g_ese_ctx.p_T1_params->tx_sub_Sframe_type);
        return ESESTATUS_INVALID_PARAMETER;
    }
    else
    {
        frame_len = get_header_len(true);
    }

    // memset(gp_data_tx, 0, sizeof(gp_data_tx));
    // pFramebuff = gp_data_tx;

    if (RNACK_PARITY_ERROR == g_ese_ctx.p_T1_params->tx_sub_Rframe_type)
    {
        p_frame_buff[1] = 0x81;
    }
    else if (RNACK_OTHER_ERROR == g_ese_ctx.p_T1_params->tx_sub_Rframe_type)
    {
        p_frame_buff[1] = 0x82;
    }
    else
    { // if (RACK == g_ese_ctx.p_T1_params->subRFrameType) {
        p_frame_buff[1] = 0x80;
    }

    p_frame_buff[1] |= (g_ese_ctx.seq_num_card << 4);

    p_frame_buff[T1_NAD_OFFSET] = NAD_D2C;
    // caculate LRC or CRC and set it to pFramebuff
    t1_set_epilogue(p_frame_buff, 0, frame_len);

    ret = phdriver_write(p_frame_buff, frame_len);
    if (-1 == ret)
    {
        status = ESESTATUS_PH_IO;

        LOG_INFO(TRACE_MODULE_SE, "write fail: %s, errno = %d, ret = %d\r\n", __FUNCTION__, errno, ret);
    }
    else
    {
        // LOG_INFO(TRACE_MODULE_SE, "\nTx", 2, pFramebuff, frameLen);
        // LOG_INFO(TRACE_MODULE_SE, "\n");
    }

    if (NULL == p_frame_buff)
    {
        LOG_INFO(TRACE_MODULE_SE, "%s failed, frame buffer malloc memory failed\r\n", __FUNCTION__);
        status = ESESTATUS_MEM_EXCEPTION;
    }

    return status;
}

/******************************************************************************
 * @Function     t1_calculate_LRC
 * @Param        p_data - data to compute the LRC over.
 *               offset - calculate start offset.
 *               len    - data length, not include the epilogue byte.
 * @Returns      On success return the LRC of the data.
 ******************************************************************************/
static uint8_t t1_calculate_LRC(uint8_t *p_data, uint16_t offset, uint16_t len)
{
    uint8_t LRC = 0;
    uint16_t i = 0;
    for (i = offset; i < len; i++)
    {
        LRC = LRC ^ p_data[i];
    }
    return LRC;
}

/******************************************************************************
 * @Function     t1_calculate_CRC
 * @Param        p_data - data to compute the CRC over.
 *               offset - calculate start offset.
 *               len    - data length, not include the epilogue bytes..
 * @Returns      On success return the CRC of the data.
 ******************************************************************************/
static uint16_t t1_calculate_CRC(uint8_t *p_data, uint16_t offset, uint16_t len)
{
    uint16_t crc;

    crc = (uint16_t)CRC_PRESET;

    int i, j;
    for (i = offset; i < len; i++)
    {
        crc = crc ^ ((unsigned short)p_data[i]);
        for (j = 0; j < 8; j++)
        {
            if ((crc & 0x0001) == 0x0001)
            {
                crc = (crc >> 1) ^ CRC_POLYNOMIAL;
            }
            else
            {
                crc = crc >> 1;
            }
        }
    }
    crc = ~crc;

    return crc;
}

/******************************************************************************
 * @Function     t1_set_epilogue
 * @Param        p_data - data to compute the LRC or CRC over.
 *               offset - calculate start offset.
 *               len    - data length, include the epilogue byte(s).
 ******************************************************************************/
static void t1_set_epilogue(uint8_t *p_data, uint16_t offset, uint16_t len)
{
    if ((LRC == g_atr.checksum) ||
        (CIP_REQ == g_ese_ctx.p_T1_params->tx_sub_Sframe_type)
        /*|| (ATR_REQ == g_ese_ctx.p_T1_params->tx_sub_Sframe_type)*/
        || (CIP_RSP == g_ese_ctx.p_T1_params->tx_sub_Sframe_type)
        /*|| (ATR_RSP == g_ese_ctx.p_T1_params->tx_sub_Sframe_type)*/)
    {
        // LRC
        p_data[len - 1] = t1_calculate_LRC(p_data, offset, len - 1);
    }
    else
    {
        const uint16_t CRC = t1_calculate_CRC(p_data, offset, len - 2);

        p_data[len - 2] = (uint8_t)(CRC >> 8);
        p_data[len - 1] = (uint8_t)CRC;
    }
}

/******************************************************************************
 * @Function     t1_chk_epilogue
 * @Param        p_data  - data to compute the LRC or CRC over.
 *               offset - calculate start offset.
 *               len    - data length, include the epilogue byte(s).
 * @Returns      ESESTATUS_SUCCESS if caculate result is equal to response's epilogue,
 *               else ESESTATUS_PARITY_ERROR.
 ******************************************************************************/
ESESTATUS t1_chk_epilogue(uint8_t *p_data, uint16_t offset, uint16_t len)
{
    ESESTATUS status = ESESTATUS_PARITY_ERROR;

    /* Note:T1 CIP_REQ for ATR, the frame's INFO length should be 1 byte,
     *      do not support 2 bytes length.
     *      And epiLogue field should use LRC (1 byte).
     */
    if ((LRC == g_atr.checksum) ||
        (CIP_REQ == g_ese_ctx.p_T1_params->tx_sub_Sframe_type)
        /*|| (ATR_REQ == g_ese_ctx.p_T1_params->tx_sub_Sframe_type)*/
        || (CIP_RSP == g_ese_ctx.p_T1_params->tx_sub_Sframe_type)
        /*|| (ATR_RSP == g_ese_ctx.p_T1_params->tx_sub_Sframe_type)*/)
    {
        // LRC
        const uint8_t LRC = t1_calculate_LRC(p_data, offset, len - 1);
        if (LRC == p_data[len - 1])
        {
            status = ESESTATUS_SUCCESS;
        }
    }
    else
    {
        uint16_t rspCRC = (uint16_t)(((uint16_t)p_data[len - 2]) << 8);
        rspCRC |= p_data[len - 1];
        const uint16_t CRC = t1_calculate_CRC(p_data, offset, len - 2);
        if (CRC == rspCRC)
        {
            status = ESESTATUS_SUCCESS;
        }
    }

    return status;
}

/******************************************************************************
 * @Function     t1_read
 * @Param        p_data_len - point to data length.
 * @Returns      On success return ESESTATUS_SUCCESS, else ESESTATUS_xxx.
 ******************************************************************************/
static ESESTATUS t1_read(uint16_t *p_data_len)
{
    ESESTATUS status = ESESTATUS_SUCCESS;
    int ret = -1;
    const uint32_t sof_max_cnt = g_ese_ctx.max_read_retry_cnt;
    uint32_t sof_cnt = 0;
    uint16_t total_cnt = 0, num_Bytes_to_read = 0, read_index = 0;

#ifdef USE_SPI_SPLIT_READ
    const uint8_t hdrLen = get_header_len(false) + 1;
#else
    const uint8_t hdrLen = g_ese_ctx.max_IFSD;
#endif

#ifdef DBG_LEVEL_STACK
    if (gDumpStackFlag)
    {
        dumpCallstack();
    }
    gDumpStackFlag = true;
#endif

    // memset(gp_data_rx, 0x00, sizeof(gp_data_rx));
    do
    {
        sys_timer_delay_ms(1); // 10

        ret = phdriver_read(gp_data_rx, 1);

        if ((ret < 0) || (NAD_C2DT != gp_data_rx[0]))
        {
            sof_cnt++;
            continue;
        }
        else
        {
            phdriver_read(gp_data_rx + 1, (hdrLen - 1));

            if (g_ese_ctx.is_T1_ext_hdr_len)
            {
                num_Bytes_to_read = (uint16_t)(((uint16_t)gp_data_rx[T1_FRAME_LEN_OFFSET]) << 8);
                num_Bytes_to_read |= gp_data_rx[T1_FRAME_LEN_OFFSET2];

                if (CRC == g_atr.checksum)
                {
                    num_Bytes_to_read += 1;
                }
            }
            else
            {
                num_Bytes_to_read = gp_data_rx[T1_FRAME_LEN_OFFSET];
            }
            read_index = hdrLen;
            total_cnt += hdrLen;
            // LOG_INFO(TRACE_MODULE_SE, "_spi_read() [HDR] read data right!! \r\n");
            break;
        }
    } while (sof_cnt < sof_max_cnt);

    /*SOF Read timeout happened, go for frame retransmission*/
    if (sof_cnt == sof_max_cnt)
    {
        if (ret >= 0)
        {
            ret = -1;
            status = ESESTATUS_PH_IOR_INVALID_DATA;
        }
        else
        {
            status = ESESTATUS_PH_IO;
        }
        // LOG_INFO(TRACE_MODULE_SE, "_spi_read() [HDR] execption, ret = %d, sofCnt = %X\r\n", ret, sofCnt);
    }

#ifdef USE_SPI_SPLIT_READ
    if (ret < 0)
    {
        if ((-1 == ret) && (4 == errno))
        {
            // Interrupted system call, is NFC_DLD_FLUSH
            status = ESESTATUS_FATAL_ERROR;
        }
    }
    else
    {
        if (0 != num_Bytes_to_read)
        {
            ret = phdriver_read(&gp_data_rx[read_index], num_Bytes_to_read);
            if (ret < 0)
            {
                status = ESESTATUS_PH_IO;
                LOG_INFO(TRACE_MODULE_SE, "%s _spi_read() [payload] execption, ret = %x, errno = %d\r\n", __FUNCTION__, ret, errno);
            }
            else
            {
                // LOG_INFO(TRACE_MODULE_SE, " _spi_read() [payload] right!!!!!!!!!!!!!!\r\n");
                total_cnt += num_Bytes_to_read;
            }
        }
    }
#endif

    if (ESESTATUS_SUCCESS != status)
    {
        *p_data_len = 0;
        // LOG_INFO(TRACE_MODULE_SE, "RxFail\r\n");
        // LOG_INFO(TRACE_MODULE_SE, "read fail: %s, errno = %d, ret = %d\r\n", __FUNCTION__, errno, ret);
    }
    else
    {
        *p_data_len = total_cnt;

        // LOG_INFO(TRACE_MODULE_SE, "Rx\r\n");
    }
    return status;
}

/******************************************************************************
 * @Function     t1_decode_frame
 * @Param        data_len - data length.
 * @Returns      On success return ESESTATUS_SUCCESS, else ESESTATUS_xxx.
 ******************************************************************************/
ESESTATUS t1_decode_frame(uint16_t data_len)
{
    ESESTATUS status = ESESTATUS_SUCCESS;
    uint8_t pcb = gp_data_rx[T1_PCB_OFFSET];
    T1_pcb_bits *p_pcb_bits;

    if (g_ese_ctx.p_T1_params)
    {
        p_pcb_bits = &g_ese_ctx.p_T1_params->last_rx_pcb_bits;
    }
    else
    {
        LOG_INFO(TRACE_MODULE_SE, "p_T1_params is NULL\r\n");
        return ESESTATUS_INVALID_PCB;
    }

    // memset(p_pcb_bits, 0x00, sizeof(T1_pcb_bits));
    memcpy(p_pcb_bits, &pcb, sizeof(uint8_t));
    uint16_t infoLen = get_info_len(gp_data_rx);
    uint8_t dataOffset = get_header_len(false);

    if (0x00 == p_pcb_bits->msb)
    {
        // I-FRAME decoded
        g_ese_ctx.p_T1_params->last_rx_frame_type = IFRAME;
        g_ese_ctx.p_T1_params->last_rx_sub_Sframe_type = SFRAME_TYPE_INVALID;
        g_ese_ctx.p_T1_params->last_rx_sub_Rframe_type = RNACK_INVALID_ERROR;

        g_ese_ctx.p_T1_params->wtx_cnt = 0;

        if (g_ese_ctx.is_seq_num_dr && (p_pcb_bits->bit7 != g_ese_ctx.seq_num_card))
        {
            g_ese_ctx.seq_num_card ^= 0x01;
        }
        g_ese_ctx.is_seq_num_dr = false;

        if (p_pcb_bits->bit7 == g_ese_ctx.seq_num_card)
        {
            g_ese_ctx.p_T1_params->recovery_cnt = 0;
            g_ese_ctx.p_T1_params->resync_CIP_req_cnt = 0;
            g_ese_ctx.is_resync_recovery_flag = false;

            if (p_pcb_bits->bit6)
            {
                g_ese_ctx.p_T1_params->is_card_chaining = true;
                g_ese_ctx.seq_num_card = (g_ese_ctx.seq_num_card ^ 0x01);

                status = t1_recv_data_store_in_list(&gp_data_rx[dataOffset], infoLen, data_len);

                if (ESESTATUS_SUCCESS != status)
                {
                    LOG_INFO(TRACE_MODULE_SE, "%s, t1_recv_data_store_in_list failed, terminate transmission, status = %d\r\n", __FUNCTION__, status);
                    g_ese_ctx.next_T1_state = STATE_IDEL;
                    free_tx_part_mem();
                }
                else
                {
                    // Card response chaining and successfully, then request the next segments data.
                    g_ese_ctx.next_T1_state = R_ACK;
                    g_ese_ctx.p_T1_params->tx_frame_type = RFRAME;
                    g_ese_ctx.p_T1_params->tx_sub_Rframe_type = RACK;
                }
            }
            else
            {
                g_ese_ctx.p_T1_params->is_card_chaining = false;
                status = t1_recv_data_store_in_list(&gp_data_rx[dataOffset], infoLen, data_len);
                if (ESESTATUS_SUCCESS != status)
                {
                    LOG_INFO(TRACE_MODULE_SE, "%s, t1_recv_data_store_in_list failed, terminate transmission, status = %d\r\n", __FUNCTION__, status);
                }
                else
                {
                    // Not chaining, and response success.
                }

                g_ese_ctx.seq_num_device = (g_ese_ctx.seq_num_device ^ 0x01);
                g_ese_ctx.seq_num_card = (g_ese_ctx.seq_num_card ^ 0x01);
                g_ese_ctx.next_T1_state = STATE_IDEL;
                free_tx_part_mem();
            }
        }
        else
        {
            LOG_INFO(TRACE_MODULE_SE, "%s, received invalid seqNum = %02X, seq_num_card = %02X\r\n", __FUNCTION__, p_pcb_bits->bit7, g_ese_ctx.seq_num_card);
            status = do_T1_recovery_at_decode_Iframe();
        }
    }
    else if ((0x01 == p_pcb_bits->msb) && (0x00 == p_pcb_bits->bit7))
    {
        // R-FRAME decoded
        g_ese_ctx.p_T1_params->last_rx_frame_type = RFRAME;
        g_ese_ctx.p_T1_params->last_rx_sub_Sframe_type = SFRAME_TYPE_INVALID;

        if ((0x00 == p_pcb_bits->lsb) && (0x00 == p_pcb_bits->bit2))
        {
            g_ese_ctx.p_T1_params->last_rx_sub_Rframe_type = RACK;
            if ((NULL != g_ese_ctx.p_T1_params->p_data_tx) && g_ese_ctx.p_T1_params->is_device_chaining)
            {
                if (g_ese_ctx.seq_num_device != p_pcb_bits->bit5)
                {
                    // Device chaining, valid card request the next segments of device data to send.
                    // seq_num_device should changed, but the seq_num_card unchanged until received card I-block.
                    g_ese_ctx.seq_num_device = p_pcb_bits->bit5;
                    g_ese_ctx.next_T1_state = I_BLK;
                    g_ese_ctx.p_T1_params->tx_frame_type = IFRAME;
                    g_ese_ctx.p_T1_params->tx_sub_Rframe_type = RNACK_INVALID_ERROR;
                    free_tx_part_mem();
                }
                else
                {
                    status = do_T1_recovery_at_decode_Rframe();
                }
            }
            else if (NULL != g_ese_ctx.p_T1_params->p_data_tx)
            {
                status = ESESTATUS_INVALID_PARAMETER;
                LOG_INFO(TRACE_MODULE_SE, "%s: Device initiates unchaining I-block cannot receive RACK, terminate transmit.\r\n", __FUNCTION__);
                // terminate transmit
                g_ese_ctx.next_T1_state = STATE_IDEL;
            }
            else
            {
                g_ese_ctx.next_T1_state = STATE_IDEL;
            }
        }
        else
        {
            g_ese_ctx.p_T1_params->last_rx_sub_Sframe_type = SFRAME_TYPE_INVALID;
            if ((0x01 == p_pcb_bits->lsb) && (0x00 == p_pcb_bits->bit2))
            {
                g_ese_ctx.p_T1_params->last_rx_sub_Rframe_type = RNACK_PARITY_ERROR;
                status = ESESTATUS_PARITY_ERROR;
            }
            else if ((0x00 == p_pcb_bits->lsb) && (0x01 == p_pcb_bits->bit2))
            {
                // Other error
                g_ese_ctx.p_T1_params->last_rx_sub_Rframe_type = RNACK_OTHER_ERROR;
                status = ESESTATUS_UNKNOWN_ERROR;
            }
            else
            {
                g_ese_ctx.p_T1_params->last_rx_sub_Rframe_type = RNACK_INVALID_ERROR;
                status = ESESTATUS_UNKNOWN_ERROR;
            }

            // LOG_INFO(TRACE_MODULE_SE, "%s: PCB = 0x%02X, recovery_cnt = %d, max_recovery_cnt = %d\r\n", __FUNCTION__, pcb,
            // g_ese_ctx.p_T1_params->recovery_cnt,
            // g_ese_ctx.max_recovery_cnt);
            do_T1_recovery_at_decode_Rframe();
        }
    }
    else if ((0x01 == p_pcb_bits->msb) && (0x01 == p_pcb_bits->bit7))
    {
        g_ese_ctx.p_T1_params->last_rx_frame_type = SFRAME;
        g_ese_ctx.p_T1_params->last_rx_sub_Rframe_type = RNACK_INVALID_ERROR;

        LOG_INFO(TRACE_MODULE_SE, "%s S-Frame Received\r\n", __FUNCTION__);
        uint8_t subFrameType = pcb & T1_S_BLOCK_SUB_TYPE_MASK;
        if (RESYNC_RSP != subFrameType)
        {
            g_ese_ctx.is_resync_recovery_flag = false;
        }

        switch (subFrameType)
        {
            case RESYNC_RSP:
            {
                g_ese_ctx.p_T1_params->last_rx_sub_Sframe_type = RESYNC_RSP;
                status = do_T1_recovery_at_decode_Sframe();
                break;
            }

            case IFS_REQ:
            {
                uint16_t IFSC = 0;
                if (2 == infoLen)
                {
                    IFSC = (uint16_t)(((uint16_t)gp_data_rx[dataOffset]) << 8);
                    IFSC |= gp_data_rx[dataOffset + 1];
                    LOG_INFO(TRACE_MODULE_SE, "%s IFS_RSP Received, IFSD = %04X\r\n", __FUNCTION__, IFSC);
                }
                else if (1 == infoLen)
                {
                    IFSC = (uint16_t)gp_data_rx[dataOffset];
                    LOG_INFO(TRACE_MODULE_SE, "%s IFS_RSP Received, IFSD = %02X\r\n", __FUNCTION__, IFSC);
                }
                else
                {
                    LOG_INFO(TRACE_MODULE_SE, "%s Invalid IFS_RSP Received\r\n", __FUNCTION__);
                }
                g_ese_ctx.max_IFSC = IFSC;
                g_ese_ctx.next_T1_state = S_IFS_RSP;
                g_ese_ctx.p_T1_params->tx_frame_type = SFRAME;
                g_ese_ctx.p_T1_params->tx_sub_Sframe_type = IFS_RSP;
                break;
            }

            case IFS_RSP:
            {
                g_ese_ctx.p_T1_params->last_rx_sub_Sframe_type = IFS_RSP;
                uint16_t IFSD = 0;
                uint8_t offset = get_header_len(false);
                if (2 == infoLen)
                {
                    IFSD = (uint16_t)(((uint16_t)gp_data_rx[offset]) << 8);
                    IFSD |= gp_data_rx[offset + 1];
                    LOG_INFO(TRACE_MODULE_SE, "%s IFS_RSP Received, IFSD = %04X\r\n", __FUNCTION__, IFSD);
                }
                else if (1 == infoLen)
                {
                    IFSD = (uint16_t)gp_data_rx[offset];
                    LOG_INFO(TRACE_MODULE_SE, "%s IFS_RSP Received, IFSD = %02X\r\n", __FUNCTION__, IFSD);
                }
                else
                {
                    LOG_INFO(TRACE_MODULE_SE, "%s Invalid IFS_RSP Received\r\n", __FUNCTION__);
                }
                if (g_ese_ctx.max_IFSD != IFSD)
                {
                    LOG_INFO(TRACE_MODULE_SE, "%s : invalid IFS receive paylod, receivedIFSD = %X, sentIFSD = %X\r\n", __FUNCTION__, IFSD, g_ese_ctx.max_IFSD);
                }
                status = do_T1_recovery_at_decode_Sframe();
                break;
            }

            case ABORT_REQ:
            case ABORT_RSP:
            {
                // Rule 9: only chaining cmd or rsp will send (receive) ABORT_REQ
                if (g_ese_ctx.p_T1_params->is_card_chaining || g_ese_ctx.p_T1_params->is_device_chaining)
                {
                    t1_recv_data_list_destroy();
                }

                g_ese_ctx.next_T1_state = STATE_IDEL;
                break;
            }

            case WTX_REQ:
            {
                if (g_ese_ctx.p_T1_params->wtx_cnt <= g_ese_ctx.max_wtx_cnt)
                {
                    g_ese_ctx.p_T1_params->wtx_cnt++;

                    g_ese_ctx.p_T1_params->wtx_info = gp_data_rx[get_header_len(false)];
                    g_ese_ctx.next_T1_state = S_WTX_RSP;
                    g_ese_ctx.p_T1_params->tx_frame_type = SFRAME;
                    g_ese_ctx.p_T1_params->tx_sub_Sframe_type = WTX_RSP;
                }
                else
                {
                    LOG_INFO(TRACE_MODULE_SE, "%s : failed, WTX_REQ counter larger than maxWtxCnt\r\n", __FUNCTION__);
                    status = ESESTATUS_FAILED;
                    g_ese_ctx.next_T1_state = STATE_IDEL;
                }
                break;
            }

            case CIP_RSP:
            {
                status = decode_ATR(gp_data_rx, true);
                reset_for_resync_rsp();
                g_ese_ctx.next_T1_state = STATE_IDEL;
                break;
            }

            case PROP_END_APDU_RSP:
            {
                status = ESESTATUS_SUCCESS;
                g_ese_ctx.next_T1_state = STATE_IDEL;
                break;
            }

            case HARD_RESET_RSP:
            {
                status = ESESTATUS_SUCCESS;
                g_ese_ctx.next_T1_state = STATE_IDEL;
                break;
            }

            case ATR_RSP:
            {
                status = decode_ATR(gp_data_rx, false);
                g_ese_ctx.next_T1_state = STATE_IDEL;
                break;
            }

            default:
            {
                status = ESESTATUS_SUCCESS;
                g_ese_ctx.next_T1_state = STATE_IDEL;
                LOG_INFO(TRACE_MODULE_SE, "%s : invalid S-block frame type: %X\r\n", __FUNCTION__, subFrameType);
            }
        }
    }
    else
    {
        // LOG_ERROR(TRACE_MODULE_SE, "[RX]Nothing\r\n");
        LOG_INFO(TRACE_MODULE_SE, "%s Wrong-Frame Received, PCB = %X\r\n", __FUNCTION__, pcb);
        status = ESESTATUS_INVALID_PCB;
    }

    return status;
}

/** Contains the Prologue and (or not) Epilogue field length **/
uint8_t get_header_len(bool contains_epilogue)
{
    uint8_t len = 0;
    bool is_T1_ext_hdr_len = g_ese_ctx.is_T1_ext_hdr_len;
    uint8_t checksum = g_atr.checksum;
    if ((SFRAME == g_ese_ctx.p_T1_params->tx_frame_type) && ((CIP_REQ == g_ese_ctx.p_T1_params->tx_sub_Sframe_type)
                                                             /*|| (ATR_REQ == g_ese_ctx.p_T1_params->tx_sub_Sframe_type)*/))
    {
        is_T1_ext_hdr_len = false;
        checksum = 0;
    }

    len = (is_T1_ext_hdr_len ? T1_EXT_HEADER_LEN : T1_HEADER_LEN);
    if (contains_epilogue)
    {
        len += ((checksum == 0) ? T1_LRC_LEN : T1_CRC_LEN);
    }

    return len;
}

static uint8_t set_info_len(uint8_t *p_data, uint16_t info_len)
{
    uint8_t len_offset = 0;
    bool is_T1_ext_hdr_len = g_ese_ctx.is_T1_ext_hdr_len;
    if ((SFRAME == g_ese_ctx.p_T1_params->tx_frame_type) && ((CIP_REQ == g_ese_ctx.p_T1_params->tx_sub_Sframe_type)
                                                             /*|| (ATR_REQ == g_ese_ctx.p_T1_params->tx_sub_Sframe_type)*/))
    {
        is_T1_ext_hdr_len = false;
    }

    if (is_T1_ext_hdr_len)
    {
        p_data[T1_FRAME_LEN_OFFSET] = (uint8_t)(info_len >> 8);
        p_data[T1_FRAME_LEN_OFFSET2] = (uint8_t)(info_len & 0xFF);
        len_offset = T1_FRAME_LEN_OFFSET2;
    }
    else
    {
        p_data[T1_FRAME_LEN_OFFSET] = (uint8_t)(info_len & 0xFF);
        len_offset = T1_FRAME_LEN_OFFSET;
    }
    return len_offset;
}

static uint16_t get_info_len(uint8_t *p_data)
{
    uint16_t info_len = 0;
    bool is_T1_ext_hdr_len = g_ese_ctx.is_T1_ext_hdr_len;
    if ((SFRAME == g_ese_ctx.p_T1_params->tx_frame_type) && ((CIP_REQ == g_ese_ctx.p_T1_params->tx_sub_Sframe_type)
                                                             /*|| (ATR_REQ == g_ese_ctx.p_T1_params->tx_sub_Sframe_type)*/))
    {
        is_T1_ext_hdr_len = false;
    }

    if (is_T1_ext_hdr_len)
    {
        info_len = (uint16_t)(((uint16_t)p_data[T1_FRAME_LEN_OFFSET]) << 8);
        info_len |= p_data[T1_FRAME_LEN_OFFSET2];
    }
    else
    {
        info_len = p_data[T1_FRAME_LEN_OFFSET];
    }
    return info_len;
}

/******************************************************************************
 * @Function     decode_ATR
 * @Param        p_data  - received data and its must be PCB = 0xE4 or 0xE7.
 *               is_CIP  - true if received data's PCB = 0xE4.
 * @Return       ESESTATUS_SUCCESS if decode ATR success, else ESESTATUS_INVALID_T1_LEN.
 ******************************************************************************/
static ESESTATUS decode_ATR(uint8_t *p_data, bool is_CIP)
{
    ESESTATUS status = ESESTATUS_SUCCESS;
    uint16_t info_len = get_info_len(p_data);
    uint8_t *p_start = &p_data[T1_FRAME_LEN_OFFSET];
    if (!is_CIP && g_ese_ctx.is_T1_ext_hdr_len)
    {
        // Currently, ATR length is 0x13, exttended frame length high byte should be 0x00
        p_start++;
    }

    if (sizeof(atr_info) == (info_len + 1))
    {
        memcpy(&g_atr.len, p_start, sizeof(atr_info));
    }
    else if (0 == p_data[T1_FRAME_LEN_OFFSET])
    {
        // Do nothing, keep befor ATR value.
        reset_ATR();
    }
    else
    {
        LOG_INFO(TRACE_MODULE_SE, "%s : invalid ATR response AtrInfoLen = %02X\r\n", __FUNCTION__, (uint8_t)sizeof(atr_info));

        status = ESESTATUS_INVALID_T1_LEN;
    }

    if (ESESTATUS_SUCCESS == status)
    {
        g_ese_ctx.max_IFSC = (uint16_t)(((uint16_t)g_atr.max_IFSC[0]) << 8);
        g_ese_ctx.max_IFSC |= g_atr.max_IFSC[1];
        g_ese_ctx.is_T1_ext_hdr_len = (g_atr.capbilities[1] & 0x08) != 0;
    }

    return status;
}

/******************************************************************************
 * @Function     init_Iframe_from_cmd_apdu
 * @Param        p_cmd_apdu - 7816-4 APDU that shall be sent.
 *               cmd_len - Length of the apduCmd to be sent.
 * @Returns      On success return ESESTATUS_SUCCESS or else ESESTATUS error.
 ******************************************************************************/
ESESTATUS init_Iframe_from_cmd_apdu(uint8_t *p_cmd_apdu, uint16_t cmd_len)
{
    ESESTATUS status = ESESTATUS_SUCCESS;

    g_ese_ctx.p_T1_params = &g_T1_params;
    g_ese_ctx.p_T1_params->is_device_chaining = (cmd_len > g_ese_ctx.max_IFSC ? true : false);
    g_ese_ctx.next_T1_state = I_BLK;
    g_ese_ctx.p_T1_params->tx_frame_type = IFRAME;
    g_ese_ctx.p_T1_params->p_data_tx = p_cmd_apdu;
    g_ese_ctx.p_T1_params->tx_len = cmd_len;

    g_ese_ctx.p_T1_params->tx_data_offset = 0;
    g_ese_ctx.p_T1_params->tx_len_part = 0;
    g_ese_ctx.p_T1_params->p_data_tx_part = NULL;

    g_ese_ctx.p_T1_params->resync_CIP_req_cnt = 0;

    return status;
}

/******************************************************************************
 * @Function     deinit_Iframe_from_cmd_apdu
 * @Returns      On success return ESESTATUS_SUCCESS or else ESESTATUS error.
 ******************************************************************************/
void deinit_Iframe_from_cmd_apdu(void)
{
    if (NULL != g_ese_ctx.p_T1_params)
    {
        g_ese_ctx.p_T1_params->p_data_tx = NULL;

        if (NULL != g_ese_ctx.p_T1_params->p_data_tx_part)
        {
            g_ese_ctx.p_T1_params->p_data_tx_part = NULL;
        }

        g_ese_ctx.p_T1_params = NULL;
    }
}

/******************************************************************************
 * @Function     free_tx_part_mem
 ******************************************************************************/
static void free_tx_part_mem(void)
{
    if (NULL != g_ese_ctx.p_T1_params)
    {
        if (NULL != g_ese_ctx.p_T1_params->p_data_tx_part)
        {
            g_ese_ctx.p_T1_params->p_data_tx_part = NULL;
        }
    }
}

/******************************************************************************
 * @Function     reset_for_resync_rsp
 ******************************************************************************/
static void reset_for_resync_rsp(void)
{
    g_ese_ctx.seq_num_card = 0;
    g_ese_ctx.seq_num_device = 0;
    g_ese_ctx.p_T1_params->recovery_cnt = 0;
    g_ese_ctx.p_T1_params->resync_CIP_req_cnt = 0;
    g_ese_ctx.p_T1_params->wtx_cnt = 0;
    g_ese_ctx.p_T1_params->tx_data_offset = 0;
    if (g_ese_ctx.p_T1_params->is_card_chaining)
    {
        t1_recv_data_list_destroy();
    }
    g_ese_ctx.p_T1_params->is_device_chaining = false;
    g_ese_ctx.p_T1_params->is_card_chaining = false;
}

/******************************************************************************
 * @Function     do_T1_recovery_at_undecode
 * @Returns      On success return ESESTATUS_SUCCESS, else ESESTATUS_FATAL_ERROR.
 ******************************************************************************/
ESESTATUS do_T1_recovery_at_undecode(void)
{
    ESESTATUS status = ESESTATUS_SUCCESS;
    if (g_ese_ctx.p_T1_params->recovery_cnt < g_ese_ctx.max_recovery_cnt)
    {
        g_ese_ctx.p_T1_params->recovery_cnt++;

        if ((SFRAME != g_ese_ctx.p_T1_params->tx_frame_type) || (WTX_RSP == g_ese_ctx.p_T1_params->tx_sub_Sframe_type))
        {
            g_ese_ctx.next_T1_state = R_PARITY_ERR;
            g_ese_ctx.p_T1_params->tx_frame_type = RFRAME;
            g_ese_ctx.p_T1_params->tx_sub_Rframe_type = RNACK_PARITY_ERROR;
            // Should use the N(S), that is g_ese_ctx.seq_num_device
        }
    }
    else
    {
        if (((SFRAME != g_ese_ctx.p_T1_params->tx_frame_type) || (WTX_RSP == g_ese_ctx.p_T1_params->tx_sub_Sframe_type)) && !g_ese_ctx.is_resync_recovery_flag)
        {
            g_ese_ctx.is_resync_recovery_flag = true;

            // Do case 4
            g_ese_ctx.next_T1_state = S_RESYNC_REQ;
            g_ese_ctx.p_T1_params->tx_frame_type = SFRAME;
            g_ese_ctx.p_T1_params->tx_sub_Sframe_type = RESYNC_REQ;
        }
        else if (g_ese_ctx.is_resync_recovery_flag)
        {
            if (g_ese_ctx.p_T1_params->resync_CIP_req_cnt < g_ese_ctx.max_recovery_cnt)
            {
                g_ese_ctx.p_T1_params->resync_CIP_req_cnt++;

                // Do case 5
                g_ese_ctx.next_T1_state = S_CIP_REQ;
                g_ese_ctx.p_T1_params->tx_frame_type = SFRAME;
                g_ese_ctx.p_T1_params->tx_sub_Sframe_type = CIP_REQ;
            }
            else
            {
                status = ESESTATUS_FATAL_ERROR;
                g_ese_ctx.next_T1_state = STATE_IDEL;
            }
        }
        else
        {
            // Chip hard reset if warm reset failed.
            if ((SFRAME == g_ese_ctx.p_T1_params->tx_frame_type) && (CIP_REQ == g_ese_ctx.p_T1_params->tx_sub_Sframe_type))
            {
                LOG_INFO(TRACE_MODULE_SE, "%s: warm reset failed, TODO need chip hard reset to recover\r\n", __FUNCTION__);
                // need to chip hard reset
                status = ESESTATUS_FATAL_ERROR;
                g_ese_ctx.next_T1_state = STATE_IDEL;
            }
            else
            {
                LOG_INFO(TRACE_MODULE_SE, "%s: S(... REQ) failed, warm reset to recover lastTxFrameType = %d, lastTxSFrameType = %d\r\n", __FUNCTION__,
                         g_ese_ctx.p_T1_params->tx_frame_type, g_ese_ctx.p_T1_params->tx_sub_Sframe_type);

                g_ese_ctx.next_T1_state = S_CIP_REQ;
                g_ese_ctx.p_T1_params->tx_frame_type = SFRAME;
                g_ese_ctx.p_T1_params->tx_sub_Sframe_type = CIP_REQ;
            }
        }
    }

    return status;
}

/******************************************************************************
 * @Function     do_T1_recovery_at_decode_Iframe
 * @Returns      On success return ESESTATUS_SUCCESS, else ESESTATUS_FATAL_ERROR.
 ******************************************************************************/
static ESESTATUS do_T1_recovery_at_decode_Iframe(void)
{
    ESESTATUS status = ESESTATUS_SUCCESS;
    T1_frame_types last_rx_frame_type = g_ese_ctx.p_T1_params->last_rx_frame_type;
    T1_pcb_bits *p_pcb_bits = &g_ese_ctx.p_T1_params->last_rx_pcb_bits;

    if (IFRAME == last_rx_frame_type)
    {
        if (g_ese_ctx.p_T1_params->recovery_cnt < g_ese_ctx.max_recovery_cnt)
        {
            g_ese_ctx.p_T1_params->recovery_cnt++;
            if (p_pcb_bits->bit7 != g_ese_ctx.seq_num_card)
            {
                g_ese_ctx.next_T1_state = R_OTHER_ERR;
                g_ese_ctx.p_T1_params->tx_frame_type = RFRAME;
                g_ese_ctx.p_T1_params->tx_sub_Rframe_type = RNACK_OTHER_ERROR;
            }
            else
            {
                // Cannot be occured this case
                LOG_INFO(TRACE_MODULE_SE,
                         "%s: an I-block received, seqNum exception, terminate transmission. lastTxSeqNum = %d, lastRxExpectedNum = %d, lastRxSeqNum = %d\r\n",
                         __FUNCTION__, g_ese_ctx.seq_num_device, g_ese_ctx.seq_num_card, p_pcb_bits->bit7);
                g_ese_ctx.next_T1_state = STATE_IDEL;
                g_ese_ctx.is_resync_recovery_flag = false;
                status = ESESTATUS_INVALID_PARAMETER;
                free_tx_part_mem();
            }
        }
        else
        {
            // Should transmit RESYNC_REQ to recover.
            LOG_INFO(TRACE_MODULE_SE, "%s: lastRecvFrameType = %d, recovery_cnt = %d, max_recovery_cnt = %d RESYNC_REQ should be sent to recover\r\n",
                     __FUNCTION__, last_rx_frame_type, g_ese_ctx.p_T1_params->recovery_cnt, g_ese_ctx.max_recovery_cnt);
            // RESYNC_REQ only send once, recovery_cnt should not be reset to zero.
            g_ese_ctx.is_resync_recovery_flag = true;

            g_ese_ctx.next_T1_state = S_RESYNC_REQ;
            g_ese_ctx.p_T1_params->tx_frame_type = SFRAME;
            g_ese_ctx.p_T1_params->tx_sub_Sframe_type = RESYNC_REQ;
        }
    }
    else
    {
        status = ESESTATUS_INVALID_PARAMETER;
        LOG_INFO(TRACE_MODULE_SE,
                 "%s: should be called when received an invalid IFrame, but non-IFrame received, lastRecvFrameType = %d, recovery_cnt = %d, max_recovery_cnt = "
                 "%d\r\n",
                 __FUNCTION__, last_rx_frame_type, g_ese_ctx.p_T1_params->recovery_cnt, g_ese_ctx.max_recovery_cnt);
        g_ese_ctx.next_T1_state = STATE_IDEL;
        free_tx_part_mem();
    }

    return status;
}

/******************************************************************************
 * @Function     do_T1_recovery_at_decode_Sframe
 * @Returns      On success return ESESTATUS_SUCCESS, else ESESTATUS_FATAL_ERROR.
 ******************************************************************************/
static ESESTATUS do_T1_recovery_at_decode_Sframe(void)
{
    ESESTATUS status = ESESTATUS_SUCCESS;
    T1_frame_types last_rx_frame_type = g_ese_ctx.p_T1_params->last_rx_frame_type;
    Sframe_types last_rx_sub_Sframe_type = g_ese_ctx.p_T1_params->last_rx_sub_Sframe_type;

    if ((SFRAME == last_rx_frame_type) && (NULL != g_ese_ctx.p_T1_params->p_data_tx))
    {
        // recovery_cnt will be ignored for RESYNC_RSP and IFS_RSP
        if (RESYNC_RSP == last_rx_sub_Sframe_type)
        {
            reset_for_resync_rsp();
            g_ese_ctx.next_T1_state = I_BLK;
            g_ese_ctx.p_T1_params->tx_frame_type = IFRAME;
            g_ese_ctx.p_T1_params->tx_sub_Sframe_type = SFRAME_TYPE_INVALID;
            g_ese_ctx.p_T1_params->tx_sub_Rframe_type = RNACK_INVALID_ERROR;
        }
        else if (IFS_RSP == last_rx_sub_Sframe_type)
        {
            if (g_ese_ctx.p_T1_params->is_card_chaining)
            {
                g_ese_ctx.next_T1_state = R_ACK;
                g_ese_ctx.p_T1_params->tx_frame_type = RFRAME;
                g_ese_ctx.p_T1_params->tx_sub_Sframe_type = SFRAME_TYPE_INVALID;
                g_ese_ctx.p_T1_params->tx_sub_Rframe_type = RACK;
            }
            else if (g_ese_ctx.p_T1_params->is_device_chaining)
            {
                g_ese_ctx.next_T1_state = I_BLK;
                g_ese_ctx.p_T1_params->tx_frame_type = IFRAME;
                g_ese_ctx.p_T1_params->tx_sub_Sframe_type = SFRAME_TYPE_INVALID;
                g_ese_ctx.p_T1_params->tx_sub_Rframe_type = RNACK_INVALID_ERROR;
            }
            else
            {
                LOG_INFO(TRACE_MODULE_SE, "%s: device initiates block I-block is unchaining, terminate transmit when received IFS_RSP\r\n", __FUNCTION__);
                // terminate transmit
                g_ese_ctx.next_T1_state = STATE_IDEL;
            }
        }
        else
        {
            LOG_INFO(TRACE_MODULE_SE, "%s: device initiates block is an I-block, lastTxFrameType = %d, but device received R-block, cannot be occurred.\r\n",
                     __FUNCTION__, last_rx_sub_Sframe_type);
            // terminate transmit
            g_ese_ctx.next_T1_state = STATE_IDEL;
        }
    }
    else
    {
        status = ESESTATUS_INVALID_PARAMETER;
        LOG_INFO(TRACE_MODULE_SE,
                 "%s: should be called when received an SFrame, but non-SFrame received, lastRecvFrameType = %d, recovery_cnt = %d, max_recovery_cnt = %d\r\n",
                 __FUNCTION__, last_rx_frame_type, g_ese_ctx.p_T1_params->recovery_cnt, g_ese_ctx.max_recovery_cnt);

        g_ese_ctx.next_T1_state = STATE_IDEL;
    }
    return status;
}

/******************************************************************************
 * @Function     do_T1_recovery_at_decode_Rframe
 * @Returns      On success return ESESTATUS_SUCCESS, else ESESTATUS_FATAL_ERROR.
 ******************************************************************************/
static ESESTATUS do_T1_recovery_at_decode_Rframe(void)
{
    ESESTATUS status = ESESTATUS_SUCCESS;
    T1_frame_types last_rx_frame_type = g_ese_ctx.p_T1_params->last_rx_frame_type;
    Rframe_types last_rx_sub_Rframe_type = g_ese_ctx.p_T1_params->last_rx_sub_Rframe_type;

    if (RFRAME == last_rx_frame_type)
    {
        if (g_ese_ctx.p_T1_params->recovery_cnt < g_ese_ctx.max_recovery_cnt)
        {
            g_ese_ctx.p_T1_params->recovery_cnt++;

            if ((NULL != g_ese_ctx.p_T1_params->p_data_tx))
            {
                // device initiates block is an I-block
                if (IFRAME == g_ese_ctx.p_T1_params->tx_frame_type)
                {
                    if (RACK == last_rx_sub_Rframe_type)
                    {
                        g_ese_ctx.next_T1_state = R_OTHER_ERR;
                        g_ese_ctx.p_T1_params->tx_frame_type = RFRAME;
                        g_ese_ctx.p_T1_params->tx_sub_Rframe_type = RNACK_OTHER_ERROR;
                        g_ese_ctx.p_T1_params->tx_sub_Sframe_type = SFRAME_TYPE_INVALID;
                        LOG_INFO(TRACE_MODULE_SE, "%s: RACK for RNACK_OTHER_ERROR\r\n", __FUNCTION__);
                    }
                    else if (RNACK_PARITY_ERROR == last_rx_sub_Rframe_type)
                    {
                        g_ese_ctx.next_T1_state = I_BLK;
                        g_ese_ctx.p_T1_params->tx_frame_type = IFRAME;
                        // LOG_INFO(TRACE_MODULE_SE, "%s: RNACK_PARITY_ERROR, resend IFRAME\r\n", __FUNCTION__);
                    }
                    else if (RNACK_OTHER_ERROR == last_rx_sub_Rframe_type)
                    {
                        g_ese_ctx.seq_num_device ^= 0x01;
                        g_ese_ctx.is_seq_num_dr = true;
                        g_ese_ctx.next_T1_state = I_BLK;
                        g_ese_ctx.p_T1_params->tx_frame_type = IFRAME;
                        // LOG_INFO(TRACE_MODULE_SE, "%s: RNACK_OTHER_ERROR, resend IFRAME\r\n", __FUNCTION__);
                    }
                    else
                    {
                        g_ese_ctx.next_T1_state = STATE_IDEL;
                        g_ese_ctx.is_resync_recovery_flag = false;
                        LOG_INFO(
                            TRACE_MODULE_SE,
                            "%s: lastSendIFrame, lastRecvRFrame recovery failed, unkonwn  lastRFrameType = %d, recovery_cnt = %d, max_recovery_cnt = %d\r\n",
                            __FUNCTION__, g_ese_ctx.p_T1_params->last_rx_sub_Rframe_type, g_ese_ctx.p_T1_params->recovery_cnt, g_ese_ctx.max_recovery_cnt);
                    }
                }
                else if (SFRAME == g_ese_ctx.p_T1_params->tx_frame_type)
                {
                    if ((WTX_RSP == g_ese_ctx.p_T1_params->tx_sub_Sframe_type) || (IFS_RSP == g_ese_ctx.p_T1_params->tx_sub_Sframe_type) ||
                        (ABORT_RSP == g_ese_ctx.p_T1_params->tx_sub_Sframe_type))
                    {
                        LOG_INFO(TRACE_MODULE_SE,
                                 "%s: device initiates block is an I-block, lastTxSubSFrameType = %d, but device received R-block, cannot be occurred.\r\n",
                                 __FUNCTION__, g_ese_ctx.p_T1_params->tx_sub_Sframe_type);
                        // terminate transmit
                        g_ese_ctx.next_T1_state = STATE_IDEL;
                        g_ese_ctx.is_resync_recovery_flag = false;
                    }
                    else
                    {
                        LOG_INFO(TRACE_MODULE_SE, "%s: device initiates block is I-block, lastTxSubSFrameType = %d, recovery_cnt = %d\r\n", __FUNCTION__,
                                 g_ese_ctx.p_T1_params->tx_sub_Sframe_type, g_ese_ctx.p_T1_params->recovery_cnt);
                    }
                }
                else if (RFRAME == g_ese_ctx.p_T1_params->tx_frame_type)
                {
                    LOG_INFO(TRACE_MODULE_SE, "%s: device initiates block is I-block, lastTxSubRFrameType = %d, recovery_cnt = %d\r\n", __FUNCTION__,
                             g_ese_ctx.p_T1_params->tx_sub_Rframe_type, g_ese_ctx.p_T1_params->recovery_cnt);
                }
                else
                {
                    // unknown R-block type, terminate transmit
                    g_ese_ctx.next_T1_state = STATE_IDEL;
                    g_ese_ctx.is_resync_recovery_flag = false;
                    LOG_INFO(TRACE_MODULE_SE, "%s: lastSend unknown frame type, recovery_cnt = %d\r\n", __FUNCTION__, g_ese_ctx.p_T1_params->recovery_cnt);
                }
            }
            else if (SFRAME == g_ese_ctx.p_T1_params->tx_frame_type)
            {
                LOG_INFO(TRACE_MODULE_SE, "%s: device initiates block is S-block, lastTxSubSFrameType = %d, recovery_cnt = %d\r\n", __FUNCTION__,
                         g_ese_ctx.p_T1_params->tx_sub_Sframe_type, g_ese_ctx.p_T1_params->recovery_cnt);
            }
            else
            {
                LOG_INFO(TRACE_MODULE_SE, "%s: device initiates block cannot be an R-block, lastTxFrameType = %d\r\n", __FUNCTION__,
                         g_ese_ctx.p_T1_params->tx_frame_type);
                g_ese_ctx.next_T1_state = STATE_IDEL;
                g_ese_ctx.is_resync_recovery_flag = false;
            }
        }
        else
        {
            if (!g_ese_ctx.is_resync_recovery_flag && (NULL != g_ese_ctx.p_T1_params->p_data_tx))
            {
                g_ese_ctx.is_resync_recovery_flag = true;
                g_ese_ctx.next_T1_state = S_RESYNC_REQ;
                g_ese_ctx.p_T1_params->tx_frame_type = SFRAME;
                g_ese_ctx.p_T1_params->tx_sub_Sframe_type = RESYNC_REQ;
            }
            else if (g_ese_ctx.is_resync_recovery_flag && (NULL != g_ese_ctx.p_T1_params->p_data_tx))
            {
                free_tx_part_mem();
                g_ese_ctx.is_resync_recovery_flag = false;
                g_ese_ctx.next_T1_state = S_CIP_REQ;
                g_ese_ctx.p_T1_params->tx_frame_type = SFRAME;
                g_ese_ctx.p_T1_params->tx_sub_Sframe_type = CIP_REQ;
            }
            else
            {
                status = ESESTATUS_INVALID_PARAMETER;
                LOG_INFO(TRACE_MODULE_SE,
                         "%s: should be called when received an RFrame, but non-RFrame received, lastRecvFrameType = %d, recovery_cnt = %d, max_recovery_cnt = "
                         "%d\r\n",
                         __FUNCTION__, last_rx_frame_type, g_ese_ctx.p_T1_params->recovery_cnt, g_ese_ctx.max_recovery_cnt);
                // terminate transmit
                g_ese_ctx.next_T1_state = STATE_IDEL;
            }
        }
    }
    return status;
}

/******************************************************************************
 * @Function     t1_recv_data_store_in_list
 * @Param        p_data    - 7816-4 APDU response that shall be stored.
 *               data_len  - Length of the APDU response.
 *               total_len - T=1 total length, contains prologue and epilogue.
 * @Returns      On Success ESESTATUS_SUCCESS else ESESTATUS error.
 ******************************************************************************/
static ESESTATUS t1_recv_data_store_in_list(uint8_t *p_data, uint16_t data_len, uint16_t total_len)
{
    if ((0 == data_len) || (data_len != (total_len - get_header_len(true))))
    {
        // Other error, do nothing
        return ESESTATUS_INVALID_T1_LEN;
    }

    // if (g_recv_total_len == 0)
    // {
    //     memset(g_all_data_buf, 0, sizeof(g_all_data_buf));
    // }
    memcpy(g_all_data_buf + g_recv_total_len, p_data, data_len);
    g_recv_total_len += data_len;
    return ESESTATUS_SUCCESS;
}

/******************************************************************************
 * @Function     t1_recv_data_list_destroy
 ******************************************************************************/
static void t1_recv_data_list_destroy(void)
{
    g_recv_total_len = 0;
}

static void reset_ATR(void)
{
    atr_info atr = {
        .len = 0x13,
        .vendor_ID = {0x00},
        .dll_IC = 0x01,
        .bgt = {0x00, 0x01},
        .bwt = {0x03, 0xE8},
        .max_freq = {0x4E, 0x20},
        .checksum = 0x00,
        .default_IFSC = 0xFE,
        .num_channels = 0x01,
        .max_IFSC = {0x00, 0xFF},
        .capbilities = {0x00, 0x14}, // Extended frame length feature doesn't support
    };

    g_atr = atr;
}

/******************************************************************************
 * @Function     t1_transmit_receive_apdu
 * @Param        p_cmd_apdu - 7816-4 APDU that shall be sent.
 *               cmd_len - Length of the apduCmd to be sent.
 * @Returns      On success return ESESTATUS_SUCCESS or else ESESTATUS error.
 ******************************************************************************/
ESESTATUS t1_transmit_receive_apdu(uint8_t *p_cmd_apdu, uint16_t cmd_len)
{
    ESESTATUS status = ESESTATUS_SUCCESS;
    // LOG_INFO(TRACE_MODULE_SE, "%s: Enter\r\n", __FUNCTION__);
    status = init_Iframe_from_cmd_apdu(p_cmd_apdu, cmd_len);
    if (ESESTATUS_SUCCESS != status)
    {
        goto cleanup;
    }

    status = Transmit_receive_process();

    if (ESESTATUS_SUCCESS != status)
    {
        LOG_INFO(TRACE_MODULE_SE, "%s: t1_transmit_receive_apdu failed, status = %d\r\n", __FUNCTION__, status);
    }

cleanup:
    deinit_Iframe_from_cmd_apdu();
    return status;
}

/******************************************************************************
 * @Function     t1_CIP_req
 * @Returns      On success return ESESTATUS_SUCCESS or else ESESTATUS error.
 ******************************************************************************/
ESESTATUS t1_CIP_req(void)
{
    ESESTATUS status = ESESTATUS_SUCCESS;
    // LOG_INFO(TRACE_MODULE_SE, "t1CIPReq() enter\r\n");

    g_ese_ctx.p_T1_params = &g_T1_params;
    g_ese_ctx.p_T1_params->is_device_chaining = false;
    g_ese_ctx.next_T1_state = S_CIP_REQ;
    g_ese_ctx.p_T1_params->tx_frame_type = SFRAME;
    g_ese_ctx.p_T1_params->tx_sub_Sframe_type = CIP_REQ;

    status = Transmit_receive_process();
    g_ese_ctx.p_T1_params = NULL;

    return status;
}

/******************************************************************************
 * @Function     t1_ATR_req
 * @Returns      On success return ESESTATUS_SUCCESS or else ESESTATUS error.
 ******************************************************************************/
ESESTATUS t1_ATR_req(void)
{
    ESESTATUS status = ESESTATUS_SUCCESS;

    g_ese_ctx.p_T1_params = &g_T1_params;
    g_ese_ctx.p_T1_params->is_device_chaining = false;
    g_ese_ctx.next_T1_state = S_ATR_REQ;
    g_ese_ctx.p_T1_params->tx_frame_type = SFRAME;
    g_ese_ctx.p_T1_params->tx_sub_Sframe_type = ATR_REQ;

    status = Transmit_receive_process();
    g_ese_ctx.p_T1_params = NULL;

    return status;
}

/******************************************************************************
 * @Function     t1_IFSD_req
 * @Returns      On success return ESESTATUS_SUCCESS or else ESESTATUS error.
 ******************************************************************************/
ESESTATUS t1_IFSD_req(void)
{
    ESESTATUS status = ESESTATUS_SUCCESS;

    g_ese_ctx.p_T1_params = &g_T1_params;
    g_ese_ctx.p_T1_params->is_device_chaining = false;
    g_ese_ctx.next_T1_state = S_IFS_REQ;
    g_ese_ctx.p_T1_params->tx_frame_type = SFRAME;
    g_ese_ctx.p_T1_params->tx_sub_Sframe_type = IFS_REQ;

    status = Transmit_receive_process();
    g_ese_ctx.p_T1_params = NULL;

    return status;
}

/******************************************************************************
 * @Function     t1_prop_end_apdu_req
 * @Returns      On success return ESESTATUS_SUCCESS or else ESESTATUS error.
 ******************************************************************************/
ESESTATUS t1_prop_end_apdu_req(void)
{
    ESESTATUS status = ESESTATUS_SUCCESS;

    g_ese_ctx.p_T1_params = &g_T1_params;
    g_ese_ctx.p_T1_params->is_device_chaining = false;
    g_ese_ctx.next_T1_state = S_PROP_END_APDU_REQ;
    g_ese_ctx.p_T1_params->tx_frame_type = SFRAME;
    g_ese_ctx.p_T1_params->tx_sub_Sframe_type = PROP_END_APDU_REQ;

    status = Transmit_receive_process();
    g_ese_ctx.p_T1_params = NULL;

    return status;
}

/******************************************************************************
 * Function     t1_receive_data_and_get
 * @Param        pp_Data - a pointer address to the received data.
 *               data_len - a pointer to the length of the received data.
 * Returns       On success return ESESTATUS_SUCCESS or else ESESTATUS error.
 ******************************************************************************/
ESESTATUS t1_receive_data_and_get(uint8_t **pp_Data, uint16_t *data_len)
{
    *data_len = (uint16_t)g_recv_total_len;
    *pp_Data = g_all_data_buf;
    return ESESTATUS_SUCCESS;
}