/* 网络配置与状态。契约（尤其「密码永不外泄」与跨任务那两段）在 netcfg.h。 */
#include "netcfg.h"

#include <string.h>

#include "hal_lock.h"

static netcfg_t          s_cfg;
static netcfg_save_fn    s_save;
static netcfg_changed_fn s_changed;
static void             *s_ctx;
static net_status_t      s_st;

void netcfg_init(const netcfg_t *loaded, netcfg_save_fn save, netcfg_changed_fn changed, void *ctx)
{
    hal_crit_enter();
    memset(&s_cfg, 0, sizeof(s_cfg));
    if (loaded != NULL) {
        s_cfg = *loaded;
    }
    /* 从 flash 读回来的东西不可信：强制收尾，免得一个没带 0 的字段把后面的读穿；
       空位挤到末尾（「有效的就是 [0, n)」是 count / 轮换的前提）。 */
    int n = 0;
    for (int i = 0; i < NETCFG_WIFI_N; i++) {
        netcfg_wifi_t w = s_cfg.wifi[i];
        w.ssid[NETCFG_SSID_MAX] = '\0';
        w.pass[NETCFG_PASS_MAX] = '\0';
        if (w.ssid[0] != '\0') {
            s_cfg.wifi[n++] = w;
        }
    }
    for (int i = n; i < NETCFG_WIFI_N; i++) {
        memset(&s_cfg.wifi[i], 0, sizeof(s_cfg.wifi[i]));
    }
    s_cfg.uri[NETCFG_URI_MAX] = '\0';
    s_cfg.user[NETCFG_USER_MAX] = '\0';
    s_cfg.mpass[NETCFG_MPASS_MAX] = '\0';
    if (s_cfg.tele_ms < NETCFG_TELE_MIN_MS || s_cfg.tele_ms > NETCFG_TELE_MAX_MS) {
        s_cfg.tele_ms = NETCFG_TELE_DEFAULT_MS;
    }
    memset(&s_st, 0, sizeof(s_st));
    hal_crit_exit();
    s_save = save;
    s_changed = changed;
    s_ctx = ctx;
}

void netcfg_get(netcfg_t *out)
{
    hal_crit_enter();
    *out = s_cfg;
    hal_crit_exit();
}

static bool len_in(const char *s, size_t lo, size_t hi)
{
    if (s == NULL) {
        return false;
    }
    const size_t n = strlen(s);
    return n >= lo && n <= hi;
}

bool netcfg_wifi_ok(const char *ssid, const char *pass)
{
    /* 口令：空（开放网络）或 8~63 —— WPA2 的规定。7 位的口令驱动会静默连不上，
       现象是「一直在连」，在这里拒掉比在那里猜强。 */
    return len_in(ssid, 1, NETCFG_SSID_MAX) &&
           (len_in(pass, 0, 0) || len_in(pass, 8, NETCFG_PASS_MAX));
}

bool netcfg_mqtt_ok(const char *uri, const char *user, const char *mpass, uint32_t tele_ms)
{
    if (!len_in(uri, 8, NETCFG_URI_MAX) || !len_in(user, 0, NETCFG_USER_MAX) ||
        !len_in(mpass, 0, NETCFG_MPASS_MAX)) {
        return false;
    }
    /* mqtts://（TLS，CA 编在固件里，mlink_esp.c）或明文 mqtt://（只该用在局域网里）。
       板子与服务器不在同一个局域网时只能走公网，那就必须是 mqtts。 */
    const size_t head = (strncmp(uri, "mqtts://", 8) == 0) ? 8 : (strncmp(uri, "mqtt://", 7) == 0) ? 7 : 0;
    if (head == 0 || uri[head] == '\0') {
        return false;
    }
    return tele_ms == 0 || (tele_ms >= NETCFG_TELE_MIN_MS && tele_ms <= NETCFG_TELE_MAX_MS);
}

static hal_err_t commit(const netcfg_t *next)
{
    if (s_save != NULL) {
        const hal_err_t e = s_save(s_ctx, next);
        if (e != HAL_OK) {
            return e; /* 没存下就不改内存：重启之后与现在一致，比「现在生效、重启回滚」好查 */
        }
    }
    hal_crit_enter();
    s_cfg = *next;
    hal_crit_exit();
    if (s_changed != NULL) {
        s_changed(s_ctx);
    }
    return HAL_OK;
}

int netcfg_wifi_count(const netcfg_t *cfg)
{
    int n = 0;
    while (n < NETCFG_WIFI_N && cfg->wifi[n].ssid[0] != '\0') {
        n++;
    }
    return n;
}

int netcfg_wifi_find(const netcfg_t *cfg, const char *ssid)
{
    for (int i = 0; i < netcfg_wifi_count(cfg); i++) {
        if (strcmp(cfg->wifi[i].ssid, ssid) == 0) {
            return i;
        }
    }
    return -1;
}

hal_err_t netcfg_set_wifi(const char *ssid, const char *pass)
{
    if (!netcfg_wifi_ok(ssid, pass)) {
        return HAL_ERR_ARG;
    }
    netcfg_t next;
    netcfg_get(&next);
    int i = netcfg_wifi_find(&next, ssid);
    if (i < 0) {
        i = netcfg_wifi_count(&next);
        if (i >= NETCFG_WIFI_N) {
            return HAL_ERR_STATE; /* 满了：先删一组。不悄悄挤掉最老的 —— 那可能正是唯一连得上的 */
        }
    }
    memset(&next.wifi[i], 0, sizeof(next.wifi[i]));
    strcpy(next.wifi[i].ssid, ssid);
    strcpy(next.wifi[i].pass, pass);
    return commit(&next);
}

hal_err_t netcfg_del_wifi(const char *ssid)
{
    netcfg_t next;
    netcfg_get(&next);
    const int i = ssid != NULL ? netcfg_wifi_find(&next, ssid) : -1;
    if (i < 0) {
        return HAL_ERR_ARG;
    }
    const int n = netcfg_wifi_count(&next);
    memmove(&next.wifi[i], &next.wifi[i + 1], (size_t)(n - 1 - i) * sizeof(next.wifi[0]));
    memset(&next.wifi[n - 1], 0, sizeof(next.wifi[0]));
    return commit(&next);
}

hal_err_t netcfg_set_mqtt(const char *uri, const char *user, const char *mpass, uint32_t tele_ms)
{
    if (!netcfg_mqtt_ok(uri, user, mpass, tele_ms)) {
        return HAL_ERR_ARG;
    }
    netcfg_t next;
    netcfg_get(&next);
    memset(next.uri, 0, sizeof(next.uri));
    memset(next.user, 0, sizeof(next.user));
    memset(next.mpass, 0, sizeof(next.mpass));
    strcpy(next.uri, uri);
    strcpy(next.user, user);
    strcpy(next.mpass, mpass);
    next.tele_ms = tele_ms ? tele_ms : NETCFG_TELE_DEFAULT_MS;
    return commit(&next);
}

void net_status_set(const net_status_t *st)
{
    hal_crit_enter();
    s_st = *st;
    hal_crit_exit();
}

void net_status_get(net_status_t *st)
{
    hal_crit_enter();
    *st = s_st;
    hal_crit_exit();
}

const char *net_state_str(net_state_t s)
{
    switch (s) {
    case NET_OFF:        return "off";
    case NET_CONNECTING: return "connecting";
    case NET_UP:         return "up";
    }
    return "?";
}