/*
 * Copyright (c) 2025, LISTENAI
 *
 * SPDX-License-Identifier: Apache-2.0
 */

/**
 * @file lisa_wdt_arcs.c
 * @brief LISA WDT ARCS 平台适配层
 *
 * 此文件实现 ARCS 芯片平台的看门狗定时器硬件适配
 */

#include "lisa_wdt.h"
#include "Driver_WDT.h"
#include "arcs_ap.h"
#include <stddef.h>
#include <string.h>
#include <lisa_mutex.h>

#define LOG_TAG "lisa_wdt_arcs"
#include <lisa_log.h>

#define DEVICE_LOCK(priv)                                                                                              \
    do {                                                                                                               \
        if (priv->mutex) {                                                                                             \
            lisa_mutex_lock(priv->mutex, LISA_OS_WAIT_FOREVER);                                                        \
        }                                                                                                              \
    } while (0)

#define DEVICE_UNLOCK(priv)                                                                                            \
    do {                                                                                                               \
        if (priv->mutex) {                                                                                             \
            lisa_mutex_unlock(priv->mutex);                                                                            \
        }                                                                                                              \
    } while (0)

/* ===== WDT 时钟频率定义 ===== */
#define WDT_CLK_32K_HZ  32000UL  /* 32K 时钟频率 (Hz) */
#define WDT_CLK_APB_HZ  PCLKFREQ()  /* APB 时钟频率 (Hz)，运行时获取 */

/* ===== WDT 设备私有数据 ===== */
typedef struct {
    void *hal_handler;                    /* HAL WDT 句柄 */
    lisa_mutex_t *mutex;                  /* 互斥锁 */
    lisa_wdt_config_t config;             /* 当前配置 */
    lisa_wdt_state_t state;               /* 当前状态 */
    lisa_wdt_callback_t callback;         /* 超时回调函数 */
    void *user_data;                      /* 用户数据 */
    hal_driver_wdt_clk_src clk_src;       /* 时钟源 */
    hal_driver_wdt_int_time int_time;     /* 中断时间配置 */
    hal_driver_wdt_rst_time rst_time;     /* 复位时间配置 */
    uint32_t configured_timeout_ms;       /* 已配置的超时时间（毫秒）*/
} lisa_wdt_priv_t;

/* ===== WDT 设备静态实例 ===== */
static lisa_wdt_priv_t wdt0_priv;

/* ===== 内部辅助函数 ===== */

/**
 * @brief HAL中断回调函数
 * 
 * 注意：此函数在中断上下文中执行，应尽量简短快速
 * 不要在中断回调中调用可能阻塞的函数（如mutex操作）
 */
static void wdt_hal_irq_callback(void *workspace)
{
    lisa_wdt_priv_t *priv = (lisa_wdt_priv_t *)workspace;
    if (!priv) {
        LISA_LOGE(LOG_TAG, "[IRQ] WDT callback: invalid workspace");
        return;
    }

    /* 更新状态为已超时（在中断上下文中，直接赋值是安全的） */
    priv->state = LISA_WDT_STATE_EXPIRED;

    LISA_LOGW(LOG_TAG, "[IRQ] WDT interrupt triggered! State updated to EXPIRED");

    /* 调用用户回调函数 */
    if (priv->callback) {
        LISA_LOGD(LOG_TAG, "[IRQ] Calling user callback");
        priv->callback(priv->user_data);
        LISA_LOGD(LOG_TAG, "[IRQ] User callback returned");
    } else {
        LISA_LOGW(LOG_TAG, "[IRQ] WDT interrupt triggered but no user callback registered");
    }
}

/**
 * @brief 将毫秒转换为中断时间枚举值
 *
 * @param timeout_ms 超时时间（毫秒）
 * @param clk_src 时钟源
 * @param int_time 输出参数，中断时间枚举值
 *
 * @return 0 成功
 * @return LISA_DEVICE_ERR_RANGE 超时时间超出范围
 */
static int ms_to_int_time(uint32_t timeout_ms, hal_driver_wdt_clk_src clk_src, hal_driver_wdt_int_time *int_time)
{
    uint32_t clk_freq = (clk_src == hal_driver_wdt_clk_src_32k) ? WDT_CLK_32K_HZ : WDT_CLK_APB_HZ;
    uint64_t clk_period_ns = 1000000000ULL / clk_freq;  /* 时钟周期（纳秒）*/
    uint64_t timeout_ns = (uint64_t)timeout_ms * 1000000ULL;  /* 超时时间（纳秒）*/
    uint64_t clk_count = timeout_ns / clk_period_ns;  /* 需要的时钟周期数 */

    /* 查找大于等于所需周期数的最小 2^N 值（向上取整） */
    /* 这样可以确保实际超时时间不会小于配置的时间 */
    if (clk_count <= (1ULL << 6)) {
        *int_time = hal_driver_wdt_int_time_6;
    } else if (clk_count <= (1ULL << 8)) {
        *int_time = hal_driver_wdt_int_time_8;
    } else if (clk_count <= (1ULL << 10)) {
        *int_time = hal_driver_wdt_int_time_10;
    } else if (clk_count <= (1ULL << 11)) {
        *int_time = hal_driver_wdt_int_time_11;
    } else if (clk_count <= (1ULL << 12)) {
        *int_time = hal_driver_wdt_int_time_12;
    } else if (clk_count <= (1ULL << 13)) {
        *int_time = hal_driver_wdt_int_time_13;
    } else if (clk_count <= (1ULL << 14)) {
        *int_time = hal_driver_wdt_int_time_14;
    } else if (clk_count <= (1ULL << 15)) {
        *int_time = hal_driver_wdt_int_time_15;
    } else if (clk_count <= (1ULL << 17)) {
        *int_time = hal_driver_wdt_int_time_17;
    } else if (clk_count <= (1ULL << 19)) {
        *int_time = hal_driver_wdt_int_time_19;
    } else if (clk_count <= (1ULL << 21)) {
        *int_time = hal_driver_wdt_int_time_21;
    } else if (clk_count <= (1ULL << 23)) {
        *int_time = hal_driver_wdt_int_time_23;
    } else if (clk_count <= (1ULL << 25)) {
        *int_time = hal_driver_wdt_int_time_25;
    } else if (clk_count <= (1ULL << 27)) {
        *int_time = hal_driver_wdt_int_time_27;
    } else if (clk_count <= (1ULL << 29)) {
        *int_time = hal_driver_wdt_int_time_29;
    } else if (clk_count <= (1ULL << 31)) {
        *int_time = hal_driver_wdt_int_time_31;
    } else {
        return LISA_DEVICE_ERR_RANGE;
    }

    /* 计算实际超时时间用于日志 - 需要根据枚举值映射到实际的2^N值 */
    uint64_t actual_clk_count;
    int exp;
    switch ((int)*int_time) {
        case 0: exp = 6; break;   /* int_time_6 */
        case 1: exp = 8; break;   /* int_time_8 */
        case 2: exp = 10; break;  /* int_time_10 */
        case 3: exp = 11; break;  /* int_time_11 */
        case 4: exp = 12; break;  /* int_time_12 */
        case 5: exp = 13; break;  /* int_time_13 */
        case 6: exp = 14; break;  /* int_time_14 */
        case 7: exp = 15; break;  /* int_time_15 */
        case 8: exp = 17; break;  /* int_time_17 */
        case 9: exp = 19; break;  /* int_time_19 */
        case 10: exp = 21; break; /* int_time_21 */
        case 11: exp = 23; break; /* int_time_23 */
        case 12: exp = 25; break; /* int_time_25 */
        case 13: exp = 27; break; /* int_time_27 */
        case 14: exp = 29; break; /* int_time_29 */
        case 15: exp = 31; break; /* int_time_31 */
        default: exp = 6; break;
    }
    actual_clk_count = (1ULL << exp);
    uint64_t actual_timeout_ms = (actual_clk_count * clk_period_ns) / 1000000ULL;
    LISA_LOGD(LOG_TAG, "ms_to_int_time: requested=%lu ms, clk_freq=%lu Hz, clk_count=%llu, selected=int_time_%d (2^%d=%llu cycles, ≈%llu ms)",
              timeout_ms, clk_freq, clk_count, (int)*int_time, exp, actual_clk_count, actual_timeout_ms);

    return LISA_DEVICE_OK;
}

/**
 * @brief 将毫秒转换为复位时间枚举值
 *
 * @param timeout_ms 超时时间（毫秒）
 * @param clk_src 时钟源
 * @param rst_time 输出参数，复位时间枚举值
 *
 * @return 0 成功
 * @return LISA_DEVICE_ERR_RANGE 超时时间超出范围
 */
static int ms_to_rst_time(uint32_t timeout_ms, hal_driver_wdt_clk_src clk_src, hal_driver_wdt_rst_time *rst_time)
{
    uint32_t clk_freq = (clk_src == hal_driver_wdt_clk_src_32k) ? WDT_CLK_32K_HZ : WDT_CLK_APB_HZ;
    uint64_t clk_period_ns = 1000000000ULL / clk_freq;  /* 时钟周期（纳秒）*/
    uint64_t timeout_ns = (uint64_t)timeout_ms * 1000000ULL;  /* 超时时间（纳秒）*/
    uint64_t clk_count = timeout_ns / clk_period_ns;  /* 需要的时钟周期数 */

    /* 查找大于等于所需周期数的最小 2^N 值（向上取整） */
    /* 这样可以确保实际超时时间不会小于配置的时间 */
    if (clk_count <= (1ULL << 7)) {
        *rst_time = hal_driver_wdt_rst_time_7;
    } else if (clk_count <= (1ULL << 8)) {
        *rst_time = hal_driver_wdt_rst_time_8;
    } else if (clk_count <= (1ULL << 9)) {
        *rst_time = hal_driver_wdt_rst_time_9;
    } else if (clk_count <= (1ULL << 10)) {
        *rst_time = hal_driver_wdt_rst_time_10;
    } else if (clk_count <= (1ULL << 11)) {
        *rst_time = hal_driver_wdt_rst_time_11;
    } else if (clk_count <= (1ULL << 12)) {
        *rst_time = hal_driver_wdt_rst_time_12;
    } else if (clk_count <= (1ULL << 13)) {
        *rst_time = hal_driver_wdt_rst_time_13;
    } else if (clk_count <= (1ULL << 14)) {
        *rst_time = hal_driver_wdt_rst_time_14;
    } else {
        return LISA_DEVICE_ERR_RANGE;
    }

    /* 计算实际超时时间用于日志 - rst_time枚举值直接对应2^(7+枚举值) */
    int exp = 7 + (int)*rst_time;
    uint64_t actual_clk_count = (1ULL << exp);
    uint64_t actual_timeout_ms = (actual_clk_count * clk_period_ns) / 1000000ULL;
    LISA_LOGD(LOG_TAG, "ms_to_rst_time: requested=%lu ms, clk_freq=%lu Hz, clk_count=%llu, selected=rst_time_%d (2^%d=%llu cycles, ≈%llu ms)",
              timeout_ms, clk_freq, clk_count, (int)*rst_time, exp, actual_clk_count, actual_timeout_ms);

    return LISA_DEVICE_OK;
}

/* ===== ARCS平台WDT实现函数 ===== */

/**
 * @brief 配置看门狗设备
 */
static int arcs_wdt_setup(lisa_device_t *dev, const lisa_wdt_config_t *config)
{
    if (!lisa_device_is_initialized(dev) || !config) {
        return LISA_DEVICE_ERR_INVALID;
    }

    /* 验证配置参数 */
    if (config->int_timeout_ms == 0) {
        LISA_LOGE(LOG_TAG, "Invalid int_timeout_ms: %lu ms", config->int_timeout_ms);
        return LISA_DEVICE_ERR_INVALID;
    }

    lisa_wdt_priv_t *priv = (lisa_wdt_priv_t *)dev->priv_data;

    DEVICE_LOCK(priv);

    /* 如果看门狗正在运行，先停止 */
    if (priv->state == LISA_WDT_STATE_RUNNING) {
        if (WDT_Disable(priv->hal_handler) != 0) {
            DEVICE_UNLOCK(priv);
            LISA_LOGE(LOG_TAG, "Failed to disable WDT before setup");
            return LISA_DEVICE_ERR_IO;
        }
        priv->state = LISA_WDT_STATE_IDLE;
    }

    /* 保存配置 */
    priv->config = *config;

    /* 默认使用 32K 时钟源 */
    priv->clk_src = hal_driver_wdt_clk_src_32k;

    /* 计算中断时间（从启动开始） */
    if (ms_to_int_time(config->int_timeout_ms, priv->clk_src, &priv->int_time) != LISA_DEVICE_OK) {
        DEVICE_UNLOCK(priv);
        LISA_LOGE(LOG_TAG, "Invalid interrupt time for int_timeout_ms: %lu ms", config->int_timeout_ms);
        return LISA_DEVICE_ERR_RANGE;
    }

    /* 计算复位时间（从中断触发后开始计算，到系统复位） */
    /* 注意：根据HAL库注释，rst_time是复位阶段的时间，从中断触发后开始计算 */
    /* HAL库示例：int_time=15(1s), rst_time=14(0.5s)，时间线：启动->[1s]中断->[0.5s]复位 */
    if (ms_to_rst_time(config->rst_timeout_ms, priv->clk_src, &priv->rst_time) != LISA_DEVICE_OK) {
        DEVICE_UNLOCK(priv);
        LISA_LOGE(LOG_TAG, "Invalid reset time for rst_timeout_ms: %lu ms", config->rst_timeout_ms);
        return LISA_DEVICE_ERR_RANGE;
    }

    /* 确保中断回调已注册（在配置之前注册，确保配置时回调已存在） */
    /* 注意：即使没有用户回调，我们也需要注册HAL回调来更新状态 */
    if (WDT_Initialize(priv->hal_handler, wdt_hal_irq_callback, priv) != 0) {
        DEVICE_UNLOCK(priv);
        LISA_LOGE(LOG_TAG, "Failed to register WDT callback before configuration");
        return LISA_DEVICE_ERR_IO;
    }
    LISA_LOGD(LOG_TAG, "WDT callback registered: %p, workspace: %p", wdt_hal_irq_callback, priv);

    /* 配置 HAL WDT */
    hal_driver_wdt_cfg_t hal_cfg = {
        .clk_src = priv->clk_src,
        .int_time = priv->int_time,
        .rst_time = priv->rst_time,
    };

    if (WDT_Control(priv->hal_handler, &hal_cfg) != 0) {
        DEVICE_UNLOCK(priv);
        LISA_LOGE(LOG_TAG, "Failed to configure WDT");
        return LISA_DEVICE_ERR_IO;
    }
    LISA_LOGD(LOG_TAG, "WDT configured: int_time=%d, rst_time=%d", priv->int_time, priv->rst_time);

    /* 保存配置的总超时时间（用于剩余时间查询） */
    priv->configured_timeout_ms = config->int_timeout_ms;
    priv->state = LISA_WDT_STATE_IDLE;

    DEVICE_UNLOCK(priv);

    uint32_t total_rst_timeout_ms = config->int_timeout_ms + config->rst_timeout_ms;
    LISA_LOGI(LOG_TAG, "WDT configured: int_timeout=%lu ms, rst_timeout=%lu ms (total=%lu ms), clk_src=%d, int_time=%d, rst_time=%d",
              config->int_timeout_ms, config->rst_timeout_ms, total_rst_timeout_ms,
              priv->clk_src, priv->int_time, priv->rst_time);

    return LISA_DEVICE_OK;
}

/**
 * @brief 启动看门狗
 */
static int arcs_wdt_start(lisa_device_t *dev)
{
    if (!lisa_device_is_initialized(dev)) {
        return LISA_DEVICE_ERR_INVALID;
    }

    lisa_wdt_priv_t *priv = (lisa_wdt_priv_t *)dev->priv_data;

    DEVICE_LOCK(priv);

    /* 检查是否已配置 */
    if (priv->configured_timeout_ms == 0) {
        DEVICE_UNLOCK(priv);
        LISA_LOGE(LOG_TAG, "WDT not configured, call setup first");
        return LISA_DEVICE_ERR_NOT_READY;
    }

    /* 如果已经在运行，直接返回 */
    if (priv->state == LISA_WDT_STATE_RUNNING) {
        DEVICE_UNLOCK(priv);
        return LISA_DEVICE_OK;
    }

    /* 确保回调已注册（双重检查） */
    if (WDT_Initialize(priv->hal_handler, wdt_hal_irq_callback, priv) != 0) {
        DEVICE_UNLOCK(priv);
        LISA_LOGE(LOG_TAG, "Failed to register WDT callback before start");
        return LISA_DEVICE_ERR_IO;
    }

    /* 启动 HAL WDT（这会同时使能中断和复位） */
    if (WDT_Enable(priv->hal_handler) != 0) {
        DEVICE_UNLOCK(priv);
        LISA_LOGE(LOG_TAG, "Failed to enable WDT");
        return LISA_DEVICE_ERR_IO;
    }

    priv->state = LISA_WDT_STATE_RUNNING;

    DEVICE_UNLOCK(priv);

    LISA_LOGI(LOG_TAG, "WDT started with int_time=%d, rst_time=%d, callback=%p", 
              priv->int_time, priv->rst_time, wdt_hal_irq_callback);
    return LISA_DEVICE_OK;
}

/**
 * @brief 停止看门狗
 */
static int arcs_wdt_stop(lisa_device_t *dev)
{
    if (!lisa_device_is_initialized(dev)) {
        return LISA_DEVICE_ERR_INVALID;
    }

    lisa_wdt_priv_t *priv = (lisa_wdt_priv_t *)dev->priv_data;

    DEVICE_LOCK(priv);

    if (priv->state != LISA_WDT_STATE_RUNNING) {
        DEVICE_UNLOCK(priv);
        return LISA_DEVICE_OK;
    }

    /* 停止 HAL WDT */
    if (WDT_Disable(priv->hal_handler) != 0) {
        DEVICE_UNLOCK(priv);
        LISA_LOGE(LOG_TAG, "Failed to disable WDT");
        return LISA_DEVICE_ERR_IO;
    }

    priv->state = LISA_WDT_STATE_IDLE;

    DEVICE_UNLOCK(priv);

    LISA_LOGI(LOG_TAG, "WDT stopped");
    return LISA_DEVICE_OK;
}

/**
 * @brief 喂狗（重置看门狗计数器）
 */
static int arcs_wdt_feed(lisa_device_t *dev)
{
    if (!lisa_device_is_initialized(dev)) {
        return LISA_DEVICE_ERR_INVALID;
    }

    lisa_wdt_priv_t *priv = (lisa_wdt_priv_t *)dev->priv_data;

    DEVICE_LOCK(priv);

    if (priv->state != LISA_WDT_STATE_RUNNING) {
        DEVICE_UNLOCK(priv);
        LISA_LOGW(LOG_TAG, "WDT not running, feed ignored");
        return LISA_DEVICE_ERR_NOT_READY;
    }

    /* 喂狗 */
    if (WDT_Refresh(priv->hal_handler) != 0) {
        DEVICE_UNLOCK(priv);
        LISA_LOGE(LOG_TAG, "Failed to refresh WDT");
        return LISA_DEVICE_ERR_IO;
    }

    DEVICE_UNLOCK(priv);

    LISA_LOGD(LOG_TAG, "WDT fed");
    return LISA_DEVICE_OK;
}

/**
 * @brief 获取剩余时间
 */
static int arcs_wdt_get_remaining_time(lisa_device_t *dev, uint32_t *remaining_ms)
{
    if (!lisa_device_is_initialized(dev) || !remaining_ms) {
        return LISA_DEVICE_ERR_INVALID;
    }

    lisa_wdt_priv_t *priv = (lisa_wdt_priv_t *)dev->priv_data;

    DEVICE_LOCK(priv);

    if (priv->state != LISA_WDT_STATE_RUNNING) {
        DEVICE_UNLOCK(priv);
        *remaining_ms = 0;
        return LISA_DEVICE_ERR_NOT_READY;
    }

    /* ARCS WDT HAL 不支持直接读取剩余时间，返回配置的超时时间 */
    *remaining_ms = priv->configured_timeout_ms;

    DEVICE_UNLOCK(priv);

    return LISA_DEVICE_OK;
}

/**
 * @brief 获取看门狗状态
 */
static int arcs_wdt_get_state(lisa_device_t *dev, lisa_wdt_state_t *state)
{
    if (!lisa_device_is_initialized(dev) || !state) {
        return LISA_DEVICE_ERR_INVALID;
    }

    lisa_wdt_priv_t *priv = (lisa_wdt_priv_t *)dev->priv_data;

    DEVICE_LOCK(priv);
    *state = priv->state;
    DEVICE_UNLOCK(priv);

    return LISA_DEVICE_OK;
}

/**
 * @brief 设置超时回调函数
 */
static int arcs_wdt_set_callback(lisa_device_t *dev, lisa_wdt_callback_t callback, void *user_data)
{
    if (!lisa_device_is_initialized(dev)) {
        return LISA_DEVICE_ERR_INVALID;
    }

    lisa_wdt_priv_t *priv = (lisa_wdt_priv_t *)dev->priv_data;

    DEVICE_LOCK(priv);

    priv->callback = callback;
    priv->user_data = user_data;

    /* 注意：HAL回调始终注册，用于更新状态和调用用户回调 */
    /* 即使用户没有设置回调，我们也需要HAL回调来更新状态 */
    if (WDT_Initialize(priv->hal_handler, wdt_hal_irq_callback, priv) != 0) {
        DEVICE_UNLOCK(priv);
        LISA_LOGE(LOG_TAG, "Failed to update WDT callback");
        return LISA_DEVICE_ERR_IO;
    }

    DEVICE_UNLOCK(priv);

    LISA_LOGD(LOG_TAG, "WDT callback %s", callback ? "set" : "cleared");
    return LISA_DEVICE_OK;
}

/* ===== ARCS WDT API 实例 ===== */
static const lisa_wdt_api_t arcs_wdt_api = {
    .setup = arcs_wdt_setup,
    .start = arcs_wdt_start,
    .stop = arcs_wdt_stop,
    .feed = arcs_wdt_feed,
    .get_remaining_time = arcs_wdt_get_remaining_time,
    .get_state = arcs_wdt_get_state,
    .set_callback = arcs_wdt_set_callback,
};

/* ===== 设备初始化函数 ===== */

static int arcs_wdt0_init(void)
{
    /* 清空私有数据 */
    memset(&wdt0_priv, 0, sizeof(lisa_wdt_priv_t));

    /* 获取 HAL WDT 句柄 */
    wdt0_priv.hal_handler = WDT();
    if (!wdt0_priv.hal_handler) {
        LISA_LOGE(LOG_TAG, "Failed to get WDT handler");
        return LISA_DEVICE_ERR_INIT_FAIL;
    }

    /* 创建互斥锁 */
    wdt0_priv.mutex = lisa_mutex_create();
    if (!wdt0_priv.mutex) {
        LISA_LOGE(LOG_TAG, "Failed to create mutex");
        return LISA_DEVICE_ERR_INIT_FAIL;
    }

    /* 初始化 HAL WDT，注册中断回调 */
    if (WDT_Initialize(wdt0_priv.hal_handler, wdt_hal_irq_callback, &wdt0_priv) != 0) {
        LISA_LOGE(LOG_TAG, "Failed to initialize WDT");
        return LISA_DEVICE_ERR_INIT_FAIL;
    }

    /* 上电 WDT */
    if (WDT_PowerControl(wdt0_priv.hal_handler, CSK_POWER_FULL) != 0) {
        LISA_LOGE(LOG_TAG, "Failed to power on WDT");
        return LISA_DEVICE_ERR_INIT_FAIL;
    }

    wdt0_priv.state = LISA_WDT_STATE_IDLE;

    LISA_LOGI(LOG_TAG, "WDT0 initialized successfully");

    return LISA_DEVICE_OK;
}

/* ===== 设备注册 ===== */
LISA_DEVICE_REGISTER(wdt0,                        /* 设备名称 */
                     &arcs_wdt_api,               /* API指针 */
                     &wdt0_priv,                  /* 私有数据指针 */
                     NULL,                        /* 用户数据 */
                     arcs_wdt0_init,              /* 初始化函数 */
                     LISA_DEVICE_PRIORITY_NORMAL); /* 优先级 */