/* meow_media.c — MeowOS 媒体会话注册表（阶段 D · 附录 B / D1）。
 *
 * 实现说明见 meow_media.h。自包含：仅依赖 meow_ipc.h 结构 + <time.h>（monotonic）+
 * <string.h>/<stdarg.h>；发送/日志经 meow_media_ops 注入，宿主可单测。
 */
#include "meow_media.h"
#include <string.h>
#include <stdio.h>
#include <stdarg.h>
#include <time.h>

static const meow_media_ops *g_ops = NULL;
static meow_media_session_t  g_sess[MEOW_MEDIA_MAX];
static uint64_t              g_seq = 0;   /* 全局活跃净序（每次 META +1，严格区分先后） */


/* 单调毫秒（self-contained；launcher/main_menu 的 now_ms 与此同源 CLOCK_MONOTONIC）。 */
static uint64_t media_now_ms(void)
{
    struct timespec ts;
    if (clock_gettime(CLOCK_MONOTONIC, &ts) != 0) ts.tv_sec = ts.tv_nsec = 0;
    return (uint64_t)ts.tv_sec * 1000u + (uint64_t)(ts.tv_nsec / 1000000u);
}

static void media_log(const char *fmt, ...)
{
    if (!g_ops || !g_ops->log) return;
    char buf[256];
    va_list ap;
    va_start(ap, fmt);
    vsnprintf(buf, sizeof buf, fmt, ap);
    va_end(ap);
    g_ops->log("%s", buf);
}

static char *media_cp(char *dst, size_t dstsz, const char *src)
{
    if (!dst || dstsz == 0) return dst;
    if (!src) src = "";
    snprintf(dst, dstsz, "%s", src);
    dst[dstsz - 1] = 0;
    return dst;
}

void meow_media_init(const meow_media_ops *ops)
{
    g_ops = ops;
}

static meow_media_session_t *sess_find(const char *app_id)
{
    if (!app_id || !app_id[0]) return NULL;
    for (int i = 0; i < MEOW_MEDIA_MAX; i++)
        if (g_sess[i].used && strcmp(g_sess[i].app_id, app_id) == 0)
            return &g_sess[i];
    return NULL;
}

/* 找空槽；满时覆盖最旧槽（LRU 式，防单源漂移占满）。 */
static meow_media_session_t *sess_alloc(void)
{
    int slot = -1;
    uint64_t oldest = UINT64_MAX;
    for (int i = 0; i < MEOW_MEDIA_MAX; i++) {
        if (!g_sess[i].used) return &g_sess[i];
        if (g_sess[i].last_active_ms < oldest) { oldest = g_sess[i].last_active_ms; slot = i; }
    }
    if (slot >= 0) {
        media_log("media: sessions full, evict app=%s", g_sess[slot].app_id);
        memset(&g_sess[slot], 0, sizeof g_sess[slot]);
        return &g_sess[slot];
    }
    return NULL;
}

int meow_media_meta(const m_meta_t *m, int fd)
{
    if (!m || !m->app_id[0]) return -1;
    meow_media_session_t *s = sess_find(m->app_id);
    if (!s) {
        s = sess_alloc();
        if (!s) { media_log("media: meta drop app=%s (no slot)", m->app_id); return -1; }
        s->used = 1;
        media_cp(s->app_id, sizeof s->app_id, m->app_id);
    }
    s->fd = fd;
    s->last_active_ms = media_now_ms();
    s->active_seq = ++g_seq;         /* 严格递增：跨会话先后唯一，不受时钟粒度影响 */
    s->state = m->state;
    s->pos_ms = m->pos_ms;
    s->dur_ms = m->dur_ms;
    s->flags = m->flags;
    media_cp(s->title,   sizeof s->title,   m->title);
    media_cp(s->artist,  sizeof s->artist,  m->artist);
    media_cp(s->album,   sizeof s->album,   m->album);
    media_cp(s->artwork, sizeof s->artwork, m->artwork);
    media_cp(s->lyric,   sizeof s->lyric,   m->lyric);
    media_log("media: META app=%s fd=%d state=%u pos=%u/%u title=\"%s\"",
              s->app_id, fd, s->state, s->pos_ms, s->dur_ms, s->title);
    return 0;
}

const meow_media_session_t *meow_media_current(void)
{
    /* 最近活跃 = active_seq 最大者（严格先后；last_active_ms 仅作进度推进用）。 */
    const meow_media_session_t *best = NULL;
    uint64_t t = 0;
    for (int i = 0; i < MEOW_MEDIA_MAX; i++) {
        if (g_sess[i].used && g_sess[i].active_seq >= t) {
            t = g_sess[i].active_seq;
            best = &g_sess[i];
        }
    }
    return best;
}

int meow_media_has_source(void)
{
    const meow_media_session_t *s = meow_media_current();
    return (s && s->state != MEOW_MEDIA_STOPPED) ? 1 : 0;
}

int meow_media_app_playing(const char *app_id)
{
    const meow_media_session_t *s = meow_media_current();
    if (!s || !app_id || !app_id[0]) return 0;
    return (s->state == MEOW_MEDIA_PLAYING && strcmp(s->app_id, app_id) == 0) ? 1 : 0;
}

int meow_media_app_resident(const char *app_id)
{
    const meow_media_session_t *s = sess_find(app_id);
    return (s && s->state != MEOW_MEDIA_STOPPED) ? 1 : 0;
}

static int send_playctl(const meow_media_session_t *s, uint32_t cmd, int64_t seek_ms)
{
    if (!s || !s->used || !g_ops || !g_ops->send) return -1;
    m_playctl_t c;
    memset(&c, 0, sizeof c);
    c.cmd = cmd;
    c.seek_ms = seek_ms;
    size_t n = g_ops->send(s->fd, MSG_PLAYCTL, 0, &c, sizeof c);
    media_log("media: PLAYCTL -> %s cmd=%u seek=%lld n=%zu",
              s->app_id, cmd, (long long)seek_ms, n);
    /* ops->send 返回写入总字节（16B 头 + 负载）；成功 = 完整帧已写出。 */
    return (n >= MEOW_IPC_HDR_LEN + sizeof c) ? 0 : -1;
}

int meow_media_playctl(uint32_t cmd, int64_t seek_ms)
{
    return send_playctl(meow_media_current(), cmd, seek_ms);
}

int meow_media_playctl_to(const char *app_id, uint32_t cmd, int64_t seek_ms)
{
    meow_media_session_t *s = sess_find(app_id);
    return s ? send_playctl(s, cmd, seek_ms) : -1;
}

void meow_media_clear(const char *app_id)
{
    int n = 0;
    for (int i = 0; i < MEOW_MEDIA_MAX; i++) {
        if (g_sess[i].used &&
            (!app_id || !app_id[0] || strcmp(g_sess[i].app_id, app_id) == 0)) {
            media_log("media: clear app=%s", g_sess[i].app_id);
            memset(&g_sess[i], 0, sizeof g_sess[i]);
            n++;
        }
    }
    if (app_id && app_id[0]) media_log("media: cleared %d sess for %s", n, app_id);
    else if (n) media_log("media: cleared all %d sess", n);
}

void meow_media_tick(void)
{
    uint64_t now = media_now_ms();
    for (int i = 0; i < MEOW_MEDIA_MAX; i++) {
        if (!g_sess[i].used) continue;
        if (g_sess[i].state == MEOW_MEDIA_PLAYING || g_sess[i].state == MEOW_MEDIA_BUFFER) {
            if (now - g_sess[i].last_active_ms > MEOW_MEDIA_STALE_MS) {
                media_log("media: stale source %s (no META %llu ms) -> clear",
                          g_sess[i].app_id,
                          (unsigned long long)(now - g_sess[i].last_active_ms));
                memset(&g_sess[i], 0, sizeof g_sess[i]);
            }
        }
    }
}

uint32_t meow_media_display_pos(const meow_media_session_t *s)
{
    if (!s) return 0;
    uint32_t p = s->pos_ms;
    if (s->state == MEOW_MEDIA_PLAYING) {
        uint64_t now = media_now_ms();
        uint64_t el = (now > s->last_active_ms) ? (now - s->last_active_ms) : 0;
        uint32_t adv = (el > 0xFFFFFFFFull) ? 0xFFFFFFFFu : (uint32_t)el;
        p = s->pos_ms + adv;
        if (s->dur_ms && p > s->dur_ms) p = s->dur_ms;
    }
    return p;
}

/* 把一帧歌词分片写入会话缓冲（kind=0 lrc / kind=1 tlrc）。含分片边界截断（不越界）。
 * 返回 0=写入；-1=参数非法。 */
static int lyric_put(meow_media_session_t *s, const m_lyric_t *l)
{
    if (!s || !l) return -1;
    char *buf;
    uint32_t cap;
    uint32_t *lenp;
    if (l->kind == 0)      { buf = s->lyric_lrc;  cap = MEOW_MEDIA_LRC_MAX;  lenp = &s->lyric_lrc_len; }
    else if (l->kind == 1) { buf = s->lyric_tlrc; cap = MEOW_MEDIA_TLRC_MAX; lenp = &s->lyric_tlrc_len; }
    else return -1;
    uint32_t off = l->off, n = l->len;
    if (off >= cap) { off = cap; n = 0; }                 /* 起始越界：整片丢弃 */
    if (n > cap - off) n = cap - off;                     /* 末段越界：截断到缓冲上限 */
    if (n) memcpy(buf + off, l->data, n);
    buf[off + n] = 0;                                     /* 恒 NUL 结尾（供字符串读取） */
    uint32_t end = off + n;
    if (end > *lenp) *lenp = end;
    return 0;
}

int meow_media_lyric(const m_lyric_t *l)
{
    if (!l || !l->app_id[0]) return -1;
    meow_media_session_t *s = sess_find(l->app_id);
    if (!s) {
        /* 会话须先经 META 注册（否则 fd=0，PLAYCTL 会误发到 0 号描述符）；丢弃。 */
        media_log("media: lyric drop app=%s (no session; report META first)", l->app_id);
        return -1;
    }
    /* 新代际（换歌/换词）：清旧词缓冲，重开分片写入。 */
    if (l->seq != s->lyric_seq) {
        s->lyric_seq = l->seq;
        s->lyric_lrc_len = 0;
        s->lyric_tlrc_len = 0;
        s->lyric_lrc[0] = 0;
        s->lyric_tlrc[0] = 0;
    }
    lyric_put(s, l);
    media_log("media: LYRIC app=%s seq=%u kind=%u total=%u off=%u len=%u lrc=%u tlrc=%u",
              s->app_id, l->seq, l->kind, l->total, l->off, l->len,
              s->lyric_lrc_len, s->lyric_tlrc_len);
    return 0;
}

int meow_media_lyric_valid(const meow_media_session_t *s)
{
    return (s && s->used && s->lyric_lrc_len > 0) ? 1 : 0;
}

const char *meow_media_lyric_lrc(const meow_media_session_t *s)
{
    return (s && s->used) ? s->lyric_lrc : "";
}

const char *meow_media_lyric_tlrc(const meow_media_session_t *s)
{
    return (s && s->used) ? s->lyric_tlrc : "";
}

void meow_media_dump(const char *prefix)
{
    for (int i = 0; i < MEOW_MEDIA_MAX; i++) {
        if (!g_sess[i].used) continue;
        media_log("%s sess%d app=%s state=%u fd=%d last=%llu pos=%u/%u title=\"%s\" lyric=%u",
                  prefix ? prefix : "media", i, g_sess[i].app_id, g_sess[i].state,
                  g_sess[i].fd, (unsigned long long)g_sess[i].last_active_ms,
                  g_sess[i].pos_ms, g_sess[i].dur_ms, g_sess[i].title,
                  (unsigned)(g_sess[i].lyric_lrc_len > 0 ? 1 : 0));
    }
}