/*
 * 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_power.h"
#include "mk_uwb.h"
#include "mk_timer.h"
#include "wsf_msg.h"
#include "uwb_api.h"
#include "mk_radar.h"
#include "uwb_radar.h"
#if UWB_DUAL_RADAR
#include "lib_fira.h"
#endif

// #include "board.h"

#ifndef UWB_RADAR_INTERVAL
/** Radar standalone mode interval, unit: ms */
#define UWB_RADAR_INTERVAL (100)
#endif

struct UWB_RADAR_ENV_T radar_env;

static struct UWB_RADAR_CB_T uwb_radar_cb;

static struct UWB_OP_T radar_op = {
    .session_configure = NULL,
    .session_start = NULL,
    .session_stop = NULL,
    .session_local_addr_set = NULL,
    .session_peer_addr_set = NULL,
    .session_responder_addr_add = NULL,
    .session_responder_list_clr = NULL,
    .session_dynamic_update_responder_list = NULL,
    .session_set_ccc_ursk = NULL,
    .vendor_session_configure = uwb_radar_configure,
    .vendor_session_start = uwb_radar_start,
    .vendor_session_stop = uwb_radar_stop,
};

static mac_callback_t bak_tx_cb;
static mac_callback_t bak_rx_cb;

static mac_callback_t force_bak_tx_cb;
static mac_callback_t force_bak_rx_cb;

static void uwb_radar_tx_process(struct MAC_HW_REPORT_T *tx_report);
static void uwb_radar_rx_process(struct MAC_HW_REPORT_T *rx_report);

void uwb_radar_session_init(void);

static void uwb_radar_tx_process(struct MAC_HW_REPORT_T *tx_report)
{
    radar_env.rx_ant_idx++;
    if (radar_env.rx_ant_idx == UWB_RADAR_RX_PORT_NUM)
    {
        radar_env.rx_ant_idx = 0;
    }

#if UWB_RADAR_1TNR_MODE == 1
    // board_led_on(BOARD_LED_2);
    if (radar_env.rx_ant_idx == 0)
    {
        power_off_radio();
        WsfSetEvent(uwb_radar_cb.handle_id, UWB_RADAR_SAMPLING_COMPLETE_EVT);
    }
    else
    {
        radar_start(radar_env.rx_ant_idx);
    }
    // board_led_off(BOARD_LED_2);
#else
    power_off_radio();
    WsfSetEvent(uwb_radar_cb.handle_id, UWB_RADAR_SAMPLING_COMPLETE_EVT);
#endif
}

static void uwb_radar_rx_process(struct MAC_HW_REPORT_T *rx_report)
{
    // do nothing
}

int uwb_radar_init(uint8_t handle_id)
{
    /* store handler ID */
    uwb_radar_cb.handle_id = handle_id;

    /* init rx queue */
    WSF_QUEUE_INIT(&uwb_radar_cb.msg_queue);

    uwb_radar_cb.radar_alone_timer.handlerId = handle_id;
    uwb_radar_cb.radar_alone_timer.msg.event = UWB_RADAR_ALONE_WAKEUP_MSG;

    radar_env.sample_count = 0;
    radar_env.sample_num = 0;

    return 0;
}

void uwb_radar_alone_timer_set(void)
{
    WsfTimerStartMs(&uwb_radar_cb.radar_alone_timer, UWB_RADAR_INTERVAL, WSF_TIMER_PERIODIC);
}

void uwb_radar_alone_timer_clr(void)
{
    WsfTimerStop(&uwb_radar_cb.radar_alone_timer);
}

int uwb_radar_deinit(void)
{
    return 0;
}

uint32_t uwb_is_radar_mode(void)
{
    uint32_t isenable = 0;

    uint32_t lock = int_lock();
    isenable = radar_env.enable;
    int_unlock(lock);

    return isenable;
}

void uwb_radar_start(void)
{
    uint32_t lock = int_lock();
    radar_env.sample_count = 0;
    radar_env.sample_num = 0;
    radar_env.rx_ant_idx = 0;
    radar_env.enable = 0x1U;
    mac_get_process_handler(&force_bak_tx_cb, &force_bak_rx_cb);
    int_unlock(lock);

    if (SESSION_TYPE_VENDOR_ALONE_RADAR == uwb_app_config.session_type)
    {
        uwb_radar_alone_timer_set();
    }
}

void uwb_radar_stop(void)
{
    uint32_t lock = int_lock();
    radar_env.sample_count = 0;
    radar_env.sample_num = 0;
    radar_env.enable = 0x0U;
    int_unlock(lock);

    if (SESSION_TYPE_VENDOR_ALONE_RADAR == uwb_app_config.session_type)
    {
        radar_disable();
    }
}

/**
 * @brief UWB radar session initialization function.
 * @note This function will be called by uwbapi_session_init().
 */
void uwb_radar_session_init(void)
{
    uwb_radar_creat_event();

    uwbs_handler_init(&radar_op);
}

void uwb_radar_configure(void)
{
    struct UWB_RADAR_T radar_param;
    radar_param.request = uwb_app_config.session_param.uwb_radar_req;
    radar_param.ant_id = uwb_app_config.session_param.uwb_radar_rx_ant_id;
    radar_param.bandwidth = uwb_app_config.session_param.uwb_radar_bandwidth;
    radar_param.channel_num = uwb_app_config.session_param.uwb_radar_channel_num;
    radar_param.lna_gain_level = uwb_app_config.session_param.uwb_radar_lna_gain_level;
    radar_param.pulse_period = uwb_app_config.session_param.uwb_radar_pulse_period;
    radar_param.ranging_tx_power_level = uwb_app_config.session_param.tx_power_level;
    radar_param.rx_gain_level = uwb_app_config.session_param.uwb_radar_rx_gain_level;
    radar_param.sts_len = uwb_app_config.session_param.uwb_radar_sts_len;
    radar_param.tx_power_level = uwb_app_config.session_param.uwb_radar_tx_power_level;
    radar_config(&radar_param);
}

void uwb_radar_alone_continue_trigger(void)
{
    WsfSetEvent(uwb_radar_cb.handle_id, UWB_RADAR_START_SAMPLING_EVT);
}

void uwb_radar_force_destroy_event(void)
{
    uint32_t lock = int_lock();
    mac_register_process_handler(force_bak_tx_cb, force_bak_rx_cb);
    int_unlock(lock);
}

void uwb_radar_creat_event(void)
{
    uint32_t lock = int_lock();

    if (0 == radar_env.sample_count)
    {
        mac_get_process_handler(&bak_tx_cb, &bak_rx_cb);
        mac_register_process_handler(uwb_radar_tx_process, uwb_radar_rx_process);
    }

    int_unlock(lock);
}

void uwb_radar_destroy_event(void)
{
    uint32_t lock = int_lock();

    radar_env.sample_count++;
    if (radar_env.sample_count >= radar_env.sample_num)
    {
        radar_env.sample_count = 0;
        mac_register_process_handler(bak_tx_cb, bak_rx_cb);
        bak_tx_cb = NULL;
        bak_rx_cb = NULL;
    }
    else
    {
        uwb_radar_alone_continue_trigger();
    }

    int_unlock(lock);
}

bool ranging_twr_idle_evt(uint32_t idle_duration)
{
    bool ret = true;

    radar_env.sample_num = idle_duration / UWB_RADAR_SLOT_DURATION;
#if UWB_DUAL_RADAR
    if (ranging_env.responder_slot_idx[SLOT_RESPONSE] == 2)
    {
        radar_env.sample_num = (idle_duration / UWB_RADAR_SLOT_DURATION) / 2 + (idle_duration / UWB_RADAR_SLOT_DURATION) % 2;
    }
#endif
    // LOG_INFO(TRACE_MODULE_APP, "radar rounds: %u\r\n", radar_env.sample_num);

    if (radar_env.sample_num)
    {
        uwb_radar_alone_continue_trigger();
        ret = false;
    }

    return ret;
}

uint16_t uwb_radar_data_checksum(const uint8_t *data, uint32_t data_len)
{
    uint32_t sum = 0;
    uint16_t check_sum = 0;
    for (uint32_t i = 0; i < data_len; i++)
    {
        sum ^= *(data + i);
    }
    check_sum = (uint16_t)(sum & 0xFFFF);

    return check_sum;
}