/*
 * Copyright (c) 2019-2025 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_list.h"
#include "mk_timer_list.h"
#include "mk_misc.h"

#include "mk_rtc.h"
#include "mk_power.h"

#define DEBUG_EN 0
#if DEBUG_EN
#include "mk_trace.h"
#endif

#define MIN_TURNOVER_TICK_CNT (10)

static uint32_t ref_pt;
static mk_list_t meta_list;

static void mk_timer_init(drv_callback_t callback);
static uint32_t mk_timer_get_count(void);
extern void mk_timer_start(uint32_t ticks);

static uint32_t _past_ticks(uint32_t now)
{
    return (now >= ref_pt) ? now - ref_pt : UINT32_MAX - ref_pt + now;
}

static void _insert_timer(mk_timer_t *p, uint32_t ticks, uint8_t mode)
{
    mk_timer_t *p_last = NULL;

    uint32_t lock = int_lock();

    /* if timer is already running, stop and renew it */
    if (p->active)
    {
        mk_timer_list_stop_timer(p);
    }

    p->active = true;
    p->ticks = ticks;
    p->count = ticks;
    p->mode = mode;

    mk_timer_t *p_curr = (mk_timer_t *)meta_list.first;
    while (p_curr != NULL)
    {
        if (p->ticks < p_curr->ticks)
        {
            break;
        }
        p_last = p_curr;
        p_curr = p_curr->p_next;
    }

    if (p_last != NULL)
        mk_list_insert_after(&meta_list, (mk_list_hdr_t *)p_last, (mk_list_hdr_t *)p);
    else
        mk_list_push_front(&meta_list, (mk_list_hdr_t *)p);

    int_unlock(lock);
}

static void _post_process_timer(mk_timer_t *p)
{
    if (p->mode == MK_TIMER_PERIODIC)
    {
        _insert_timer(p, p->count, MK_TIMER_PERIODIC);
    }
    else
    {
        mk_timer_list_stop_timer(p);
    }
}

static void mk_timer_list_update(uint32_t now)
{
    uint32_t lock = int_lock();

    uint32_t ticks = _past_ticks(now);

    mk_timer_t *p = (mk_timer_t *)meta_list.first;
    while (p != NULL)
    {
        p->ticks = (p->ticks > ticks) ? p->ticks - ticks : 0;

        /* timer expired */
        if (p->ticks < POWER_DOWN_TIME_TICK_MIN)
        {
            p->ticks = 0;
            if (p->fast_cb == NULL)
            {
#ifdef WSF_EN
                WsfTaskSetReady(p->handlerId, WSF_TIMER_EVENT);
#else
                // mk_event_set();
#endif
            }
        }

#if DEBUG_EN
        LOG_INFO(TRACE_MODULE_OS, "mk_timer_list_update  %u %u %u %u\r\n", p->handlerId, p->msg.event, p->ticks, ticks);
#endif
        p = p->p_next;
    }

    bool wip = true;

    while (wip)
    {
        p = (mk_timer_t *)meta_list.first;

        if (p == NULL)
            break;

        /* iterate over timer queue */
        while (p != NULL)
        {
            if ((p->ticks == 0) && (p->fast_cb != NULL))
            {
                p->fast_cb();
                _post_process_timer(p);
                wip = true;
                break;
            }
            p = p->p_next;
            wip = false;
        }
    }

    ref_pt = now;

    int_unlock(lock);
}

void mk_timer_list_start_timer(mk_timer_t *p, uint32_t ms, uint8_t mode)
{
    uint32_t lock = int_lock();

    uint32_t now = mk_timer_get_count();
    mk_timer_list_update(now);
    _insert_timer(p, __MS_TO_32K_CNT(ms), mode);

    uint32_t pd_tick = mk_timer_list_tick_left();
    if (pd_tick != UINT32_MAX)
    {
        mk_timer_start(pd_tick);
    }

    int_unlock(lock);
}

void mk_timer_list_stop_timer(mk_timer_t *p)
{
    uint32_t lock = int_lock();

    mk_list_extract(&meta_list, (mk_list_hdr_t *)p);
    p->active = false;

    int_unlock(lock);
}

mk_timer_t *mk_timer_list_pick_expired(void)
{
    uint32_t lock = int_lock();

    mk_timer_t *p = (mk_timer_t *)meta_list.first;

    if ((p != NULL) && (p->ticks == 0))
    {
        _post_process_timer(p);
    }
    else
    {
        p = NULL;
    }

    int_unlock(lock);
    return p;
}

uint32_t mk_timer_list_tick_left(void)
{
    uint32_t ticks;
    uint32_t lock = int_lock();

    if (meta_list.first == NULL)
    {
        ticks = UINT32_MAX;
    }
    else
    {
        ticks = ((mk_timer_t *)meta_list.first)->ticks;
        uint32_t elapsed_ticks = _past_ticks(mk_timer_get_count());
        ticks = (ticks > elapsed_ticks) ? ticks - elapsed_ticks : 0;
    }

    int_unlock(lock);
    return ticks;
}

static void mk_timer_callback(void *dev, uint32_t now)
{
    uint32_t lock = int_lock();

    mk_timer_list_update(now);

    uint32_t pd_tick = mk_timer_list_tick_left();
    if (pd_tick != UINT32_MAX)
    {
        mk_timer_start(pd_tick);
    }

    int_unlock(lock);
}

void mk_timer_list_init(void)
{
    mk_list_init(&meta_list);

    mk_timer_init(mk_timer_callback);
}

/**
 * @brief  Initialize the low power timer.
 *
 * @param[in]  callback  The callback function of low power timer.
 */
static void mk_timer_init(drv_callback_t callback)
{
    power_wakeup_enable(POWER_WAKEUP_BY_RTC_ALARM, POWER_WAKEUP_LEVEL_NONE);
    // enable rtc alarm interrupt and register callback
    rtc_set_alarm(RTC_ID0, rtc_get(RTC_ID0) - 1U, callback);
}

/**
 * @brief  Get low power timer count.
 *
 * @return Low power timer count.
 */
static uint32_t mk_timer_get_count(void)
{
    return rtc_get(RTC_ID0);
}

/**
 * @brief  Start hardware low power timer.
 *
 * @param[in]  ticks  The number of ticks to wakeup from power down mode.
 */
void mk_timer_start(uint32_t ticks)
{
    ticks = (ticks > MIN_TURNOVER_TICK_CNT) ? ticks : MIN_TURNOVER_TICK_CNT;

    ticks += rtc_get(RTC_ID0);
    rtc_set_alarm_lite(RTC_ID0, ticks);
}