/*
 * meow_lyric.c — SDK 通用歌词组件实现（见 meow_lyric.h 的契约说明）。
 *
 * 本 TU 为 ncm_app/app/logic/lyric.c（解析/清空/查询）+ player.c 的 lyr_wrap_lines（折行）的
 * 通用化上收：去掉 ncm 特有命名（NCM_LYRIC_LINES / LRC_MAX_TEXT / lyrical 前缀），改用
 * meow_lyric_* 前缀与 SDK 命名；行上限由编译期宏变为「静态硬上限 + 运行时可配置」；
 * 时间戳存储用 int64_t（跨 32/64 位宿主一致）；宽测量由使用方注入回调（不解耦渲染层）。
 * 逻辑（LRC 时间标签解析、时间升序排序、翻译按 timestamp 合并、字面 \n 当换行、
 * 流式有界、超宽折行中西文混排）与 ncm 逐行保持一致；改动仅限命名/接口/上限可配。
 *
 * 线程安全：单把 pthread 互斥锁（函数级，写侧整段持锁、读侧每次持锁，无嵌套；
 * 内部清空/解析用 nolock 私有版避免自锁死）。与 ncm lyric.c 的机制完全相同。
 *
 * 内存纪律：静态存储（行数组 + 文本缓冲）零 malloc；仅 meow_lyric_parse 排序时在**堆**上
 * 申请瞬态索引/拷贝数组（ncm 实测：600 行×192 字节的临时数组若放栈会占 ~227KB，超出后台
 * 线程 128KB 栈 → 栈溢出 SIGSEGV；放堆按 s_n 计、用后即 free）。任一 malloc 失败保留未排序
 * （不崩，查询仍可用）。
 */
#include "meow_lyric.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>

/* ---- 运行时状态（静态，解析/查询全程零 malloc；仅排序时瞬态堆）---- */
static int64_t s_t[MEOW_LYRIC_LINES_MAX];                 /* 每行时间戳(ms) */
static char    s_txt[MEOW_LYRIC_LINES_MAX][MEOW_LYRIC_TEXT_MAX];   /* 原文 */
static char    s_tl[MEOW_LYRIC_LINES_MAX][MEOW_LYRIC_TEXT_MAX];    /* 翻译 */
static int     s_n = 0;                                   /* 有效行数 */
static int     g_max_lines = MEOW_LYRIC_LINES_MAX;        /* 运行时可配行上限（默认 600） */
static pthread_mutex_t g_lyric_mu = PTHREAD_MUTEX_INITIALIZER;

/* 清空（nolock，内部用；调用方须已持锁）。 */
static void meow_lyric_clear_nolock(void)
{
    s_n = 0;
    memset(s_t,   0, sizeof(s_t));
    memset(s_txt, 0, sizeof(s_txt));
    memset(s_tl,  0, sizeof(s_tl));
}

/* 复制一行歌词正文 n 字节到 dst，把「字面反斜杠 n/r」序列（服务器用 \n 把多行文本塞进一行，
 * 字面 \n 渲染成豆腐块/凌乱）替换为空格；顺带把 \r\n / \n\r 折叠为单空格。有界 ≤max。
 * 语义与 ncm copy_lrc_text 一致。 */
static void meow_lyric_copy_text(char *dst, const char *src, size_t n, size_t max)
{
    size_t oi = 0, si = 0;
    while (si < n && oi < max - 1) {
        if (src[si] == '\\' && si + 1 < n && (src[si + 1] == 'n' || src[si + 1] == 'r')) {
            dst[oi++] = ' ';
            si += 2;
            /* \r\n / \n\r 成对 → 只留一个空格（跳过紧随的互补转义，防双空格） */
            if (si + 1 < n && src[si] == '\\' &&
                ((src[si + 1] == 'r' && src[si - 1] == 'n') ||
                 (src[si + 1] == 'n' && src[si - 1] == 'r')))
                si += 2;
        } else {
            dst[oi++] = src[si++];
        }
    }
    dst[oi] = 0;
}

/* 解析单个 [mm:ss.ff] 时间标签为毫秒。返回 1=合法时间标签（*out_ms、*next=']' 之后）；
 * 0=非时间标签（*next=']' 之后；NULL=无闭合 ']'，调用方按残缺处理）。
 * 小数位自适应：1 位=0.1s(×100)、2 位=0.01s(×10，标准 LRC 厘秒)、3 位=0.001s(×1，
 * 网易云 LRC 毫秒)、>3 位截断到毫秒。 */
static int meow_lyric_parse_tag(const char *p, int64_t *out_ms, const char **next)
{
    const char *q = p + 1;                 /* 跳过 '[' */
    int m = 0, md = 0, s = 0, sd = 0;
    while (*q >= '0' && *q <= '9') { m = m * 10 + (*q - '0'); md++; q++; }
    if (md == 0 || *q != ':') goto notime;
    q++;
    while (*q >= '0' && *q <= '9') { s = s * 10 + (*q - '0'); sd++; q++; }
    if (sd == 0) goto notime;
    long frac = 0; int fd = 0; long scale = 10;
    if (*q == '.') {
        q++;
        while (*q >= '0' && *q <= '9') { frac = frac * 10 + (*q - '0'); fd++; q++; }
        if (fd == 1) scale = 100;
        else if (fd == 2) scale = 10;
        else if (fd >= 3) { scale = 1; while (fd > 3) { frac /= 10; fd--; } }  /* >3 位截断到 ms */
        else scale = 0;                    /* 孤立 '.' 无数字：忽略小数 */
    }
    if (*q != ']') goto notime;
    *out_ms = (int64_t)m * 60000L + (int64_t)s * 1000L + frac * scale;
    *next = q + 1;
    return 1;
notime:
    {
        const char *r = strchr(p, ']');
        *next = r ? r + 1 : NULL;
        return 0;
    }
}

/* 解析一批 LRC 行（原文 is_trans=0 / 翻译 is_trans=1）。翻译按 first_ms 匹配到已有原文行合并。
 * 行上限取 g_max_lines；超出的原文行丢弃。不持锁（调用方已持锁）。 */
static void meow_lyric_parse_lines(const char *lrc, int is_trans)
{
    if (!lrc) return;
    const char *p = lrc;
    while (*p) {
        while (*p && *p != '[') p++;
        if (!*p) break;
        /* 解析一个或多个时间标签 */
        int have = 0;
        int64_t first_ms = 0;
        while (*p == '[') {
            int64_t ms;
            const char *after;
            if (meow_lyric_parse_tag(p, &ms, &after)) {
                if (!have) { first_ms = ms; have = 1; }
                p = after;
            } else {
                /* 非时间标签（[ti:..] 等）——跳到行尾 */
                if (!after) return;        /* 无闭合 ']'：残缺文件 */
                p = after;
                break;
            }
        }
        if (have) {
            /* 正文 = 到行尾（去 \r\n） */
            const char *e = p;
            while (*e && *e != '\n' && *e != '\r') e++;
            size_t len = (size_t)(e - p);
            if (len > MEOW_LYRIC_TEXT_MAX - 1) len = MEOW_LYRIC_TEXT_MAX - 1;
            if (is_trans) {
                /* 翻译行：按 first_ms 匹配到已有原文行 */
                for (int i = 0; i < s_n; i++) {
                    if (s_t[i] == first_ms) {
                        meow_lyric_copy_text(s_tl[i], p, len, MEOW_LYRIC_TEXT_MAX);
                        break;
                    }
                }
            } else {
                if (s_n < g_max_lines) {
                    s_t[s_n] = first_ms;
                    meow_lyric_copy_text(s_txt[s_n], p, len, MEOW_LYRIC_TEXT_MAX);
                    s_tl[s_n][0] = 0;
                    s_n++;
                }
            }
        }
        while (*p && *p != '\n') p++;      /* 跳到下一行 */
        if (*p == '\n') p++;
    }
}

/* qsort 比较：按时间戳升序（用索引数组。s_t 为静态数组，比较器直接读它）。 */
static int meow_lyric_cmp(const void *a, const void *b)
{
    const int *ia = (const int *)a, *ib = (const int *)b;
    if (s_t[*ia] < s_t[*ib]) return -1;
    if (s_t[*ia] > s_t[*ib]) return 1;
    return 0;
}

/* 折行宽测量的兜底：字节数近似（仅当使用方未注入 width 时；非像素精确）。
 * 保证 meow_lyric_wrap 在无渲染引擎下仍行为确定（maxw 作字节预算，仍按中西文断行）。 */
static int meow_lyric_default_width(const char *u, int size, void *ctx)
{
    (void)size; (void)ctx;
    return (int)strlen(u);
}

void meow_lyric_clear(void)
{
    pthread_mutex_lock(&g_lyric_mu);
    meow_lyric_clear_nolock();
    pthread_mutex_unlock(&g_lyric_mu);
}

int meow_lyric_parse(const char *lrc, const char *tlrc)
{
    pthread_mutex_lock(&g_lyric_mu);
    meow_lyric_clear_nolock();
    meow_lyric_parse_lines(lrc, 0);
    meow_lyric_parse_lines(tlrc, 1);
    /* 按时间排序（用索引数组）。临时数组放**堆**上：`char [600][192]`×2 + `int64[600]`
     * 若放栈会占 ~227KB，超过后台线程 128KB 栈 → 栈溢出 SIGSEGV。堆上按 s_n 计
     * （≤600 行），峰值 ~230KB 瞬态、用后即 free。 */
    if (s_n > 0) {
        int *idx = (int *)malloc(sizeof(int) * (size_t)s_n);
        int64_t *ttmp = (int64_t *)malloc(sizeof(int64_t) * (size_t)s_n);
        char (*txt)[MEOW_LYRIC_TEXT_MAX] =
            (char (*)[MEOW_LYRIC_TEXT_MAX])malloc((size_t)MEOW_LYRIC_TEXT_MAX * (size_t)s_n);
        char (*tl)[MEOW_LYRIC_TEXT_MAX] =
            (char (*)[MEOW_LYRIC_TEXT_MAX])malloc((size_t)MEOW_LYRIC_TEXT_MAX * (size_t)s_n);
        if (idx && ttmp && txt && tl) {
            for (int i = 0; i < s_n; i++) idx[i] = i;
            qsort(idx, (size_t)s_n, sizeof(int), meow_lyric_cmp);
            memcpy(ttmp, s_t, sizeof(int64_t) * (size_t)s_n);
            memcpy(txt, s_txt, (size_t)MEOW_LYRIC_TEXT_MAX * (size_t)s_n);
            memcpy(tl,  s_tl,  (size_t)MEOW_LYRIC_TEXT_MAX * (size_t)s_n);
            for (int i = 0; i < s_n; i++) {
                s_t[i] = ttmp[idx[i]];
                memcpy(s_txt[i], txt[idx[i]], (size_t)MEOW_LYRIC_TEXT_MAX);
                memcpy(s_tl[i],  tl[idx[i]],  (size_t)MEOW_LYRIC_TEXT_MAX);
            }
        }
        free(idx); free(ttmp); free(txt); free(tl);   /* 任一 malloc 失败：保留未排序（不崩） */
    }
    int result = s_n;
    pthread_mutex_unlock(&g_lyric_mu);
    return result;
}

int meow_lyric_count(void)
{
    pthread_mutex_lock(&g_lyric_mu);
    int n = s_n;
    pthread_mutex_unlock(&g_lyric_mu);
    return n;
}

int meow_lyric_line_at(int64_t ms)
{
    pthread_mutex_lock(&g_lyric_mu);
    int line = 0;
    for (int i = 0; i < s_n; i++) {
        if (s_t[i] <= ms) line = i;
        else break;
    }
    pthread_mutex_unlock(&g_lyric_mu);
    return line;
}

const char *meow_lyric_line_text(int i)
{
    pthread_mutex_lock(&g_lyric_mu);
    const char *p = (i < 0 || i >= s_n) ? "" : s_txt[i];
    pthread_mutex_unlock(&g_lyric_mu);
    return p;
}

const char *meow_lyric_line_tl(int i)
{
    pthread_mutex_lock(&g_lyric_mu);
    const char *p = (i < 0 || i >= s_n) ? "" : s_tl[i];
    pthread_mutex_unlock(&g_lyric_mu);
    return p;
}

int64_t meow_lyric_line_time(int i)
{
    pthread_mutex_lock(&g_lyric_mu);
    int64_t t = (i < 0 || i >= s_n) ? -1 : s_t[i];
    pthread_mutex_unlock(&g_lyric_mu);
    return t;
}

void meow_lyric_set_max_lines(int max)
{
    pthread_mutex_lock(&g_lyric_mu);
    if (max < 1) max = 1;
    if (max > MEOW_LYRIC_LINES_MAX) max = MEOW_LYRIC_LINES_MAX;
    g_max_lines = max;
    pthread_mutex_unlock(&g_lyric_mu);
}

int meow_lyric_wrap(const char *txt, int size, int maxw,
                    char seg[][MEOW_LYRIC_SEG_SZ], int max_rows,
                    meow_lyric_width_fn width, void *ctx)
{
    meow_lyric_width_fn w = width ? width : meow_lyric_default_width;
    if (!txt || !txt[0] || !seg || max_rows <= 0) {
        if (seg) seg[0][0] = 0;
        return 1;
    }
    int n = 0;
    size_t len = strlen(txt), pos = 0;
    while (pos < len && n < max_rows) {
        size_t start = pos;
        int last_ws = -1;                 /* 本行最后一个空格（相对 start 的字节偏移） */
        int overflow = 0;
        while (pos < len) {
            unsigned char c = (unsigned char)txt[pos];
            int ch = (c < 0x80) ? 1 : (c < 0xE0) ? 2 : (c < 0xF0) ? 3 : 4;
            if (pos + (size_t)ch > len) ch = (int)(len - pos);
            size_t cand = (pos + (size_t)ch) - start;
            size_t cp = cand < MEOW_LYRIC_SEG_SZ - 1 ? cand : MEOW_LYRIC_SEG_SZ - 1;
            memcpy(seg[n], txt + start, cp); seg[n][cp] = 0;
            if (w(seg[n], size, ctx) > maxw && cand > 0) { overflow = 1; break; }
            if (txt[pos] == ' ' || txt[pos] == '\t') last_ws = (int)(pos - start);
            pos += (size_t)ch;
        }
        if (overflow) {
            size_t linelen = (last_ws > 0) ? (size_t)last_ws : (pos - start);
            if (linelen == 0) {           /* 单字符超宽（罕见）：至少放一个字符防死循环 */
                unsigned char c = (unsigned char)txt[start];
                int ch = (c < 0x80) ? 1 : (c < 0xE0) ? 2 : (c < 0xF0) ? 3 : 4;
                linelen = (size_t)ch;
            }
            size_t cp = linelen < MEOW_LYRIC_SEG_SZ - 1 ? linelen : MEOW_LYRIC_SEG_SZ - 1;
            memcpy(seg[n], txt + start, cp); seg[n][cp] = 0;
            pos = start + linelen;
            if (last_ws > 0) {
                size_t sp = start + (size_t)last_ws + 1;
                if (sp > pos) pos = sp;   /* 跳过断点后的一个空格 */
            }
            n++;
        } else {
            size_t cp = (len - start) < MEOW_LYRIC_SEG_SZ - 1 ? (len - start) : MEOW_LYRIC_SEG_SZ - 1;
            memcpy(seg[n], txt + start, cp); seg[n][cp] = 0;
            n++;
            break;
        }
    }
    if (n == 0) { seg[0][0] = 0; n = 1; }
    return n;
}