/*
 * Copyright (c) 2019-2023 Beijing Hanwei Innovation Technology Ltd. Co. and
 * its subsidiaries and affiliates (collectly called MKSEMI).
 *
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form, except as embedded into an MKSEMI
 *    integrated circuit in a product or a software update for such product,
 *    must reproduce the above copyright notice, this list of conditions and
 *    the following disclaimer in the documentation and/or other materials
 *    provided with the distribution.
 *
 * 3. Neither the name of MKSEMI nor the names of its contributors may be used
 *    to endorse or promote products derived from this software without
 *    specific prior written permission.
 *
 * 4. This software, with or without modification, must only be used with a
 *    MKSEMI integrated circuit.
 *
 * 5. Any software provided in binary form under this license must not be
 *    reverse engineered, decompiled, modified and/or disassembled.
 *
 * THIS SOFTWARE IS PROVIDED BY MKSEMI "AS IS" AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL MKSEMI OR CONTRIBUTORS BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "mk_trace.h"
#include "mk_clock.h"
#include "mk_power.h"
#include "mk_misc.h"
#include "uwb_trx.h"
#if CSI_EN
#include "lib_ranging.h"
#include "lib_aoa.h"
#include "uwb_api.h"
// extern uint16_t g_main_path_loc;
// extern uint16_t g_fap_loc;
// extern uint16_t g_sts_main_path_loc;
// extern uint16_t g_sts_fap_loc;
#endif

#define PAYLOAD_PRINT_EN 0

uint8_t uwb_tx_done = 0;
uint8_t uwb_rx_done = 0;

/*************************************************************************************************/
/*!
 *  \brief  WSF event handler for uwb task.
 *
 *  \param  event   WSF event mask.
 *  \param  msg    WSF message.
 *
 *  \return None.
 */
/*************************************************************************************************/
void uwb_handler(wsfEventMask_t event, const void *param)
{
    const wsfMsgHdr_t *msg = (const wsfMsgHdr_t *)param;
    if (msg != NULL)
    {
        switch (msg->event)
        {
            case UWB_TX_DONE_MSG:
            {
                const struct UWB_TX_DONE_IND_T *ind = (const struct UWB_TX_DONE_IND_T *)param;
                // LOG_INFO(TRACE_MODULE_UWB, "UWB TX DONE %04x\r\n", ind->status);
                uwb_tx_done = 1;

                if (ind->status == UWB_TX_OK)
                {
                    // print payload
                    LOG_INFO(TRACE_MODULE_UWB, "[TX][%d]", ind->length);
#if PAYLOAD_PRINT_EN
                    for (int i = 0; i < ind->length; i++)
                    {
                        LOG_INFO(TRACE_NO_OPTION | TRACE_MODULE_UWB, " %02x", ind->data[i]);
                    }
#endif
                    LOG_INFO(TRACE_NO_OPTION | TRACE_MODULE_UWB, "\r\n");
                }
                else
                {
                    LOG_INFO(TRACE_MODULE_UWB, "UWB TX fail 0x%04x\r\n", ind->status);
                }
            }
            break;

            case UWB_RX_DONE_MSG:
            {
                const struct UWB_RX_DONE_IND_T *ind = (const struct UWB_RX_DONE_IND_T *)param;
                // LOG_INFO(TRACE_MODULE_UWB, "UWB RX DONE %02x\r\n", ind->status);
                uwb_rx_done = 1;

                if (ind->status == UWB_RX_OK)
                {
                    // print payload
                    LOG_INFO(TRACE_MODULE_UWB, "[RX][%d]", ind->length);
#if PAYLOAD_PRINT_EN
                    for (uint8_t i = 0; i < ind->length; i++)
                    {
                        LOG_INFO(TRACE_NO_OPTION | TRACE_MODULE_UWB, " %02x", ind->data[i]);
                    }
#endif
                    LOG_INFO(TRACE_NO_OPTION | TRACE_MODULE_UWB, "\r\n");

                    int32_t freq_offset = phy_freq_offset_get();
                    int32_t freq_offset_filter = average_filter(freq_offset);
                    LOG_INFO(TRACE_MODULE_APP, "CH Freq Offset %d\r\n", freq_offset_filter);

#if CSI_EN
                    // need to increase slot duration for log printing
#if 0
                    ranging_first_path_detect(ind->rssi);
                    LOG_INFO(TRACE_MODULE_UWB, "main tap: %d first tap: %d \r\n", g_main_path_loc, g_fap_loc);

                    if ((uwb_app_config.ppdu_params.sts_pkt_cfg == SP1) || (uwb_app_config.ppdu_params.sts_pkt_cfg == SP3))
                    {
                        if (sts_valid_check())
                        {
                            sts_first_path_detect(ind->rssi, &g_sts_main_path_loc, &g_sts_fap_loc);
                            LOG_INFO(TRACE_MODULE_UWB, "main tap: %d first tap: %d \r\n", g_sts_main_path_loc, g_sts_fap_loc);
                        }
                        else 
                        {
                            LOG_INFO(TRACE_MODULE_UWB, "STS invalid\r\n");
                        }
                    }
#endif
                    struct RANGING_TAPS_INF_T taps_inf;
                    ranging_taps_inf_get(&taps_inf);
                    LOG_INFO(TRACE_MODULE_APP, "NLoS: %d, FoM: %u \r\n", taps_inf.NLoS, taps_inf.FoM);
                    // LOG_INFO(TRACE_MODULE_APP, "fap: %d, %f\r\n", taps_inf.fap_loc, taps_inf.fap_pow);
                    // LOG_INFO(TRACE_MODULE_APP, "tap1: %d, %f\r\n", taps_inf.tap1_loc, taps_inf.tap1_pow);
                    // LOG_INFO(TRACE_MODULE_APP, "tap2: %d, %f\r\n", taps_inf.tap2_loc, taps_inf.tap2_pow);
                    // LOG_INFO(TRACE_MODULE_APP, "tap3: %d, %f\r\n", taps_inf.tap3_loc, taps_inf.tap3_pow);

                    // float chtaps_re[128];
                    // float chtaps_im[128];
                    // ranging_multi_taps_iq_get(chtaps_re, chtaps_im, 128);
                    // for (uint8_t i = 0; i < 128; i++)
                    // {
                    //     LOG_INFO(TRACE_NO_OPTION | TRACE_MODULE_APP, "%f, %f\r\n", chtaps_re[i], chtaps_im[i]);
                    // }
#endif

                    // print_preamble_chest(1, 1);
                    // print_sts_ch_taps(1);
                }
                else
                {
                    LOG_INFO(TRACE_MODULE_UWB, "UWB RX fail  0x%04x\r\n", ind->status);
#if 0
                    uint8_t BD_err = (ind->status >> 4) & 0x1;
                    uint8_t SFD_err = (ind->status >> 3) & 0x1;
                    uint8_t PHR_err = (ind->status >> 2) & 0x1;
                    uint8_t PLD_err = (ind->status >> 1) & 0x1;

                    uint32_t SYNSTATUS_4 = REG_READ(0x4000406C);
                    uint16_t BD_cnt = SYNSTATUS_4 & 0xFFFF;
                    uint16_t SFD_cnt = (SYNSTATUS_4 >> 16) & 0xFFFF;

                    LOG_INFO(TRACE_MODULE_UWB, "BD err %d SFD err %d PHR err %d PLD err %d BD cnt %u SFD cnt %u\r\n", BD_err, SFD_err, PHR_err, PLD_err, BD_cnt,
                             SFD_cnt);
#endif
                }
#if RSSI_EN
                if (ind->status != 0x0830)
                {
                    LOG_INFO(TRACE_MODULE_APP, "RSSI: %ddBm, SNR: %ddB \r\n", ind->rssi, ind->snr);
                }
#endif
            }
            break;

            default:
                break;
        }
    }
    // Handle events
    else if (event)
    {
    }
}