/*
 * meow_ui_gfx.c — meow_ui 渲染后端（B1.0+B1.1）。
 *
 * 独立实现：自建 fb 上下文（自 mmap /dev/fb0、自建 back_buf、自实现脏区+present），
 * 不复用 launcher 的全局 g_dirty/fb（launcher 与 app 是不同进程）。机制参考
 * MEOW_APP_SDK.md §1/§2 与 launcher 的 M2.16 无闪烁地基，代码全部独立书写。
 *
 * 抽象：所有绘制目标 = 离屏 back_buf（g_fb）；meow_ui_flush() 时单次原子
 * vsync+blit 到 fb0（真实设备），或写出 PPM 截图（宿主/qemu 离屏，MEOW_UI_DUMP）。
 */
#include "meow_ui.h"
#include "meow_ui_internal.h"
#include "meow_ui_sys.h"
#include "../meow_launcherd/meow_font.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <time.h>
#include <sys/ioctl.h>
#include <sys/mman.h>

/* 本设备实测 ioctl 号（勿与通用头交换） */
#define FBIOGET_VSCREENINFO 0x4600
#define FBIOGET_FSCREENINFO 0x4602
#define FBIO_WAITFORVSYNC   0x4620

#define FB_DEV "/dev/fb0"
#define MEOW_FONT_PNG_CARD "/usr/data/mnt/sd_0/MeowOS/fonts/default/regular/font.png"
#define MEOW_FONT_IDX_CARD "/usr/data/mnt/sd_0/MeowOS/fonts/default/regular/font.idx"
#define MEOW_FONT_PNG_SYS  "/usr/share/meowos/font/font.png"
#define MEOW_FONT_IDX_SYS  "/usr/share/meowos/font/font.idx"
/* 默认字库（卡 MeowOS/fonts/default/regular，M2.6 字重结构）与固件内置之外，launcher 会把
 * 「当前生效字体」经环境变量下发给 app（见 meow_launcherd.c launch_app / meow_font_effective_paths）：
 *   MEOW_FONT_PNG / MEOW_FONT_IDX = 绝对路径；MEOW_FONT_APP = <family> 或 "default"。
 * SDK load_font 优先读 env（匹配系统 font.file），无则回退卡默认 → 固件。 */

#define MUI_DEFAULT_W   480
#define MUI_DEFAULT_H   720

/* 脏矩形上限（超出合并为全屏） */
#define MUI_DIRTY_MAX   12

struct mu_rect { int x, y, w, h; };

/* ---- fb 上下文 ---- */
static unsigned char *g_back_buf = NULL;   /* 离屏（所有绘制目标） */
static unsigned char *g_fb_mem   = NULL;   /* 真实 mmap 帧缓冲（present 落点；NULL=离屏） */
static unsigned char *g_fb       = NULL;   /* 绘制指针 = g_back_buf */
static int g_fb_fd = -1;
static int g_xres = MUI_DEFAULT_W, g_yres = MUI_DEFAULT_H;
static int g_bpp = 16;
static int g_line = 0;                     /* 每行字节数 */
static int g_init_ok = 0;
static int g_mfont_ready = 0;

static int g_dirty[/*MUI_DIRTY_MAX*/12][4];  /* [x,y,w,h] */
static int g_ndirty = 0;
static int g_dirty_full = 1;

static char *g_dump_path = NULL;

/* ---- 状态栏「上收出屏只留提示线」（collapsed，基座）----
 * g_sbar_collapsed = 目标态（1=上收）；g_sbar_collapse_h = 当前实际上收偏移
 * （0..MUI_SBAR_H：0=完全展开，MUI_SBAR_H=内容全部上移出屏、仅留提示线）。
 * 基座让 meow_ui_statusbar_set_collapsed(on) 立即生效（true→只画提示线/内容上移）；
 * 过渡（每帧插值）留待后续代理或经 meow_ui_statusbar_animate(ms) 启用的简易线性逼近。
 * 「收合=只留提示线」占高 = MUI_SBAR_COLLAPSE_H（=MEOW_SBAR_HOTZONE_FS=4，meow_ui_sys.h），
 * 与 inset（meow_ui_statusbar_height()）/顶部下滑热区/收合渲染同口径——replaced MUI_SBAR_HINT_H。 */
static int g_sbar_collapsed = 0;            /* 目标：1=上收 */
static int g_sbar_collapse_h = 0;           /* 当前上收偏移（0..MUI_SBAR_H） */
static int g_sbar_collapse_anim_ms = 0;     /* 过渡时长（0=瞬切）；meow_ui_statusbar_animate 设置 */
static int g_sbar_collapse_from_h = 0;      /* 本次过渡起点偏移 */
static unsigned long long g_sbar_collapse_start_ms = 0;  /* 本次过渡起始（monotonic ms） */

/* ---- 字体档位（MEOW_FONT_TIER，基座存档 + 公共 get/set）----
 * launcher 按 app.json "fonts":<档> 注入 MEOW_FONT_TIER=<0|1|2>；SDK 读入并以
 * meow_font_set_tier/tier 暴露。按档装载大字库（GBK/Full）由 meow_font_reload_tier()
 * 在 meow_font.c 实现；meow_font_set_tier() 在档位变化时经 env/settings 路由到该钩子真重载。 */
static int g_font_tier = MEOW_FONT_TIER_COMMON;

/* ---- 帧率调度（A-1/A-2：从 launcher M2.16 迁入，刷新率调度归口 SDK）----
 * meow_ui_flush()/present() 的 fps 档位与自适应降档 governor。launcher 不再自带
 * 一套帧率门控；launcher 与 app 统一走这里 → 全局观感/刷新率一致。
 * 设置接口：meow_ui_set_refresh_rate()/meow_ui_set_refresh_always_max()。 */
static int g_refresh_rate_cfg = 60;            /* 配置目标档 60/30/15（上限） */
static int g_eff_rate = 60;                    /* 当前有效帧率（governor 可降档） */
static int g_refresh_always_max = 0;           /* 1=恒 max 不降档 */
static unsigned long long g_last_present_ms = 0;
static unsigned long long g_frames_presented = 0;
static unsigned long long g_present_cost_sum = 0;
static int g_present_cost_n = 0;
static int g_gov_low = 0;

/* 每档上限（refresh_always_max=1 时恒 max；0 时 governor 可在 [15,30,60] 内降/升档）。 */
static int rate_bump(int r) { return (r == 15) ? 30 : (r == 30) ? 60 : 60; }
static int rate_drop(int r) { return (r == 60) ? 30 : (r == 30) ? 15 : 15; }

/* 自适应降档 governor：统计每帧 present 耗时；连续 12 帧平均超预算 → 降一档；
 * 连续 4 批（≈48 帧）平均远低于预算 → 升一档。refresh_always_max=1 时恒 max 不降。 */
static void refresh_governor(unsigned long long cost_ms, int period)
{
    if (g_refresh_always_max || g_eff_rate <= 0) return;
    g_present_cost_sum += cost_ms; g_present_cost_n++;
    if (g_present_cost_n < 12) return;
    unsigned long long avg = g_present_cost_sum / (unsigned int)g_present_cost_n;
    if (avg > (unsigned long long)period) {
        if (g_eff_rate > 15) g_eff_rate = rate_drop(g_eff_rate);
        g_gov_low = 0;
    } else if (avg * 2 < (unsigned long long)period) {
        if (++g_gov_low >= 4) {
            int nr = rate_bump(g_eff_rate);
            if (nr <= g_refresh_rate_cfg) g_eff_rate = nr;
            g_gov_low = 0;
        }
    } else g_gov_low = 0;
    g_present_cost_sum = 0; g_present_cost_n = 0;
}

/* ---- 工具 ---- */
static uint64_t now_ms(void)
{
    struct timespec ts;
    clock_gettime(CLOCK_MONOTONIC, &ts);
    return (uint64_t)ts.tv_sec * 1000u + (uint64_t)ts.tv_nsec / 1000000u;
}

uint64_t meow_ui_time_ms(void) { return now_ms(); }

static uint16_t rgb565(uint32_t c)
{
    return (uint16_t)(((c >> 8) & 0xF800) | ((c >> 5) & 0x07E0) | ((c >> 3) & 0x001F));
}

static uint8_t ex5(uint16_t v) { return (uint8_t)(((v) << 3) | ((v) >> 2)); } /* 5→8 */
static uint8_t ex6(uint16_t v) { return (uint8_t)(((v) << 2) | ((v) >> 4)); } /* 6→8 */

static int rect_hit(int ax, int ay, int aw, int ah, int bx, int by, int bw, int bh)
{
    return ax < bx + bw && ax + aw > bx && ay < by + bh && ay + ah > by;
}

/* ================= 脏区追踪 ================= */
static void dirty_full(void) { g_dirty_full = 1; g_ndirty = 0; }
static void dirty_reset(void) { g_ndirty = 0; g_dirty_full = 0; }

static void dirty_add(int x, int y, int w, int h)
{
    if (g_dirty_full) return;
    if (w <= 0 || h <= 0) return;
    if (x < 0) { w += x; x = 0; }
    if (y < 0) { h += y; y = 0; }
    if (x >= g_xres || y >= g_yres) return;
    if (x + w > g_xres) w = g_xres - x;
    if (y + h > g_yres) h = g_yres - y;
    if (w <= 0 || h <= 0) return;
    for (int i = 0; i < g_ndirty; i++) {
        if (rect_hit(g_dirty[i][0], g_dirty[i][1], g_dirty[i][2], g_dirty[i][3], x, y, w, h)) {
            int nx1 = g_dirty[i][0] < x ? g_dirty[i][0] : x;
            int ny1 = g_dirty[i][1] < y ? g_dirty[i][1] : y;
            int nx2 = (g_dirty[i][0] + g_dirty[i][2]) > (x + w) ? (g_dirty[i][0] + g_dirty[i][2]) : (x + w);
            int ny2 = (g_dirty[i][1] + g_dirty[i][3]) > (y + h) ? (g_dirty[i][1] + g_dirty[i][3]) : (y + h);
            g_dirty[i][0] = nx1; g_dirty[i][1] = ny1;
            g_dirty[i][2] = nx2 - nx1; g_dirty[i][3] = ny2 - ny1;
            return;
        }
    }
    if (g_ndirty >= MUI_DIRTY_MAX) { dirty_full(); return; }
    g_dirty[g_ndirty][0] = x; g_dirty[g_ndirty][1] = y;
    g_dirty[g_ndirty][2] = w; g_dirty[g_ndirty][3] = h;
    g_ndirty++;
}

void meow_gfx_mark_dirty(int x, int y, int w, int h) { dirty_add(x, y, w, h); }
void meow_gfx_mark_full(void) { dirty_full(); }

/* launcher（系统组件）与 SDK 共用同一 back_buf：launcher 的 fb 绘制指针指向它，
 * 从而 launcher 与 app 统一渲染栈（同一离屏 + 同一 present）。 */
unsigned char *meow_ui_back_buf(void) { return g_back_buf; }

/* ================= 像素写入 ================= */
static void px_write_rgb565(int x, int y, uint16_t c16)
{
    *(uint16_t *)(g_fb + (size_t)y * g_line + (size_t)x * 2) = c16;
}
static uint16_t px_read_rgb565(int x, int y)
{
    return *(uint16_t *)(g_fb + (size_t)y * g_line + (size_t)x * 2);
}

static void put_px(int x, int y, uint32_t color)
{
    if (x < 0 || x >= g_xres || y < 0 || y >= g_yres) return;
    if (g_bpp == 16) {
        px_write_rgb565(x, y, rgb565(color));
    } else {
        unsigned char *p = g_fb + (size_t)y * g_line + (size_t)x * 4;
        *(uint32_t *)p = (color << 8) | 0xFF;
    }
}

static void put_px_blend(int x, int y, uint32_t color, int alpha)
{
    if (x < 0 || x >= g_xres || y < 0 || y >= g_yres) return;
    uint16_t fg = rgb565(color);
    if (g_bpp == 16) {
        uint16_t bg = px_read_rgb565(x, y);
        int ia = 255 - alpha;
        unsigned r = ((((fg >> 11) & 0x1F) * alpha + ((bg >> 11) & 0x1F) * ia) / 255);
        unsigned gg = ((((fg >> 5) & 0x3F) * alpha + ((bg >> 5) & 0x3F) * ia) / 255);
        unsigned b = (((fg & 0x1F) * alpha + (bg & 0x1F) * ia) / 255);
        px_write_rgb565(x, y, (uint16_t)((r << 11) | (gg << 5) | b));
    } else {
        unsigned char *p = g_fb + (size_t)y * g_line + (size_t)x * 4;
        uint32_t bg = (*(uint32_t *)p) >> 8;
        int ia = 255 - alpha;
        unsigned r = ((((color >> 16) & 0xFF) * alpha + ((bg >> 16) & 0xFF) * ia) / 255);
        unsigned gg = ((((color >> 8) & 0xFF) * alpha + ((bg >> 8) & 0xFF) * ia) / 255);
        unsigned b = (((color & 0xFF) * alpha + (bg & 0xFF) * ia) / 255);
        *(uint32_t *)p = (r << 24) | (gg << 16) | (b << 8) | 0xFF;
    }
}

/* ================= 基本绘制 ================= */
void meow_ui_clear(uint32_t color)
{
    if (!g_init_ok) return;
    /* 快速整刷（16bit 用半字填充，可 memset 当色值由 32bit 拼接掩码） */
    if (g_bpp == 16) {
        uint16_t c16 = rgb565(color);
        uint32_t c32 = (uint32_t)c16 | ((uint32_t)c16 << 16);
        for (int y = 0; y < g_yres; y++) {
            uint32_t *row = (uint32_t *)(g_fb + (size_t)y * g_line);
            int n = g_xres / 2;
            for (int i = 0; i < n; i++) row[i] = c32;
            if (g_xres & 1) px_write_rgb565(g_xres - 1, y, c16);
        }
    } else {
        for (int y = 0; y < g_yres; y++)
            for (int x = 0; x < g_xres; x++) put_px(x, y, color);
    }
    dirty_full();
}

void meow_ui_fill_rect(int x, int y, int w, int h, uint32_t color)
{
    if (!g_init_ok) return;
    if (w <= 0 || h <= 0) return;
    int x0 = x, y0 = y;
    if (x < 0) { w += x; x = 0; }
    if (y < 0) { h += y; y = 0; }
    if (x >= g_xres || y >= g_yres) return;
    if (x + w > g_xres) w = g_xres - x;
    if (y + h > g_yres) h = g_yres - y;
    if (w <= 0 || h <= 0) return;
    if (g_bpp == 16) {
        uint16_t c16 = rgb565(color);
        for (int ry = y; ry < y + h; ry++) {
            uint16_t *rp = (uint16_t *)(g_fb + (size_t)ry * g_line + (size_t)x * 2);
            for (int rx = 0; rx < w; rx++) rp[rx] = c16;
        }
    } else {
        for (int ry = y; ry < y + h; ry++)
            for (int rx = x; rx < x + w; rx++) put_px(rx, ry, color);
    }
    dirty_add(x, y, w, h);
}

void meow_ui_put_px(int x, int y, uint32_t color)
{
    if (!g_init_ok) return;
    put_px(x, y, color);
    dirty_add(x, y, 1, 1);
}

void meow_ui_draw_rect(int x, int y, int w, int h, uint32_t color)
{
    if (w <= 0 || h <= 0) return;
    meow_ui_fill_rect(x, y, w, 1, color);
    meow_ui_fill_rect(x, y + h - 1, w, 1, color);
    meow_ui_fill_rect(x, y, 1, h, color);
    meow_ui_fill_rect(x + w - 1, y, 1, h, color);
}

/* 圆角矩形区域判定（含内缩） */
static int rr_inside(int px, int py, int x, int y, int w, int h, int r)
{
    if (px < x || px >= x + w || py < y || py >= y + h) return 0;
    if (r <= 0) return 1;
    if (w < 2 * r || h < 2 * r) return 1; /* 半径过大退化为矩形 */
    int cx1 = x + r, cy1 = y + r;
    int cx2 = x + w - 1 - r, cy2 = y + h - 1 - r;
    if (px < cx1 && py < cy1) return ((px - cx1) * (px - cx1) + (py - cy1) * (py - cy1)) <= r * r;
    if (px > cx2 && py < cy1) return ((px - cx2) * (px - cx2) + (py - cy1) * (py - cy1)) <= r * r;
    if (px < cx1 && py > cy2) return ((px - cx1) * (px - cx1) + (py - cy2) * (py - cy2)) <= r * r;
    if (px > cx2 && py > cy2) return ((px - cx2) * (px - cx2) + (py - cy2) * (py - cy2)) <= r * r;
    return 1;
}

static int rr_border(int px, int py, int x, int y, int w, int h, int r)
{
    if (!rr_inside(px, py, x, y, w, h, r)) return 0;
    int ir = r - 1; if (ir < 0) ir = 0;
    if (w > 2 && h > 2 && rr_inside(px, py, x + 1, y + 1, w - 2, h - 2, ir)) return 0;
    return 1;
}

void meow_gfx_fill_round(int x, int y, int w, int h, int r, uint32_t color)
{
    if (!g_init_ok) return;
    int x1 = x, y1 = y, x2 = x + w, y2 = y + h;
    if (x1 < 0) x1 = 0; if (y1 < 0) y1 = 0;
    if (x2 > g_xres) x2 = g_xres; if (y2 > g_yres) y2 = g_yres;
    for (int py = y1; py < y2; py++)
        for (int px = x1; px < x2; px++)
            if (rr_inside(px, py, x, y, w, h, r)) put_px(px, py, color);
    dirty_add(x1, y1, x2 - x1, y2 - y1);
}

void meow_ui_draw_rect_round(int x, int y, int w, int h, int r, uint32_t color)
{
    if (!g_init_ok) return;
    int x1 = x, y1 = y, x2 = x + w, y2 = y + h;
    if (x1 < 0) x1 = 0; if (y1 < 0) y1 = 0;
    if (x2 > g_xres) x2 = g_xres; if (y2 > g_yres) y2 = g_yres;
    for (int py = y1; py < y2; py++)
        for (int px = x1; px < x2; px++)
            if (rr_border(px, py, x, y, w, h, r)) put_px(px, py, color);
    dirty_add(x1, y1, x2 - x1, y2 - y1);
}

void meow_ui_fill_rect_alpha(int x, int y, int w, int h, uint32_t color, int alpha)
{
    if (!g_init_ok) return;
    if (alpha <= 0) return;
    if (alpha >= 255) { meow_ui_fill_rect(x, y, w, h, color); return; }
    if (w <= 0 || h <= 0) return;
    if (x < 0) { w += x; x = 0; }
    if (y < 0) { h += y; y = 0; }
    if (x >= g_xres || y >= g_yres) return;
    if (x + w > g_xres) w = g_xres - x;
    if (y + h > g_yres) h = g_yres - y;
    if (w <= 0 || h <= 0) return;
    for (int ry = y; ry < y + h; ry++)
        for (int rx = x; rx < x + w; rx++) put_px_blend(rx, ry, color, alpha);
    dirty_add(x, y, w, h);
}

/* ================= 左滑返回视觉条（GESTURE_BACK §2.3） ================= */
#define MUI_HINT_H 5
static int g_hint_last = 0;   /* 上次画过的条长（清条时只清到它，避免残留） */

void meow_ui_swipe_hint(int x)
{
    if (!g_init_ok) return;
    const meow_theme *th = meow_theme_get();
    /* 进度条画在状态栏下沿（z 在状态栏之下，不被全局状态栏覆盖）。
     * 有状态栏（非全屏）→ y = 状态栏高度；收合（collapsed）→ y=提示线下缘
     * （MUI_SBAR_COLLAPSE_H，与提示线不重叠）；无状态栏（全屏/隐藏）→ y=0。 */
    int hy = meow_ui_statusbar_height();
    /* 单一实现（与非全屏 Hello 完全一致，全屏仅 hy 不同）：grow 画 0..x、shrunk 先清旧长
     * 再画 0..x、x<=0 清空。x<0 视为清空；条长上限=屏宽。 */
    if (x > 0) {
        if (x > g_xres) x = g_xres;
        /* 往回滑（新长度 < 上次）时，先清掉「上次画到旧长度、但本次超出的部分」，
         * 否则条只增不减（右滑变长、左滑回缩实时可见）。 */
        if (g_hint_last > x) meow_ui_fill_rect(0, hy, g_hint_last, MUI_HINT_H, th->bg);
        /* 条色取主题前景（fg）：fg 定义为与背景对比，能同时覆盖「非全屏(底=主题bg)」与
         * 「全屏 Hello 类(底=主题accent)」两种情况——accent 在 Hello 全屏 accent 底上同色不可见。 */
        meow_ui_fill_rect(0, hy, x, MUI_HINT_H, th->fg);
        g_hint_last = x;
    } else if (g_hint_last > 0) {
        /* 手指回原点/抬手未达标/抬手达标：清掉此前画的条（填回背景色） */
        meow_ui_fill_rect(0, hy, g_hint_last, MUI_HINT_H, th->bg);
        g_hint_last = 0;
    }
    /* 不发 flush：由调用方 meow_ui_flush_region(0,0,宽,6) 只刷顶部条 */
}

/* ================= 5x7 回退点阵字（与 launcher/hello 一致的表，独立携带） ================= */
static const unsigned char mfont5x7[][8] = {
    {0x0E,0x11,0x13,0x15,0x19,0x11,0x0E,0x00},{0x04,0x0C,0x04,0x04,0x04,0x04,0x0E,0x00},
    {0x0E,0x11,0x01,0x02,0x04,0x08,0x1F,0x00},{0x1F,0x02,0x04,0x02,0x01,0x11,0x0E,0x00},
    {0x02,0x06,0x0A,0x12,0x1F,0x02,0x02,0x00},{0x1F,0x10,0x1E,0x01,0x01,0x11,0x0E,0x00},
    {0x06,0x08,0x10,0x1E,0x11,0x11,0x0E,0x00},{0x1F,0x01,0x02,0x04,0x08,0x08,0x08,0x00},
    {0x0E,0x11,0x11,0x0E,0x11,0x11,0x0E,0x00},{0x0E,0x11,0x11,0x0F,0x01,0x02,0x0C,0x00},
    {0x0E,0x11,0x11,0x1F,0x11,0x11,0x11,0x00},{0x1E,0x11,0x11,0x1E,0x11,0x11,0x1E,0x00},
    {0x0E,0x11,0x10,0x10,0x10,0x11,0x0E,0x00},{0x1C,0x12,0x11,0x11,0x11,0x12,0x1C,0x00},
    {0x1F,0x10,0x10,0x1E,0x10,0x10,0x1F,0x00},{0x1F,0x10,0x10,0x1E,0x10,0x10,0x10,0x00},
    {0x0E,0x11,0x10,0x17,0x11,0x11,0x0F,0x00},{0x11,0x11,0x11,0x1F,0x11,0x11,0x11,0x00},
    {0x0E,0x04,0x04,0x04,0x04,0x04,0x0E,0x00},{0x07,0x02,0x02,0x02,0x02,0x12,0x0C,0x00},
    {0x11,0x12,0x14,0x18,0x14,0x12,0x11,0x00},{0x10,0x10,0x10,0x10,0x10,0x10,0x1F,0x00},
    {0x11,0x1B,0x15,0x15,0x11,0x11,0x11,0x00},{0x11,0x19,0x15,0x13,0x11,0x11,0x11,0x00},
    {0x0E,0x11,0x11,0x11,0x11,0x11,0x0E,0x00},{0x1E,0x11,0x11,0x1E,0x10,0x10,0x10,0x00},
    {0x0E,0x11,0x11,0x11,0x15,0x12,0x0D,0x00},{0x1E,0x11,0x11,0x1E,0x14,0x12,0x11,0x00},
    {0x0F,0x10,0x10,0x0E,0x01,0x01,0x1E,0x00},{0x1F,0x04,0x04,0x04,0x04,0x04,0x04,0x00},
    {0x11,0x11,0x11,0x11,0x11,0x11,0x0E,0x00},{0x11,0x11,0x11,0x11,0x11,0x0A,0x04,0x00},
    {0x11,0x11,0x11,0x15,0x15,0x1B,0x11,0x00},{0x11,0x11,0x0A,0x04,0x0A,0x11,0x11,0x00},
    {0x11,0x11,0x11,0x0A,0x04,0x04,0x04,0x00},{0x1F,0x01,0x02,0x04,0x08,0x10,0x1F,0x00},
    {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},{0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x00},
    {0x04,0x04,0x04,0x04,0x04,0x00,0x04,0x00},{0x00,0x00,0x00,0x1F,0x00,0x00,0x00,0x00},
    {0x00,0x00,0x00,0x1F,0x00,0x00,0x00,0x00},
};
#define FONT5X7_N (sizeof(mfont5x7)/sizeof(mfont5x7[0]))

static int glyph_index(char c)
{
    if (c >= '0' && c <= '9') return c - '0';
    if (c >= 'A' && c <= 'Z') return 10 + (c - 'A');
    if (c >= 'a' && c <= 'z') return 10 + (c - 'a');
    if (c == ' ') return 36;
    if (c == '.') return 37;
    if (c == '!') return 38;
    if (c == '-' || c == '_') return 39;
    return 36;
}

static void draw_glyph5x7(int x, int y, char c, int scale, uint32_t color)
{
    const unsigned char *g = mfont5x7[glyph_index(c)];
    for (int row = 0; row < 7; row++) {
        unsigned char bits = g[row];
        for (int col = 0; col < 5; col++) {
            if (bits & (0x10 >> col)) {
                for (int dy = 0; dy < scale; dy++)
                    for (int dx = 0; dx < scale; dx++)
                        put_px(x + col * scale + dx, y + row * scale + dy, color);
            }
        }
    }
}

static void draw_text5x7(int x, int y, const char *s, int scale, uint32_t color)
{
    while (*s) { draw_glyph5x7(x, y, *s, scale, color); x += 6 * scale; s++; }
}

/* ================= 文本（字库优先，回退点阵） ================= */
static int fallback_scale(int size) { return (size >= 16) ? 2 : 1; }

static void text_draw(int x, int y, const char *s, int size, uint32_t color)
{
    if (!g_init_ok || !s) return;
    if (g_mfont_ready && g_bpp == 16) {
        meow_font_drawtext((uint16_t *)g_fb, x, y, s, rgb565(color), size);
        int w = meow_font_width_text(s, size);
        int hh = meow_font_line_height(size);
        dirty_add(x, y, w, hh);
    } else {
        int sc = fallback_scale(size);
        draw_text5x7(x, y, s, sc, color);
        dirty_add(x, y, (int)strlen(s) * 6 * sc, 7 * sc);
    }
}

void meow_ui_text(int x, int y, const char *utf8, int size, uint32_t color)
{ text_draw(x, y, utf8, size, color); }

void meow_ui_text_right(int right_x, int y, const char *utf8, int size, uint32_t color)
{ text_draw(right_x - meow_ui_text_width(utf8, size), y, utf8, size, color); }

void meow_ui_text_center(int cx, int y, const char *utf8, int size, uint32_t color)
{ text_draw(cx - meow_ui_text_width(utf8, size) / 2, y, utf8, size, color); }

int meow_ui_text_width(const char *utf8, int size)
{
    if (!utf8) return 0;
    if (g_mfont_ready) return meow_font_width_text(utf8, size);
    return (int)strlen(utf8) * 6 * fallback_scale(size);
}

int meow_ui_text_height(int size)
{
    if (g_mfont_ready) return meow_font_line_height(size);
    return 7 * fallback_scale(size);
}

/* ================= RGBA blit（图片层用） ================= */
void meow_gfx_blit_rgba(int x, int y, int w, int h, const uint8_t *rgba, int alpha)
{
    if (!g_init_ok || !rgba || w <= 0 || h <= 0 || alpha <= 0) return;
    int x1 = x, y1 = y, x2 = x + w, y2 = y + h;
    if (x1 < 0) x1 = 0; if (y1 < 0) y1 = 0;
    if (x2 > g_xres) x2 = g_xres; if (y2 > g_yres) y2 = g_yres;
    for (int py = y1; py < y2; py++) {
        int sy = py - y;
        for (int px = x1; px < x2; px++) {
            int sx = px - x;
            const uint8_t *p = rgba + ((size_t)sy * w + sx) * 4;
            int a = (alpha * p[3]) / 255;
            if (a <= 0) continue;
            uint32_t c = ((uint32_t)p[0] << 16) | ((uint32_t)p[1] << 8) | (uint32_t)p[2];
            if (a >= 255) put_px(px, py, c);
            else put_px_blend(px, py, c, a);
        }
    }
    dirty_add(x1, y1, x2 - x1, y2 - y1);
}

/* ================= present / 上屏 ================= */
static void dump_ppm(void)
{
    if (!g_dump_path || !g_back_buf) return;
    FILE *f = fopen(g_dump_path, "wb");
    if (!f) return;
    fprintf(f, "P6\n%d %d\n255\n", g_xres, g_yres);
    for (int y = 0; y < g_yres; y++) {
        for (int x = 0; x < g_xres; x++) {
            unsigned char r, g, b;
            if (g_bpp == 16) {
                uint16_t px = *(uint16_t *)(g_back_buf + (size_t)y * g_line + (size_t)x * 2);
                r = ex5((px >> 11) & 0x1F); g = ex6((px >> 5) & 0x3F); b = ex5(px & 0x1F);
            } else {
                uint32_t px = *(uint32_t *)(g_back_buf + (size_t)y * g_line + (size_t)x * 4);
                r = (px >> 16) & 0xFF; g = (px >> 8) & 0xFF; b = px & 0xFF;
            }
            fputc(r, f); fputc(g, f); fputc(b, f);
        }
    }
    fclose(f);
}

/* ================= 状态栏「上收出屏只留提示线」（collapsed，基座） ================= */
/* 每帧推进上收/恢复：向目标偏移（collapsed→MUI_SBAR_H、否则→0）线性逼近；
 * 无过渡时长（g_sbar_collapse_anim_ms<=0）= 一步到位（基座默认）。动画插值骨架在此，
 * 后续代理可换缓动/每帧步进。 */
static void statusbar_collapse_step(void)
{
    int tgt = g_sbar_collapsed ? MUI_SBAR_H : 0;
    if (g_sbar_collapse_h == tgt) return;
    if (g_sbar_collapse_anim_ms <= 0) { g_sbar_collapse_h = tgt; return; }
    unsigned long long now = now_ms();
    unsigned long long el = now - g_sbar_collapse_start_ms;
    int span = g_sbar_collapse_anim_ms;
    if ((int)el >= span) { g_sbar_collapse_h = tgt; return; }
    int delta = tgt - g_sbar_collapse_from_h;
    g_sbar_collapse_h = g_sbar_collapse_from_h +
        (int)((long long)delta * (long long)el / (long long)span);
}

/* 上收中是否需要逐帧重画（动画未达目标位置时置位，强制每帧推进）。 */
static int statusbar_collapse_in_transition(void)
{
    int tgt = g_sbar_collapsed ? MUI_SBAR_H : 0;
    return g_sbar_collapse_h != tgt;
}

/* 上收状态栏：内容整体上移出屏（不画时钟/电量），仅在顶部画一条「提示线」。
 * 与 meow_ui_swipe_hint（左滑返回进度条，5px，动态）不同：此线是「状态栏可下拉还原」的
 * 常驻提示（主题强调色下边缘）。收合只占/清「提示线」高度区域（MUI_SBAR_COLLAPSE_H=4），
 * 不再清整 MUI_SBAR_H(28) 行 —— app 内容按 inset=提示线高可上移到提示线下缘，无 28px 空条。 */
static void statusbar_collapsed_render(int h)
{
    (void)h;
    const meow_theme *th = meow_theme_get();
    int w = meow_ui_width();
    /* h 越大内容越贴顶；基座：折叠态清「提示线」区域底 + 顶部提示线（提示线下缘=主题 accent） */
    meow_ui_fill_rect(0, 0, w, MUI_SBAR_COLLAPSE_H, th->bg);
    meow_ui_fill_rect(0, MUI_SBAR_COLLAPSE_H - 1, w, 1, th->accent);
}

/* ---- 公共 API（基座实现；动画插值骨架见 statusbar_collapse_step）---- */
void meow_ui_statusbar_set_collapsed(int on)
{
    int tgt = on ? 1 : 0;
    if (tgt == g_sbar_collapsed) return;
    g_sbar_collapsed = tgt;
    g_sbar_collapse_from_h = g_sbar_collapse_h;
    g_sbar_collapse_start_ms = now_ms();
    dirty_full();   /* 顶栏显隐/上收变化 → 全帧重画 */
}

int meow_ui_statusbar_collapsed(void) { return g_sbar_collapsed; }

void meow_ui_statusbar_animate(int ms)
{
    g_sbar_collapse_anim_ms = (ms > 0) ? ms : 0;   /* 0=瞬切（基座默认） */
}

int meow_ui_statusbar_hotzone(void)
{
    /* 非全屏=整条状态栏可视；全屏时缩小到 MEOW_SBAR_HOTZONE_FS（保留一处下拉入口）。
     * 上收（collapsed、非全屏）时热区=提示线下缘高度（MUI_SBAR_COLLAPSE_H，与渲染/inset 同口径）。
     * 全屏态由 meow_ui_sys 维护。 */
    if (meow_ui_sys_statusbar_active())
        return g_sbar_collapsed ? MUI_SBAR_COLLAPSE_H : MUI_SBAR_H;
    return MEOW_SBAR_HOTZONE_FS;
}

/* 顶部状态栏条是否被本次脏区触及（含整帧）：触及或数据已变(force)才需要重画顶条。 */
static int statusbar_touched(void)
{
    if (g_dirty_full) return 1;
    for (int i = 0; i < g_ndirty; i++)
        if (g_dirty[i][1] < MUI_SBAR_H) return 1;   /* 脏矩形与顶条(前 MUI_SBAR_H 行)相交 */
    return 0;
}

static void present(void)
{
    if (!g_init_ok || !g_back_buf) return;
    if (!(g_dirty_full || g_ndirty > 0)) return;
    /* 帧率门控（A-1/A-2，从 launcher 迁入）：present 距上次 ≥ period(1000/eff_rate) 才呈现；
     * 未满周期则保留脏区（不 dirty_reset），下一轮再试。refresh_always_max=1 时跳过门控（恒满速）。 */
    unsigned long long now = now_ms();
    int period = (g_eff_rate > 0) ? (1000 / g_eff_rate) : 16;
    if (!g_refresh_always_max) {
        if (g_last_present_ms && now - g_last_present_ms < (unsigned long long)period) return;
    }
    /* 全局状态栏（A-0）+ 上收（collapsed）基座：上屏前把状态栏画进 back_buf 顶部行。
     * 展开态=整条（MUI_SBAR_H 行）；收合态只占/清「提示线」区域（MUI_SBAR_COLLAPSE_H 行），
     * app 内容（inset=提示线高）可上移到提示线下缘，无 28px 空条。全屏/隐藏时 active()==0
     * 不画（沉浸），app 内容可占满整屏。触发条件：数据已变(1s 轻刷/显隐切换) /
     * 顶条被 app 内容触及 / 上收动画未到位（逐帧推进）。展开态仍走
     * meow_ui_sys_statusbar_render()（meow_ui_sys.c 不改，留给后续代理）；
     * 上收折叠态（collapse_h>=MUI_SBAR_H）由基座只画提示线（内容上移出屏）。 */
    if (meow_ui_sys_statusbar_active() &&
        (meow_ui_sys_statusbar_force() || statusbar_touched() ||
         statusbar_collapse_in_transition())) {
        statusbar_collapse_step();
        if (g_sbar_collapse_h >= MUI_SBAR_H)
            statusbar_collapsed_render(g_sbar_collapse_h);
        else
            meow_ui_sys_statusbar_render();
    }
    if (g_fb_mem) {
        ioctl(g_fb_fd, FBIO_WAITFORVSYNC, 0);   /* 等垂直同步 */
        unsigned long long tbg = now_ms();
        if (g_dirty_full) {
            memcpy(g_fb_mem, g_back_buf, (size_t)g_line * (size_t)g_yres);
        } else {
            int bppb = g_bpp / 8;
            for (int i = 0; i < g_ndirty; i++) {
                int rw = g_dirty[i][2], ry = g_dirty[i][1];
                for (int yy = 0; yy < g_dirty[i][3]; yy++) {
                    size_t off = (size_t)(ry + yy) * g_line + (size_t)g_dirty[i][0] * bppb;
                    memcpy(g_fb_mem + off, g_back_buf + off, (size_t)rw * bppb);
                }
            }
        }
        refresh_governor(now_ms() - tbg, period);
    }
    g_last_present_ms = now;
    g_frames_presented++;
    if (g_dump_path) dump_ppm();
    dirty_reset();
}

void meow_ui_flush(void) { present(); }

void meow_ui_flush_region(int x, int y, int w, int h)
{ dirty_add(x, y, w, h); present(); }

/* ---- 帧率调度设置接口（launcher 与 app 共用；归口 PERF_SCHEDULER 显示刷新率子域）---- */
/* 设目标档位（60/30/15）：同时把当前有效档对齐到目标（与 launcher settings_load 语义一致）。 */
void meow_ui_set_refresh_rate(int r)
{
    if (r != 60 && r != 30 && r != 15) return;
    g_refresh_rate_cfg = r;
    g_eff_rate = r;
}

/* 1=恒 max 不降档（性能优先）；0=允许 governor 在 [15,30,60] 内自适应降/升档。 */
void meow_ui_set_refresh_always_max(int on) { g_refresh_always_max = on ? 1 : 0; }

/* 当前有效帧率（governor 可能已降档；验证/诊断用）。 */
int  meow_ui_effective_rate(void) { return g_eff_rate; }

/* 已呈现帧计数（验证 present 频率用）。 */
unsigned long long meow_ui_frames_presented(void) { return g_frames_presented; }

int meow_gfx_is_device(void) { return g_fb_mem != NULL; }
int meow_gfx_mfont_ready(void) { return g_mfont_ready; }

/* ---- 字体档位（公共 API，基座定义 + font 域真重载钩子）----
 * meow_font_tier()/meow_font_set_tier() 在 meow_ui_gfx.c 定义（符号唯一），font 代理勿在
 * meow_font.c 重复定义；大字库按档装载由 meow_font.c meow_font_reload_tier() 实现，并在
 * meow_font_set_tier() 处唤起（见下）。 */
int meow_font_tier(void) { return g_font_tier; }

int meow_font_set_tier(int tier)
{
    int old = g_font_tier;
    if (tier < MEOW_FONT_TIER_COMMON) tier = MEOW_FONT_TIER_COMMON;
    if (tier > MEOW_FONT_TIER_FULL)   tier = MEOW_FONT_TIER_FULL;
    if (tier == g_font_tier) return g_font_tier;
    g_font_tier = tier;
    /* 真重载（font 域钩子，M2.5x）：按档装载大字库。launcher 已按档解析并注入
     * MEOW_FONT_PNG/IDX（tier>0 → GBK/Full 大字库绝对路径）；重读 env 重载。
     * 无 env/失败 → 回退卡默认 MeowOS/fonts/default → 固件。
     * 大字库 atlas 大（GBK≈5-15MB+），meow_font_reload_tier 先 unload 旧再 load 新，防双驻留。 */
    const char *ep = getenv("MEOW_FONT_PNG");
    const char *ei = getenv("MEOW_FONT_IDX");
    if (ep && ep[0] && ei && ei[0] && meow_font_reload_tier(tier, ep, ei) == 0)
        return g_font_tier;
    if (meow_font_reload_tier(tier, MEOW_FONT_PNG_CARD, MEOW_FONT_IDX_CARD) == 0)
        return g_font_tier;
    if (meow_font_reload_tier(tier, MEOW_FONT_PNG_SYS, MEOW_FONT_IDX_SYS) == 0)
        return g_font_tier;
    g_font_tier = old;   /* 全部失败 → 回退旧档（字库可能已不可用，5x7 点阵兜底，系统不死） */
    return g_font_tier;
}

/* ================= 初始化/销毁 ================= */
/* 字库加载优先级（M2.x）：
 *   1) 环境变量 MEOW_FONT_PNG/MEOW_FONT_IDX（launcher 注入的「当前生效字体」= 系统 font.file）
 *      —— app 未自带字库（§5.7 load_handle 未实现）时跟随系统 font.file；
 *   2) 卡默认 MeowOS/fonts/default/regular/font.png（M2.6 字重结构；不再硬编码 MeowAPPs/fonts）；
 *   3) 固件 /usr/share/meowos/font/font.png。
 * 全失败 → g_mfont_ready=0，text_draw 回退 5x7 点阵（系统不死）。 */
static int load_font(void)
{
    /* 字体档位（MEOW_FONT_TIER env，由 launcher 按 app.json "fonts" 注入）：
     * 0=默认4K常用 1=大字库GBK 2=Full。launcher 已按档解析大字库路径并经 MEOW_FONT_PNG/IDX
     * 注入（见 meow_font_effective_paths_tiered），故下方 meow_font_load(ep,ei) 即装载
     * 对应档位字库（tier>0 → GBK/Full 大字库）；此处 read env 存档对齐公共 get/set。 */
    const char *etr = getenv("MEOW_FONT_TIER");
    if (etr && etr[0]) {
        g_font_tier = atoi(etr);
        if (g_font_tier < MEOW_FONT_TIER_COMMON) g_font_tier = MEOW_FONT_TIER_COMMON;
        if (g_font_tier > MEOW_FONT_TIER_FULL)   g_font_tier = MEOW_FONT_TIER_FULL;
    }
    const char *ep = getenv("MEOW_FONT_PNG");
    const char *ei = getenv("MEOW_FONT_IDX");
    if (ep && ep[0] && ei && ei[0] && meow_font_load(ep, ei) == 0) return 1;
    if (meow_font_load(MEOW_FONT_PNG_CARD, MEOW_FONT_IDX_CARD) == 0) return 1;
    if (meow_font_load(MEOW_FONT_PNG_SYS, MEOW_FONT_IDX_SYS) == 0) return 1;
    return 0;
}

/* M2.5x 多字体：读 launcher 注入的环境变量，构建 6 字符类 → 字库的映射（同 family 去重、
 * ≤4 套上限由 meow_font_config_multifont 统一处理）。launcher 注入（见 meow_launcherd.c
 * launch_app）：MEOW_MULTI_FONT=0/1；MEOW_FONT_PNG/IDX=全局（保留）；每类
 * MEOW_FONT_CLS_<X>_PNG/IDX（命中则覆盖全局；未注入 = 该类跟随全局）。
 * 仅当全局字库已装载（g_mfont_ready）才配置；关/无 env → 单字体，零额外开销。 */
static void meow_gfx_load_multifont(void)
{
    static const char *cls_env[MEOW_FCLS_COUNT][2] = {
        { "MEOW_FONT_CLS_CJK_PNG",      "MEOW_FONT_CLS_CJK_IDX" },
        { "MEOW_FONT_CLS_CJK_SYM_PNG",  "MEOW_FONT_CLS_CJK_SYM_IDX" },
        { "MEOW_FONT_CLS_NUM_PNG",      "MEOW_FONT_CLS_NUM_IDX" },
        { "MEOW_FONT_CLS_LATIN_PNG",    "MEOW_FONT_CLS_LATIN_IDX" },
        { "MEOW_FONT_CLS_LATIN_SYM_PNG", "MEOW_FONT_CLS_LATIN_SYM_IDX" },
        { "MEOW_FONT_CLS_OTHER_PNG",    "MEOW_FONT_CLS_OTHER_IDX" },
    };
    const char *emf = getenv("MEOW_MULTI_FONT");
    int on = emf && emf[0] == '1';
    const char *gp = getenv("MEOW_FONT_PNG");
    const char *gi = getenv("MEOW_FONT_IDX");
    meow_font_class_cfg cfg[MEOW_FCLS_COUNT];
    memset(cfg, 0, sizeof cfg);
    for (int c = 0; c < MEOW_FCLS_COUNT; c++) {
        const char *p = getenv(cls_env[c][0]);
        const char *idx = getenv(cls_env[c][1]);
        if (p && p[0] && idx && idx[0]) { cfg[c].png = p; cfg[c].idx = idx; }
    }
    int distinct = 0, truncated = 0;
    if (meow_font_config_multifont(on, gp, gi, cfg, &distinct, &truncated) != 0)
        meow_log(MEOW_LOG_WARN, "multi_font: config failed, single-font fallback");
    else if (truncated)
        meow_log(MEOW_LOG_WARN, "multi_font: >%d distinct fonts -> capped (more memory!)", distinct);
}

int meow_ui_init(const meow_ui_opts *opts)
{
    if (g_init_ok) return 0;
    int fw = 0, fh = 0;
    if (opts) { fw = opts->width; fh = opts->height; }

    int fd = open(FB_DEV, O_RDWR);
    if (fd >= 0) {
        unsigned char vinfo[160], finfo[68];
        memset(vinfo, 0, sizeof vinfo);
        memset(finfo, 0, sizeof finfo);
        if (ioctl(fd, FBIOGET_VSCREENINFO, vinfo) == 0 &&
            ioctl(fd, FBIOGET_FSCREENINFO, finfo) == 0) {
            g_xres = *(uint32_t *)(vinfo + 0);
            g_yres = *(uint32_t *)(vinfo + 4);
            g_bpp  = *(uint32_t *)(vinfo + 24);
            g_line = *(uint32_t *)(finfo + 44);
            if (!g_line) g_line = g_xres * (g_bpp / 8);
            if (g_bpp != 16 && g_bpp != 32) g_bpp = 16;
            size_t maplen = (size_t)g_line * (size_t)g_yres;
            void *m = mmap(NULL, maplen, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
            if (m != MAP_FAILED) { g_fb_mem = m; g_fb_fd = fd; }
            else { close(fd); fd = -1; g_fb_mem = NULL; }
        } else { close(fd); fd = -1; g_fb_mem = NULL; }
    }

    /* host/qemu 无 fb：使用缺省/覆写几何，走离屏（present 只 dump） */
    if (g_fb_mem == NULL) {
        if (g_xres <= 0 || g_xres > 4096) g_xres = MUI_DEFAULT_W;
        if (g_yres <= 0 || g_yres > 4096) g_yres = MUI_DEFAULT_H;
        if (g_bpp != 16 && g_bpp != 32) g_bpp = 16;
        g_line = g_xres * (g_bpp / 8);
        if (fd >= 0) { close(fd); fd = -1; }
    }
    if (fw > 0 && fw <= 4096) g_xres = fw;
    if (fh > 0 && fh <= 4096) g_yres = fh;
    g_line = g_xres * (g_bpp / 8);

    g_back_buf = malloc((size_t)g_line * (size_t)g_yres);
    if (!g_back_buf) { if (g_fb_mem) munmap(g_fb_mem, 0); if (fd >= 0) close(fd); return -1; }
    g_fb = g_back_buf;

    meow_font_set_fb((unsigned)g_xres, (unsigned)g_yres, (unsigned)g_line);
    g_mfont_ready = load_font();
    if (g_mfont_ready) meow_gfx_load_multifont();   /* M2.5x 多字体（读 env；关/无 env = 单字体） */

    const char *dp = getenv("MEOW_UI_DUMP");
    if (dp && *dp) g_dump_path = strdup(dp);

    g_init_ok = 1;
    dirty_full();
    meow_ui_sys_init();   /* A-0：系统状态读取器首刷（电量/WiFi/蓝牙/音量），状态栏就绪 */
    /* 全屏预置（基座）：launcher 按 app.json "fullscreen" 注入 MEOW_FULLSCREEN=1，SDK 据此
     * 预先设全屏（隐藏整条状态栏/沉浸，statusbar_active()==0、statusbar_height()==0）。
     * 未注入/非"1"=非全屏（默认）。放在 sys_init 后使首帧即为全屏态。 */
    const char *efs = getenv("MEOW_FULLSCREEN");
    if (efs && efs[0] == '1') meow_ui_set_fullscreen(1);
    return 0;
}

void meow_ui_shutdown(void)
{
    if (!g_init_ok) return;
    meow_font_unload();
    if (g_fb_mem) munmap(g_fb_mem, (size_t)g_line * (size_t)g_yres);
    if (g_fb_fd >= 0) close(g_fb_fd);
    if (g_back_buf) free(g_back_buf);
    if (g_dump_path) { free(g_dump_path); g_dump_path = NULL; }
    g_back_buf = NULL; g_fb = NULL; g_fb_mem = NULL;
    g_fb_fd = -1; g_init_ok = 0; g_mfont_ready = 0;
    dirty_reset();
}

int meow_ui_width(void)  { return g_xres; }
int meow_ui_height(void) { return g_yres; }