/* solitaire.c —— 接龙（Klondike，就是 Windows 自带那个纸牌）
 * solitaire.c -- Klondike solitaire (the one Windows shipped with)
 *
 * 玩法（经典 Klondike 规则）：
 * Rules (classic Klondike):
 *   ① 7 列牌堆：第 i 列 i+1 张，只有最后一张明着；
 *   ① seven tableau piles: column i holds i+1 cards, only the last one face up;
 *   ② 牌堆按**红黑交替、点数递减**叠（红 10 上放黑 9，不能放红 9）；空列**只收 K**；
 *   ② a pile stacks **alternating colors, descending** (a black 9 on a red 10); an empty column
 *      **takes a King only**；
 *   ③ 右上 4 个收牌区：同花色从 A 开始往上收，四个都收到 K 就赢；
 *   ③ four foundations at the top right: same suit ascending from Ace; filling all four to K wins;
 *   ④ 左上牌堆点一下翻一张到废牌堆，翻完再点就从头循环。
 *   ④ tapping the stock at the top left turns one card to the waste; when empty, tapping recycles.
 *
 * 手机没有鼠标拖拽，所以交互是**点选 → 点目标**：
 * Phones have no drag, so interaction is **tap to select, tap the target**:
 *   点一张明牌（连同它下面连成合法序列的那一摞）= 选中；再点目标列 / 目标收牌区 = 移动；
 *   tapping a face-up card (with the valid run below it) selects it; tapping a target column or
 *   foundation moves it;
 *   点牌堆 = 翻牌；点已选中的牌 = 取消。
 *   tapping the stock turns a card; tapping the selection cancels.
 *
 * 牌编码：`c = suit * 13 + rank`，`suit` 0/1/2/3 = 黑桃/红桃/方块/梅花，`rank` 0..12 = A..K。
 * Card encoding: `c = suit * 13 + rank`, suits 0..3 = spades/hearts/diamonds/clubs, rank 0..12 = A..K.
 * 花色用字母（S/H/D/C）而不是 ♠♥♦♣：**字形不一定在随包字体里**，缺字形会画成豆腐块。
 * Suits are letters (S/H/D/C) rather than pip glyphs: the bundled font may not carry those glyphs,
 * and a missing glyph renders as tofu.
 */

#include <vml_ui.h>
#include <stdlib.h>
#include <stdio.h>

#define MAX_FRAMES 60000
#define PILE_MAX   52

#define C_BG    0xFF0C2B1A      /* 桌面绿（经典纸牌桌布的颜色关系） */
#define C_SLOT  0xFF10402A
#define C_CARD  0xFFF4F4F0
#define C_BACK  0xFF1E3F8F
#define C_RED   0xFFC02020
#define C_BLACK 0xFF202020
#define C_TEXT  0xFFE8F0E8
#define C_DIM   0xFF9AB0A0

static int SW, SH, g_lang, g_frames;
static int cw, ch, col_w, top_y, tab_y, base_x;

/* 四堆：牌堆 / 废牌 / 收牌区 / 7 列 */
static int stock[PILE_MAX], stock_n;
static int waste[PILE_MAX], waste_n;
static int found[4][13], found_n[4];
static int tab[7][PILE_MAX], tab_up[7][PILE_MAX], tab_n[7];

static int sel_col, sel_idx, sel_waste, won;

static unsigned int seed = 20261124;
static int rnd(int n)
{
    seed = seed * 1103515245u + 12345u;
    return (int)((seed >> 16) % (unsigned int)n);
}

static int rank_of(int c) { return c % 13; }
static int suit_of(int c) { return c / 13; }
static int is_red(int c) { return suit_of(c) == 1 || suit_of(c) == 2; }

static void relayout(void)
{
    SW = ui_scr_get_w();
    SH = ui_scr_get_h();
    if (SW <= 0) SW = 360;
    if (SH <= 0) SH = 620;
    col_w = (SW - 8) / 7;
    cw = col_w - 3;
    ch = cw * 3 / 2;
    /* 高度上限：7 张牌最多叠出 4 个卡高（tab_y 里已有 1 个 + 6 段 ch/3） */
    /* Height cap: seven cards can stack to four card heights (one in tab_y plus 6 × ch/3). */
    {
        int maxCh = (SH - 88) / 4;
        if (maxCh < 40) maxCh = 40;
        if (ch > maxCh) {
            ch = maxCh;
            cw = ch * 2 / 3;
            col_w = cw + 3;
        }
    }
    base_x = (SW - 7 * col_w) / 2;
    if (base_x < 4) base_x = 4;
    top_y = 64;
    tab_y = top_y + ch + 14;
}

/* 列里从上往下的 y（面朝上的牌重叠多一点，看得清点数） */
static int card_y_at(int col, int i)
{
    int y = tab_y, k;
    for (k = 0; k < i; k++) y += tab_up[col][k] ? ch / 3 : ch / 6;
    return y;
}

static void deal(void)
{
    int deck[52], n = 52, i, j, c;

    for (i = 0; i < 52; i++) deck[i] = i;
    for (i = n - 1; i > 0; i--) {           /* Fisher–Yates */
        j = rnd(i + 1);
        c = deck[i]; deck[i] = deck[j]; deck[j] = c;
    }

    stock_n = 0;
    waste_n = 0;
    for (i = 0; i < 4; i++) found_n[i] = 0;
    for (i = 0; i < 7; i++) tab_n[i] = 0;

    c = 0;
    for (i = 0; i < 7; i++)
        for (j = 0; j <= i; j++) {
            tab[i][tab_n[i]] = deck[c];
            tab_up[i][tab_n[i]] = (j == i);      /* 只有最上面那张明着 */
            tab_n[i] = tab_n[i] + 1;
            c++;
        }
    while (c < 52) { stock[stock_n] = deck[c]; stock_n = stock_n + 1; c++; }

    sel_col = -1; sel_idx = -1; sel_waste = 0; won = 0;
}

/* 这一摞（从 col 的第 i 张到底）能不能整体搬走：递减 + 红黑交替 */
static int run_ok(int col, int i)
{
    int k;
    for (k = i; k + 1 < tab_n[col]; k++) {
        int a = tab[col][k], b = tab[col][k + 1];
        if (!tab_up[col][k] || !tab_up[col][k + 1]) return 0;
        if (rank_of(a) != rank_of(b) + 1) return 0;
        if (is_red(a) == is_red(b)) return 0;
    }
    return tab_up[col][i];
}

static int can_place_tab(int col, int card)
{
    int top;
    if (tab_n[col] == 0) return rank_of(card) == 12;          /* 空列只收 K */
    top = tab[col][tab_n[col] - 1];
    if (!tab_up[col][tab_n[col] - 1]) return 0;
    if (rank_of(card) != rank_of(top) - 1) return 0;
    return is_red(card) != is_red(top);
}

static int can_place_found(int f, int card)
{
    if (suit_of(card) != f) return 0;
    if (found_n[f] == 0) return rank_of(card) == 0;           /* 收牌区从 A 起 */
    return rank_of(card) == found_n[f];                       /* 且恰好是下一张 */
}

/* 把 col 从 idx 起到末尾整摞挪到 dst */
static void move_run(int src, int idx, int dst)
{
    int k;
    for (k = idx; k < tab_n[src]; k++) {
        tab[dst][tab_n[dst]] = tab[src][k];
        tab_up[dst][tab_n[dst]] = 1;
        tab_n[dst] = tab_n[dst] + 1;
    }
    tab_n[src] = idx;
    if (tab_n[src] > 0) tab_up[src][tab_n[src] - 1] = 1;      /* 翻出新的明牌 */
}

static void check_win(void)
{
    int i;
    for (i = 0; i < 4; i++)
        if (found_n[i] != 13) return;
    won = 1;
}

/* ── 画 ─────────────────────────────────────────────────────────────── */

static void draw_card(int x, int y, int card, int face_up)
{
    char r[8];
    int color, v = rank_of(card);

    ui_2d_rect(x, y, cw, ch, face_up ? C_CARD : C_BACK, 1, 0, 6);
    if (!face_up) {
        /* 牌背：几条斜线，看着像纹样 */
        ui_2d_line(x + 6, y + 6, x + cw - 6, y + ch - 6, 0xFF4A6AB0, 2);
        ui_2d_line(x + cw - 6, y + 6, x + 6, y + ch - 6, 0xFF4A6AB0, 2);
        return;
    }
    color = is_red(card) ? C_RED : C_BLACK;
    /* 点数：A / 2..10 / J / Q / K（索引 0..12）。⚠ 10 是**两个字符**，别用 p[-1] 那种写法。 */
    if (v == 0) { r[0] = 'A'; r[1] = 0; }
    else if (v == 9) { r[0] = '1'; r[1] = '0'; r[2] = 0; }
    else if (v == 10) { r[0] = 'J'; r[1] = 0; }
    else if (v == 11) { r[0] = 'Q'; r[1] = 0; }
    else if (v == 12) { r[0] = 'K'; r[1] = 0; }
    else { r[0] = (char)('1' + v); r[1] = 0; }
    /* 花色：**一个字符**（用 `"SHDC" + n` 那种写法会拿到整串 "SHDC"） */
    r[3] = "SHDC"[suit_of(card)];
    r[4] = 0;
    ui_2d_text(x + 5, y + cw / 3, r, color, cw / 3, VML_ANCHOR_LEFT);
    ui_2d_text(x + 5, y + cw / 3 + cw / 3, r + 3, color, cw / 4, VML_ANCHOR_LEFT);

    /* 选中的牌描一圈亮边（在牌上再画一次细框） */
}

static void draw(void)
{
    int i, k;
    char buf[16];

    ui_2d_clear(C_BG);

    /* 顶栏：牌堆 + 废牌 + 4 个收牌区 */
    ui_2d_rect(base_x, top_y, cw, ch, C_SLOT, 1, 0, 6);
    if (stock_n > 0) draw_card(base_x, top_y, stock[stock_n - 1], 0);
    if (waste_n > 0) {
        draw_card(base_x + col_w, top_y, waste[waste_n - 1], 1);
        if (sel_waste) ui_2d_rect(base_x + col_w, top_y, cw, ch, 0x00000000, 0, 3, 6);
    }
    for (i = 0; i < 4; i++) {
        int x = base_x + 3 * col_w + i * col_w;
        ui_2d_rect(x, top_y, cw, ch, C_SLOT, 1, 0, 6);
        if (found_n[i] > 0) draw_card(x, top_y, found[i][found_n[i] - 1], 1);
        else ui_2d_text(x + cw / 2, top_y + ch / 2, "A", C_DIM, cw / 3, VML_ANCHOR_CENTER);
    }

    /* 7 列 */
    for (i = 0; i < 7; i++) {
        int x = base_x + i * col_w;
        ui_2d_rect(x, tab_y, cw, ch, C_SLOT, 1, 0, 6);
        for (k = 0; k < tab_n[i]; k++)
            draw_card(x, card_y_at(i, k), tab[i][k], tab_up[i][k]);
        /* 选中：给整摞描一圈（只在最上面那张画个角标，省得满屏线） */
        if (sel_col == i && sel_idx >= 0 && sel_idx < tab_n[i]) {
            int y = card_y_at(i, sel_idx);
            ui_2d_rect(x - 1, y - 1, cw + 2, ch + 2, 0x00000000, 0, 3, 7);
            ui_2d_text(x + cw - 4, y + ch - 4, "*", 0xFFFFD040, cw / 3, VML_ANCHOR_RIGHT);
        }
    }

    itoa(g_frames / 120, buf);
    ui_2d_text(SW / 2, 22, buf, C_DIM, 12, VML_ANCHOR_CENTER);

    if (won)
        ui_2d_text(SW / 2, SH / 2, g_lang == 0 ? "全部收完，赢了！ESC 再来一局" : "You win! ESC for a new deal",
                   C_TEXT, 20, VML_ANCHOR_CENTER);
    else
        ui_2d_text(SW / 2, SH - 12, g_lang == 0 ? "点牌选中，再点目标；点左上翻牌"
                                               : "Tap a card, then the target; tap the stock to deal",
                   C_DIM, 11, VML_ANCHOR_CENTER);

    ui_2d_present();
}

/* ── 交互 ───────────────────────────────────────────────────────────── */

static void tap_stock(void)
{
    if (stock_n > 0) {
        stock_n = stock_n - 1;
        waste[waste_n] = stock[stock_n];
        waste_n = waste_n + 1;
    } else if (waste_n > 0) {
        int i;
        for (i = waste_n - 1; i >= 0; i--) {           /* 废牌整体倒回牌堆 */
            stock[stock_n] = waste[i];
            stock_n = stock_n + 1;
        }
        waste_n = 0;
    }
    sel_col = -1; sel_idx = -1; sel_waste = 0;
}

static void tap_foundation(int f)
{
    int card;
    if (sel_waste) {
        card = waste[waste_n - 1];
        if (!can_place_found(f, card)) return;
        found[f][found_n[f]] = card; found_n[f] = found_n[f] + 1;
        waste_n = waste_n - 1;
        sel_waste = 0;
        check_win();
        return;
    }
    if (sel_col >= 0 && sel_idx == tab_n[sel_col] - 1) {
        card = tab[sel_col][sel_idx];
        if (!can_place_found(f, card)) return;
        found[f][found_n[f]] = card; found_n[f] = found_n[f] + 1;
        tab_n[sel_col] = tab_n[sel_col] - 1;
        if (tab_n[sel_col] > 0) tab_up[sel_col][tab_n[sel_col] - 1] = 1;
        sel_col = -1; sel_idx = -1;
        check_win();
    }
}

static void tap_column(int col, int card_index, int hit)
{
    /* 没选中：点一张明牌就选中它那一摞 */
    if (sel_col < 0 && !sel_waste) {
        if (!hit || card_index < 0) return;
        if (card_index >= tab_n[col]) return;
        if (card_index == tab_n[col] - 1 && !tab_up[col][card_index]) {
            tab_up[col][card_index] = 1;               /* 封面朝下的顶牌 = 翻开 */
            return;
        }
        if (run_ok(col, card_index)) { sel_col = col; sel_idx = card_index; }
        return;
    }

    /* 已选中：点同一列同一张 = 取消 */
    if (sel_col == col && sel_idx == card_index) { sel_col = -1; sel_idx = -1; return; }

    /* 已选中：尝试落到这一列 */
    {
        int card;
        if (sel_waste) {
            card = waste[waste_n - 1];
            if (!can_place_tab(col, card)) return;
            tab[col][tab_n[col]] = card;
            tab_up[col][tab_n[col]] = 1;
            tab_n[col] = tab_n[col] + 1;
            waste_n = waste_n - 1;
            sel_waste = 0;
            return;
        }
        if (sel_col < 0) return;
        card = tab[sel_col][sel_idx];
        if (!can_place_tab(col, card)) return;
        move_run(sel_col, sel_idx, col);
        sel_col = -1; sel_idx = -1;
    }
}

static void tap(int x, int y)
{
    int i, k;

    if (won) return;

    /* 牌堆 */
    if (x < base_x + cw && y >= top_y && y <= top_y + ch) { tap_stock(); return; }
    /* 废牌 */
    if (x >= base_x + col_w && x < base_x + 2 * col_w && y >= top_y && y <= top_y + ch) {
        if (waste_n > 0) { sel_col = -1; sel_idx = -1; sel_waste = sel_waste ? 0 : 1; }
        return;
    }
    /* 收牌区（右侧四格） */
    if (y >= top_y && y <= top_y + ch) {
        for (i = 0; i < 4; i++) {
            int fx = base_x + 3 * col_w + i * col_w;
            if (x >= fx && x < fx + cw) { tap_foundation(i); return; }
        }
        return;
    }
    /* 7 列：找到点在哪张牌上（从下往上判，重叠的牌上面那张优先） */
    for (i = 0; i < 7; i++) {
        int colx = base_x + i * col_w;
        if (x < colx || x >= colx + cw) continue;
        for (k = tab_n[i] - 1; k >= 0; k--) {
            int cy = card_y_at(i, k);
            if (y >= cy && y < cy + ch) { tap_column(i, k, 1); return; }
        }
        tap_column(i, -1, 0);          /* 点在这一列的空位 */
        return;
    }
}

int main(void)
{
    int msg[4];
    int tid;
    int done = 0;
    /* ⚠ 宿主对**一次物理点击**会同时投递 TOUCHDOWN 与 MOUSEDOWN 两条消息（MAUI 实测：
       一次点击队列里连着两条、坐标相同）。本程序两条都处理 ⇒ 第一下选中、第二下立刻取消
       ⇒ 用户看到的就是「选中纸牌没反应」。⇒ 记住上一条触摸的坐标，紧跟其后、坐标相同的
       鼠标按下视为同一手势的重复投递，直接丢掉（纯鼠标的桌面仍走 MOUSEDOWN 那条）。 */
    /* The host posts BOTH a TOUCHDOWN and a MOUSEDOWN for one physical tap (measured on MAUI);
       handling both selected and immediately deselected the card. Remember the touch position and
       drop the identical MOUSEDOWN that follows it (desktop mouse-only input still works). */
    int lastX = -1, lastY = -1, sawTouch = 0;

    g_lang = ui_scr_get_language();
    relayout();
    ui_win_open_ex("solitaire.c", 0, 0, VML_WIN_ROTATABLE, VML_WIN_NO_GAMEPAD);
    relayout();
    deal();
    draw();

    tid = ui_timer_set(60, 1);
    while (!done && ui_win_is_closed() == 0) {
        int t = ui_msg_wait(msg, 0);
        if (t == VML_MSG_NONE) continue;

        if (t == VML_MSG_TOUCHDOWN) { lastX = msg[1]; lastY = msg[2]; sawTouch = 1; tap(msg[1], msg[2]); draw(); continue; }
        if (t == VML_MSG_MOUSEDOWN) {
            if (sawTouch && msg[1] == lastX && msg[2] == lastY) { sawTouch = 0; continue; }
            tap(msg[1], msg[2]); draw(); continue;
        }
        if (t == VML_MSG_KEYDOWN) {
            if (msg[1] == VML_KEY_ESCAPE) { deal(); draw(); }
            else if (msg[1] == VML_KEY_SPACE) { tap_stock(); draw(); }
            continue;
        }
        if (t == VML_MSG_TIMER) {
            g_frames = g_frames + 1;
            if (g_frames >= MAX_FRAMES) done = 1;
            if ((g_frames % 120) == 0) draw();      /* 每秒刷一次计时 */
            continue;
        }
        if (t == VML_MSG_WINDOWRESIZE) { relayout(); draw(); continue; }
        if (t == VML_MSG_WINDOWCLOSE) break;
    }

    ui_timer_kill(tid);
    ui_win_close();
    printf("solitaire: found=%d%d%d%d won=%d done\n", found_n[0], found_n[1], found_n[2], found_n[3], won);
    return 0;
}
