/**
 *******************************************************************************
 * @file     app_timer.c
 * @create   2023-08-01    
 * @author   Panchip BLE GROUP
 * @note
 * Copyright (c) Shanghai Panchip Microelectronics Co.,Ltd.
 *
 *******************************************************************************
 */
#include "app_timer.h"
#include "PanSeries.h"
#include "utils/fifo.h"
#include "utils/critical.h"
#include "sort_queue.h"
#include "soc_api.h"

#if defined(IP_107x) || defined(IP_101x)
static app_timer_t *cur_active_timer = NULL;
static bool global_active = false;

/**
 * @brief Timer requests types.
 */
typedef enum{
    TIMER_REQ_START,
    TIMER_REQ_STOP,
    TIMER_REQ_STOP_ALL
}timer_req_type_t;

/**
 * @brief Operation request structure.
 */
typedef struct{
    app_timer_t         *p_timer; /**< Timer instance. */
    timer_req_type_t 	 type;    /**< Request type. */
}timer_req_t;

FIFO_DEFINE(timer_req_fifo, MEM_ALIGNED4(sizeof(timer_req_t)), APP_TIMER_REQ_FIFO_ITEM_NUM);

bool sort_list_compare_func(sort_queue_item_t *item0, sort_queue_item_t *item1);
SORT_QUEUE_INIT(app_timer_sort_queue, sort_list_compare_func);


static bool time_little(uint32_t t1, uint32_t t2)
{
	return (uint32_t)(t1 - t2) > BIT(30) ? true:false;
}

bool sort_list_compare_func(sort_queue_item_t *item0, sort_queue_item_t *item1)
{
	app_timer_t *ptimer0 = (app_timer_t *)item0;
	app_timer_t *ptimer1 = (app_timer_t *)item1;

	if(time_little(ptimer0->endVal, ptimer1->endVal)){
		return true;
	}
	return false;
}

uint32_t sort_list_cnt(void)
{
	return sort_queue_cnt(&app_timer_sort_queue);
}

void sort_list_add(app_timer_t *ptimer)
{
	sort_queue_add(&app_timer_sort_queue, (sort_queue_item_t *)ptimer);
}

app_timer_t *sort_list_pop(void)
{
	return (app_timer_t *)sort_queue_pop(&app_timer_sort_queue);
}

app_timer_t *sort_list_peek(void)
{
	return (app_timer_t *)sort_queue_peek(&app_timer_sort_queue);
}

void sort_list_remove(app_timer_t *ptimer)
{
	sort_queue_remove(&app_timer_sort_queue, (sort_queue_item_t *)ptimer);
}

void sort_list_remove_all(void)
{
	app_timer_t *p_cur_timer = NULL;
	do {
		p_cur_timer = sort_list_pop();
		if(p_cur_timer){
			p_cur_timer->endVal = APP_TIMER_IDLE_VAL;
		}
	}while(p_cur_timer);
}

static void timer_req_trigger(void)
{
	NVIC_SetPendingIRQ(SLPTMR_IRQn);
}

static int timer_req_send(app_timer_t *ptimer, timer_req_type_t type)
{
	fifo_t *pfifo = &timer_req_fifo;
	if(FIFO_IsFull(pfifo)){
		return APP_TIMER_NO_MEM;
	}

	timer_req_t *ptimer_req = (timer_req_t *)FIFO_GetWriteBuf(pfifo);

	ptimer_req->type = type;
	ptimer_req->p_timer = ptimer;

	FIFO_MoveToNextWriteBuf(pfifo); 

	timer_req_trigger();

	return APP_TIMER_OK;
}

static void timer_req_handler(void)
{
	fifo_t *pfifo = &timer_req_fifo;

	while(pfifo->w != pfifo->r)
	{
		timer_req_t *ptimer_req = (timer_req_t *)FIFO_GetReadBuf(pfifo);
		app_timer_t *ptimer = ptimer_req->p_timer;

		switch(ptimer_req->type)
		{
		case TIMER_REQ_START:
			if(!APP_TIMER_IS_IDLE(ptimer)){
				sort_list_add(ptimer);
			}
			break;

		case TIMER_REQ_STOP:
			if(ptimer == cur_active_timer){
				cur_active_timer = NULL;
			}
			else{
				sort_list_remove(ptimer);
			}
			break;

		case TIMER_REQ_STOP_ALL:
			sort_list_remove_all();
			global_active = true;
			break;

		default:
			break;
		}

		FIFO_MoveToNextReadBuf(pfifo); // must
	}
}

uint32_t app_timer_get_cnt_tick(void)
{
#if 1
	soc_busy_wait(35);//must wait 1 32k cycle when read 32k cnt
	return ANA->LP_SLPTMR;
#else
	return soc_lptmr_cycle_get(); //!!!Note: BLE MAC clock must be enabled.
#endif
}

void app_timer_set_cmp(uint32_t tick)
{
	ANA->LP_SPACING_TIME1 = tick;
}

static void app_timer_expired(app_timer_t *ptimer)
{
	if(global_active == false)
		return;

	uint32_t cpu_state = 0;

	if(ptimer)
	{
		ENTER_CRITICAL(cpu_state);
		if(ptimer->reloadPeriod == 0){
			ptimer->endVal = APP_TIMER_IDLE_VAL;
		}
		EXIT_CRITICAL(cpu_state);

		if(ptimer->handler){
			ptimer->handler(ptimer->ctxt);
		}

		ENTER_CRITICAL(cpu_state);
		/* check active flag as it may have been stopped in the user handler */
		if(ptimer->reloadPeriod && !APP_TIMER_IS_IDLE(ptimer)){
			ptimer->endVal += ptimer->reloadPeriod;

			//push timer to queue
			sort_list_add(ptimer);
		}
		EXIT_CRITICAL(cpu_state);
	}
}

static void app_timer_update(void)
{
	app_timer_t *ptimer = NULL;
	bool reconfig = false;
	while(1)
	{
		ptimer = sort_list_peek();
		if(ptimer == NULL){
			break;
		}

		if(APP_TIMER_IS_IDLE(ptimer)){
			sort_list_pop();
			continue;
		}
		else if(cur_active_timer == NULL){
			reconfig = true;
		}
		else if(time_little(ptimer->endVal, cur_active_timer->endVal)){
			if(!APP_TIMER_IS_IDLE(cur_active_timer)){
				sort_list_add(cur_active_timer);
			}
			reconfig = true;
		}

		if(!reconfig){
			break;
		}

		ptimer = sort_list_pop();
		if((uint32_t)((app_timer_get_cnt_tick()+APP_TIMER_MIN_TIMEOUT_TICKS) - ptimer->endVal) > BIT(30)){
			cur_active_timer = ptimer;
			app_timer_set_cmp((uint32_t)(ptimer->endVal - app_timer_get_cnt_tick()));
			break; //select ok
		}
		else{
			//timer expired
			app_timer_expired(ptimer);
			cur_active_timer = NULL;

			// select next timer object
		}
	}
}

void sleep_timer1_handler(void)
{
	if(cur_active_timer){
		app_timer_expired(cur_active_timer);
		cur_active_timer = NULL;
	}
}

void sleep_timer_post_irq_handler(void)
{
	timer_req_handler();
	app_timer_update();
}

void sleep_timer_it_config(uint8_t en)
{
	#define LP_INT_REG_WR_BIT_MASK  (BIT(0) | BIT(16) | BIT(20))
	
	uint32_t state = ANA->LP_INT_CTRL;

	if(en){
		ANA->LP_INT_CTRL = (state & LP_INT_REG_WR_BIT_MASK) | ANAC_INT_SLEEP_TMR_INT_EN_Msk;
	}
	else{
		ANA->LP_INT_CTRL = (state & LP_INT_REG_WR_BIT_MASK) & (~ANAC_INT_SLEEP_TMR_INT_EN_Msk);
	}
}

int app_timer_init(void)
{
	sleep_timer_it_config(ENABLE);
	NVIC_ClearPendingIRQ(SLPTMR_IRQn);
	NVIC_EnableIRQ(SLPTMR_IRQn);

	global_active = true;
	
	return APP_TIMER_OK;
}

int app_timer_create(app_timer_t *ptimer, app_timer_mode_t mode, app_timer_timeout_handler_t timeout_handler)
{
	ptimer->endVal  = APP_TIMER_IDLE_VAL;
	ptimer->handler = timeout_handler;
	ptimer->reloadPeriod = (mode == APP_TIMER_MODE_REPEATED ? 1:0);
	
	return APP_TIMER_OK;
}

int app_timer_start(app_timer_t *ptimer, uint32_t timeout_ticks, void *ctxt)
{
	uint32_t cpu_state = 0;

	if(APP_TIMER_IS_IDLE(ptimer))
	{
		ENTER_CRITICAL(cpu_state);
		ptimer->endVal = app_timer_get_cnt_tick() + timeout_ticks;
		EXIT_CRITICAL(cpu_state);

		ptimer->ctxt = ctxt;

		if(ptimer->reloadPeriod){
			ptimer->reloadPeriod = timeout_ticks;
		}

		return timer_req_send(ptimer, TIMER_REQ_START);
	}
	return APP_TIMER_OK;
}

int app_timer_stop(app_timer_t *ptimer)
{
	if(APP_TIMER_IS_IDLE(ptimer)){
		return APP_TIMER_OK;
	}

	uint32_t cpu_state = 0;
	ENTER_CRITICAL(cpu_state);
	ptimer->endVal = APP_TIMER_IDLE_VAL;
	EXIT_CRITICAL(cpu_state);

	return timer_req_send(ptimer, TIMER_REQ_STOP);
}

int app_timer_stop_all(void)
{
	global_active = false;
	return timer_req_send(NULL, TIMER_REQ_STOP_ALL);
}




#if APP_TIMER_TEST_EN
#include "pan_ble.h"
app_timer_t app_timer1;
app_timer_t app_timer2;


void app_timer1_cb(void *ctxt)
{
	static uint8_t flag = 1;
	
	DBG_CHN6_TOGGLE

	if(flag){
		app_timer_stop(&app_timer2);
		flag = 0;
	}
	else{
		flag = 1;
		app_timer_start(&app_timer2, (100*32), NULL);
	}
}

void app_timer2_cb(void *ctxt)
{
	DBG_CHN5_TOGGLE
}

void app_timer_test(void)
{
	app_timer_init();

	app_timer_create(&app_timer1, APP_TIMER_MODE_REPEATED, app_timer1_cb);
	app_timer_create(&app_timer2, APP_TIMER_MODE_REPEATED, app_timer2_cb);

	app_timer_start(&app_timer1, (500*32), NULL);
	app_timer_start(&app_timer2, (100*32), NULL);
}
#endif

#endif