#include "t_safety.h"

#include <assert.h>
#include <stdio.h>
#include <string.h>

#include "hal_i2c_acct.h"
#include "hal_lock.h"
#include "hal_time.h"
#include "rail.h"
#include "rail_cfg.h"
#include "t_actuator.h"
#include "tasks.h"

/* ---- A10：两条判据 --------------------------------------------------------

   §10.3 原话：「越界**直接**操作 `EFUSE_EN` / `VBUS_EN`（GPIO 直连，不经任何
   队列或抽象层）」。所以下面这几个函数直接调 `rail_*_enable()`，不发消息给
   t_actuator —— 发消息就等于把「关电」排在了一个中优先级任务的队列后面。

   四条不能改的规矩：

   1. **判据只在放锁之后跑。** 两根 EN 线是 GPIO，和 I²C 没有关系；拿着总线锁
      去写引脚只会把别的任务多挡一会儿。而且 `t_actuator_abort()` 会去拿 595
      那把锁，拿着 I²C 锁进去就是嵌套（`hal_lock_take()` 会直接判 HAL_ERR_STATE）。

   2. **先 `t_actuator_abort()`，再断电。** 反过来有个真实的洞：硬重启的
      `HR_OFF` 状态会在 4 s 后自己把 `EFUSE_EN` 抬回去，于是「关掉的路」几秒钟
      之后又带电了。abort 之后那一路只会走收尾（只碰 595），再也够不到 EN 线。
      代价是 abort 最坏会等 595 那把锁 20 ms（`ACT_LOCK_TIMEOUT_MS`），也就是
      巡检可能丢一拍 —— 认了：SR-5 原文写着它「仅承担记录与告警，不承担实时保护」，
      真正的过压保护是 eFuse 里的硬件 OVP，不靠这条路径的延迟。

   3. **判据只在「这一路该有电」而且「这一圈的值是新鲜的」时武装。**
      关着的路电压本来就是 0，不设这一条的话每一圈都会得出「偏低 3900 mV」；
      而器件失联那一路的值是上一圈的，§10.10 明写着「保持供电，禁用该路的
      SR-5 / SW-8 判据并持续告警」。

   4. **一条判据也不许发 I²C 事务。** 判据要的三个量（设定值、两根 EN 的状态、
      正在跑的序列）全部有影子可查。多读一次就把 §10.3 那 7.8 % 的预算顶穿，
      `test_one_cycle_is_exactly_thirteen_transactions()` 会当场变红。 */

static safety_ev_fn s_sink;
static void        *s_sink_ctx;

void t_safety_set_event_sink(safety_ev_fn fn, void *ctx)
{
    s_sink = fn;
    s_sink_ctx = ctx;
}

const char *t_safety_ev_str(safety_ev_t ev)
{
    switch (ev) {
    case SAFETY_EV_NONE:
        return "无";
    case SAFETY_EV_OVER_VOLT:
        return "过压关路(SR-5)";
    case SAFETY_EV_UNDER_VOLT:
        return "欠压关路(SR-5)";
    case SAFETY_EV_REVERSE:
        return "反灌断VBUS(SW-8)";
    case SAFETY_EV_PUSHED_UP:
        return "被顶高断VBUS(SW-8)";
    default:
        return "?";
    }
}

/* 记一条。**永远在动作之后调** —— 记录慢一步没关系，断电慢一步不行。 */
static void emit(safety_snap_t *s, int rail, safety_ev_t ev, uint32_t now)
{
    const ina226_vi_t *vi = &s->rail[rail - 1];

    s->last.t_ms       = now;
    s->last.rail       = (uint8_t)rail;
    s->last.type       = (uint8_t)ev;
    s->last.bus_mv     = vi->bus_mv;
    s->last.current_ua = vi->current_ua;
    s->events++;

    if (s_sink != NULL) {
        s_sink(s_sink_ctx, &s->last); /* TODO(A11)：这里接环形缓冲 */
    }
}

/* SR-5：关这一路。**先断 VBUS 再关 eFuse** —— 只关 eFuse 的话，插着 USB 的那几路
   会停在「手机只靠 VBUS 供着电」，那既不是开也不是关（`rail_all_off()` 里同一条
   理由）。两个都要试，不因为第一个失败就不关第二个。 */
static void trip_rail(safety_snap_t *s, int rail, safety_ev_t ev, uint32_t now)
{
    t_actuator_abort(rail); /* 规矩 2：必须在断电之前 */
    (void)rail_vbus_enable(rail, false);
    (void)rail_efuse_enable(rail, false);
    emit(s, rail, ev, now);
}

/* SW-8：只断这一路的 VBUS，**不碰 eFuse** —— 反灌的能量是从 USB 那一侧来的，
   把直供也一起关掉等于「因为充电器有问题就把手机关机」，而 §10.2 的整节都在讲
   「范围可控的时候只动出事的那一处」。 */
static void cut_vbus(safety_snap_t *s, int rail, safety_ev_t ev, uint32_t now)
{
    /* 三个序列里只有 EDL 会去写 `VBUS_EN`（`EDL_EN=1 → VBUS_EN=1 → 等枚举`）。
       它正跑着的话必须打断，否则下一拍它就把 VBUS 又抬回来了。
       硬重启 / 按键不碰 VBUS，没有理由为一次反灌把它们打断。 */
    if (t_actuator_seq(rail) == ACT_SEQ_EDL) {
        t_actuator_abort(rail);
    }
    (void)rail_vbus_enable(rail, false);
    emit(s, rail, ev, now);
}

static void check_rail(safety_snap_t *s, int rail, uint32_t now)
{
    safety_rail_t *st = &s->st[rail - 1];
    const bool     en = rail_efuse_is_on(rail);

    /* `EFUSE_EN` 的上升沿：缓启动窗口从这一刻算起。 */
    if (en && !st->en_on) {
        st->en_ms = now;
    }
    st->en_on = en;

    /* 规矩 3 的三道闸。任何一道不过就把圈数清零 —— 「关着的那几秒」
       不能算进「持续 20 ms」里，不然一开机就跳闸。
       （缓启动窗口是真按毫秒算的：它对应的是 tON + 斜坡那段物理时间，
       不像「持续 20 ms」那样是在数样本。） */
    if (!en || !s->rail_ok[rail - 1] || (now - st->en_ms) < T_SAFETY_SETTLE_MS) {
        st->dev_n = 0;
        return;
    }

    const int32_t mv  = s->rail[rail - 1].bus_mv;
    const int32_t ua  = s->rail[rail - 1].current_ua;
    const int32_t dev = mv - (int32_t)rail_setpoint_mv(rail);

    /* ---- SW-8（先跑）：只在 VBUS 通着的时候武装 -------------------------
       反灌的能量只可能从 VBUS 那一侧来，断开之后判据自然就解除武装了 ——
       这也是「关掉之后不会每 20 ms 再刷一条事件」的机制。
       先跑它是因为过压这一种情况两条判据都成立：该先撤掉能量来源（VBUS），
       20 ms 后 SR-5 再决定要不要连这一路一起关掉。 */
    if (rail_vbus_is_on(rail)) {
        if (ua < T_SAFETY_REV_UA) {
            cut_vbus(s, rail, SAFETY_EV_REVERSE, now);
        } else if (dev > T_SAFETY_DEV_MV) {
            cut_vbus(s, rail, SAFETY_EV_PUSHED_UP, now);
        }
    }

    /* ---- SR-5：±100 mV 连着 T_SAFETY_DEV_HOLD_CYCLES 圈（= 持续 20 ms）---- */
    if (dev > T_SAFETY_DEV_MV || dev < -T_SAFETY_DEV_MV) {
        if (st->dev_n < 0xFF) {
            st->dev_n++;
        }
        if (st->dev_n >= T_SAFETY_DEV_HOLD_CYCLES) {
            trip_rail(s, rail, dev > 0 ? SAFETY_EV_OVER_VOLT : SAFETY_EV_UNDER_VOLT, now);
            /* ⚠️ 这里**故意不**把 `dev_n` 清零。关掉之后下一圈 `en` 就是 false，
               上面那道闸自己会清；而万一那次写引脚失败了（影子留在 on），
               下一圈 `dev_n` 已经够数，会**立刻再关一次** —— 清零的话得再等两圈。
               关电路径上「重试快一点」永远是对的那一边。 */
        }
    } else {
        st->dev_n = 0; /* 「持续」的意思是连续，中间回到范围内就从头数 */
    }
}

void t_safety_init(safety_snap_t *s)
{
    assert(s != NULL);
    memset(s, 0, sizeof(*s));
    /* 游标对齐到「现在」，否则第一圈会把启动期间（器件初始化）的事务算进来。 */
    s->bus_cursor = hal_i2c_acct_bits();
}

hal_err_t t_safety_step(safety_snap_t *s)
{
    assert(s != NULL);
    s->cycles++;

    hal_err_t err = hal_lock_take(HAL_LOCK_I2C, T_SAFETY_LOCK_TIMEOUT_MS);
    if (err != HAL_OK) {
        /* 规矩 1：不死等。这一圈作废，20 ms 后重来。 */
        s->skipped++;
        s->bus_us = hal_i2c_acct_window_us(&s->bus_cursor);
        return err;
    }

    hal_err_t first = HAL_OK;

    /* 五路 —— 地址查表，**不许算**（rail_cfg.h 那条禁令）。 */
    for (int rail = 1; rail <= PHONERAIL_RAIL_COUNT; rail++) {
        ina226_vi_t vi;
        const hal_err_t e = ina226_read_vi(rail_cfg(rail)->ina_addr, &vi);
        s->rail_ok[rail - 1] = (e == HAL_OK);
        if (e == HAL_OK) {
            s->rail[rail - 1] = vi; /* 规矩 2：失败就留着上一圈的值，别清零 */
        } else {
            s->i2c_errors++;
            if (first == HAL_OK) {
                first = e;
            }
        }
    }

    /* 第六片：输入侧。 */
    {
        ina226_vi_t vi;
        const hal_err_t e = ina226_read_vi(INA226_ADDR_INPUT, &vi);
        s->input_ok = (e == HAL_OK);
        if (e == HAL_OK) {
            s->input = vi;
        } else {
            s->i2c_errors++;
            if (first == HAL_OK) {
                first = e;
            }
        }
    }

    /* PCA9555 的两个输入端口一次事务读完（自增指针）。 */
    {
        pca9555_in_t in;
        const hal_err_t e = pca9555_read_inputs(&in);
        s->io_ok = (e == HAL_OK);
        if (e == HAL_OK) {
            s->io = in;
        } else {
            s->i2c_errors++;
            if (first == HAL_OK) {
                first = e;
            }
        }
    }

    hal_lock_give(HAL_LOCK_I2C);

    /* 判据：放锁之后跑，直接写 EFUSE_EN / VBUS_EN（上面那四条规矩）。
       `now` 只取一次 —— 五路要拿同一个时刻去算「持续了多久」。 */
    {
        const uint32_t now = hal_time_now_ms();
        for (int rail = 1; rail <= PHONERAIL_RAIL_COUNT; rail++) {
            check_rail(s, rail, now);
        }
    }

    s->bus_us = hal_i2c_acct_window_us(&s->bus_cursor);
    return first;
}

uint32_t t_safety_budget_us(void)
{
    /* 上面那一圈真正发出去的事务，逐条数：
         6 片 INA226 × 2 次寄存器读（母线电压 + 电流）
         1 次 PCA9555 读（一次事务读回两个输入端口）
       每次都是「写 1 字节寄存器号 + 读 2 字节」的形状。 */
    const uint32_t txns = INA226_COUNT * 2u + 1u;
    return (uint32_t)hal_i2c_bits_to_us((uint64_t)txns * hal_i2c_txn_bits(1, 2));
}

uint32_t t_safety_load_permille(uint32_t bus_us, uint32_t period_ms)
{
    if (period_ms == 0) {
        return 0;
    }
    return (uint32_t)(((uint64_t)bus_us * 1000ull) / ((uint64_t)period_ms * 1000ull));
}

int t_safety_format(const safety_snap_t *s, char *buf, size_t len)
{
    assert(s != NULL && buf != NULL && len > 0);
    const uint32_t period = task_desc(TASK_SAFETY)->period_ms;
    const uint32_t pm = t_safety_load_permille(s->bus_us, period);
    return snprintf(buf, len,
                    "t_safety: cycles=%u skipped=%u i2c_err=%u bus=%u us/%u ms load=%u.%u%% "
                    "events=%u",
                    (unsigned)s->cycles, (unsigned)s->skipped, (unsigned)s->i2c_errors,
                    (unsigned)s->bus_us, (unsigned)period, (unsigned)(pm / 10u),
                    (unsigned)(pm % 10u), (unsigned)s->events);
}