#!/usr/bin/env node

// 识糖小课堂棋盘压力测试：复刻生产版的 5x4 棋盘、掉落、洗牌和渐进换组规则。
// 运行：node tongji/endless-game/build/stress-game.mjs --runs 10000

const ROWS = 5
const COLS = 4
const HIGH_CAP = 3
const MAX_CASCADE_WAVES = 3
const DANGER_DROP_CHANCE = 0.1
const COLUMN_GROUP_BIAS = 0.72

const FOOD_GROUPS = [
    { title: '中式早餐', safe: ['egg', 'cucumber', 'corn', 'grainMantou'], danger: 'congee' },
    { title: '家常粥餐', safe: ['celery', 'mushroom', 'chicken', 'taro'], danger: 'centuryCongee' },
    { title: '粗粮早餐', safe: ['broccoli', 'milk', 'brownRice', 'potato'], danger: 'milletCongee' },
    { title: '水果饮品', safe: ['apple', 'strawberry', 'banana', 'mango'], danger: 'orangeJuice' },
    { title: '日常饮品', safe: ['milk', 'tea', 'blackCoffee', 'coffee'], danger: 'soda' },
    { title: '下午茶甜饮', safe: ['milk', 'tea', 'apple', 'strawberry'], danger: 'milkTea' },
    { title: '南方汤粉', safe: ['pepper', 'greenBean', 'shrimp', 'udon'], danger: 'riceNoodleSoup' },
    { title: '北方面食', safe: ['onion', 'celery', 'corn', 'grainMantou'], danger: 'noodleSoup' },
    { title: '家常餐桌', safe: ['tofu', 'spinach', 'carrot', 'fish'], danger: 'redBeanCongee' }
]

const HIGH_KEYS = new Set(FOOD_GROUPS.map(group => group.danger))
const SAFE_KEYS = new Set(FOOD_GROUPS.flatMap(group => group.safe))

function readNumberArg(name, fallback) {
    const index = process.argv.indexOf(name)
    if (index < 0) return fallback
    const value = Number(process.argv[index + 1])
    return Number.isFinite(value) && value > 0 ? Math.floor(value) : fallback
}

const RUNS = readNumberArg('--runs', 10000)
const TURNS = readNumberArg('--turns', 80)
const BASE_SEED = readNumberArg('--seed', 20260722)

function createRng(seed) {
    let state = seed >>> 0 || 1
    return () => {
        state ^= state << 13
        state ^= state >>> 17
        state ^= state << 5
        return (state >>> 0) / 4294967296
    }
}

function cloneBoard(source) {
    return source.map(tile => tile ? { ...tile } : null)
}

function tile(key) {
    return { key }
}

function isAdjacent(a, b) {
    const ar = Math.floor(a / COLS)
    const ac = a % COLS
    const br = Math.floor(b / COLS)
    const bc = b % COLS
    return Math.abs(ar - br) + Math.abs(ac - bc) === 1
}

function swap(source, a, b) {
    const next = cloneBoard(source)
    ;[next[a], next[b]] = [next[b], next[a]]
    return next
}

function shuffle(source, rng) {
    const result = cloneBoard(source)
    for (let i = result.length - 1; i > 0; i -= 1) {
        const j = Math.floor(rng() * (i + 1))
        ;[result[i], result[j]] = [result[j], result[i]]
    }
    return result
}

function findMatches(source) {
    const groups = []
    for (let row = 0; row < ROWS; row += 1) {
        let start = 0
        while (start < COLS) {
            let end = start + 1
            while (end < COLS && source[row * COLS + end]?.key === source[row * COLS + start]?.key) end += 1
            if (source[row * COLS + start] && end - start >= 3) {
                groups.push({ direction: 'row', indices: Array.from({ length: end - start }, (_, n) => row * COLS + start + n) })
            }
            start = end
        }
    }
    for (let col = 0; col < COLS; col += 1) {
        let start = 0
        while (start < ROWS) {
            let end = start + 1
            while (end < ROWS && source[end * COLS + col]?.key === source[start * COLS + col]?.key) end += 1
            if (source[start * COLS + col] && end - start >= 3) {
                groups.push({ direction: 'col', indices: Array.from({ length: end - start }, (_, n) => (start + n) * COLS + col) })
            }
            start = end
        }
    }
    return groups
}

function enumerateMatchingMoves(source) {
    const moves = []
    for (let i = 0; i < source.length; i += 1) {
        const candidates = []
        if (i % COLS < COLS - 1) candidates.push(i + 1)
        if (i + COLS < source.length) candidates.push(i + COLS)
        for (const j of candidates) {
            const copy = swap(source, i, j)
            const groups = findMatches(copy)
            if (!groups.length) continue
            const indices = new Set(groups.flatMap(group => group.indices))
            const hitsHigh = [...indices].some(index => HIGH_KEYS.has(copy[index]?.key))
            moves.push({ from: i, to: j, hitsHigh, groups })
        }
    }
    return moves
}

function safeMoves(source) {
    return enumerateMatchingMoves(source).filter(move => !move.hitsHigh)
}

function wouldCreateMatchAt(source, index, key) {
    const row = Math.floor(index / COLS)
    const col = index % COLS
    const keyAt = target => target === index ? key : source[target]?.key
    let horizontal = 1
    for (let c = col - 1; c >= 0 && keyAt(row * COLS + c) === key; c -= 1) horizontal += 1
    for (let c = col + 1; c < COLS && keyAt(row * COLS + c) === key; c += 1) horizontal += 1
    if (horizontal >= 3) return true
    let vertical = 1
    for (let r = row - 1; r >= 0 && keyAt(r * COLS + col) === key; r -= 1) vertical += 1
    for (let r = row + 1; r < ROWS && keyAt(r * COLS + col) === key; r += 1) vertical += 1
    return vertical >= 3
}

function openingKeys(state) {
    const [a, b, c, d] = state.activeSafeKeys
    const danger = FOOD_GROUPS[state.themeIndex].danger
    return [
        a, b, c, d,
        b, c, d, a,
        c, d, a, danger,
        d, a, danger, b,
        a, b, c, d
    ]
}

function forcedPlayableKeys(state) {
    const [a, b, c, d] = state.activeSafeKeys
    const danger = FOOD_GROUPS[state.themeIndex].danger
    return [
        d, a, danger, c,
        d, c, b, danger,
        c, a, b, a,
        d, d, a, a,
        b, d, c, b
    ]
}

function buildPlayableBoard(state, keys = openingKeys(state)) {
    let candidate = keys.map(tile)
    for (let attempt = 0; attempt < 240; attempt += 1) {
        if (!findMatches(candidate).length && safeMoves(candidate).length) return candidate
        candidate = shuffle(candidate, state.rng)
    }
    state.metrics.guaranteedFallbacks += 1
    return forcedPlayableKeys(state).map(tile)
}

function makeStablePlayableBoard(state, source) {
    const tiles = source.filter(Boolean).map(item => ({ ...item }))
    if (tiles.length === ROWS * COLS) {
        for (let attempt = 0; attempt < 300; attempt += 1) {
            const candidate = shuffle(tiles, state.rng)
            if (!findMatches(candidate).length && safeMoves(candidate).length) return candidate
        }
    }
    state.metrics.stableFallbacks += 1
    return buildPlayableBoard(state)
}

function queueSafeGroupTransition(state, keys) {
    const target = [...keys]
    const last = state.queuedSafeGroups[state.queuedSafeGroups.length - 1]
    if (!last || !last.every((key, index) => key === target[index])) {
        state.queuedSafeGroups.push(target)
    }
    startNextTransition(state)
}

function startNextTransition(state) {
    if (state.transition) return false
    while (state.queuedSafeGroups.length) {
        const target = state.queuedSafeGroups[0]
        const slot = target.findIndex((key, index) => state.activeSafeKeys[index] !== key)
        if (slot < 0) {
            state.queuedSafeGroups.shift()
            continue
        }
        const from = state.activeSafeKeys[slot]
        const to = target[slot]
        state.activeSafeKeys[slot] = to
        state.transition = { from, to, slot, age: 0 }
        return true
    }
    return false
}

function finishTransitionIfReady(state) {
    let changed = false
    while (state.transition) {
        const { from, to } = state.transition
        const remaining = state.board.filter(item => item?.key === from).length
        if (remaining > 2) break
        if (remaining) {
            state.board = state.board.map(item => item?.key === from ? { ...item, key: to } : item)
            state.metrics.tailConversions += remaining
        }
        state.transition = null
        changed = true
        startNextTransition(state)
    }
    return changed
}

function prepareTransitionForReshuffle(state) {
    const activeSet = new Set(state.activeSafeKeys)
    const counts = Object.fromEntries(state.activeSafeKeys.map(key => [key, 0]))
    state.board.forEach(item => {
        if (item && activeSet.has(item.key)) counts[item.key] += 1
    })
    let imported = 0
    const next = state.board.map(item => {
        if (!item || item.key === 'camel' || HIGH_KEYS.has(item.key)) return item ? { ...item } : item
        if (state.transition && item.key === state.transition.from) {
            imported += 1
            counts[state.transition.to] += 1
            return { ...item, key: state.transition.to }
        }
        if (activeSet.has(item.key)) return { ...item }
        const key = [...state.activeSafeKeys].sort((a, b) => counts[a] - counts[b])[0]
        counts[key] += 1
        imported += 1
        return { ...item, key }
    })
    state.board = next
    state.metrics.reshuffleImports += imported
}

function randomFoodKey(state, snapshot, col) {
    const highs = snapshot.filter(item => item && HIGH_KEYS.has(item.key)).length
    if (highs < HIGH_CAP && state.rng() < DANGER_DROP_CHANCE) {
        return FOOD_GROUPS[state.themeIndex].danger
    }
    if (state.rng() < COLUMN_GROUP_BIAS) return state.activeSafeKeys[col % state.activeSafeKeys.length]
    return state.activeSafeKeys[Math.floor(state.rng() * state.activeSafeKeys.length)]
}

function pickDropKey(state, snapshot, index, col) {
    for (let attempt = 0; attempt < 16; attempt += 1) {
        const key = randomFoodKey(state, snapshot, col)
        if (!wouldCreateMatchAt(snapshot, index, key)) return key
    }
    const fallback = [...state.activeSafeKeys, FOOD_GROUPS[state.themeIndex].danger]
        .find(key => !wouldCreateMatchAt(snapshot, index, key))
    return fallback || state.activeSafeKeys[(index + col) % state.activeSafeKeys.length]
}

function collapseAndFill(state) {
    const next = Array(ROWS * COLS).fill(null)
    for (let col = 0; col < COLS; col += 1) {
        const existing = []
        for (let row = ROWS - 1; row >= 0; row -= 1) {
            const item = state.board[row * COLS + col]
            if (item) existing.push(item)
        }
        existing.forEach((item, offset) => {
            next[(ROWS - 1 - offset) * COLS + col] = item
        })
    }
    for (let row = 0; row < ROWS; row += 1) {
        for (let col = 0; col < COLS; col += 1) {
            const index = row * COLS + col
            if (!next[index]) next[index] = tile(pickDropKey(state, next, index, col))
        }
    }
    state.board = next
}

function reshuffle(state) {
    prepareTransitionForReshuffle(state)
    let candidate = null
    for (let attempt = 0; attempt < 240; attempt += 1) {
        const shuffled = shuffle(state.board, state.rng)
        if (findMatches(shuffled).length || !safeMoves(shuffled).length) continue
        candidate = shuffled
        break
    }
    state.board = candidate || buildPlayableBoard(state, forcedPlayableKeys(state))
    finishTransitionIfReady(state)
    state.metrics.reshuffles += 1
}

function advanceTheme(state) {
    const previous = FOOD_GROUPS[state.themeIndex]
    state.themeIndex = (state.themeIndex + 1) % FOOD_GROUPS.length
    const next = FOOD_GROUPS[state.themeIndex]
    state.board = state.board.map(item => item?.key === previous.danger ? { ...item, key: next.danger } : item)
    queueSafeGroupTransition(state, next.safe)
    state.metrics.themeChanges += 1
}

function resolveMatches(state, initialGroups) {
    let groups = initialGroups
    let wave = 0
    let camelMatch = 0
    while (groups.length && wave < MAX_CASCADE_WAVES) {
        wave += 1
        const remove = new Set(groups.flatMap(group => group.indices))
        for (const group of groups) {
            if (group.indices.every(index => state.board[index]?.key === 'camel')) {
                camelMatch = Math.max(camelMatch, group.indices.length)
            }
        }
        remove.forEach(index => { state.board[index] = null })
        collapseAndFill(state)
        finishTransitionIfReady(state)
        groups = findMatches(state.board)
        const autoHigh = groups.some(group => group.indices.some(index => HIGH_KEYS.has(state.board[index]?.key)))
        if (autoHigh) {
            state.metrics.automaticHighAvoided += 1
            state.board = makeStablePlayableBoard(state, state.board)
            groups = []
        } else if (wave >= MAX_CASCADE_WAVES && groups.length) {
            state.metrics.cascadeCaps += 1
            state.board = makeStablePlayableBoard(state, state.board)
            groups = []
        }
    }
    state.metrics.maxCascade = Math.max(state.metrics.maxCascade, wave)
    if (camelMatch >= 3) advanceTheme(state)
}

function useCamelTool(state) {
    const danger = FOOD_GROUPS[state.themeIndex].danger
    const targets = state.board
        .map((item, index) => item?.key === danger ? index : -1)
        .filter(index => index >= 0)
    if (!targets.length) return false
    const index = targets[Math.floor(state.rng() * targets.length)]
    state.board[index] = tile('camel')
    state.metrics.toolUses += 1
    const groups = findMatches(state.board)
    if (groups.length) resolveMatches(state, groups)
    return true
}

function recordFailure(state, type, detail = '') {
    state.metrics.failures[type] = (state.metrics.failures[type] || 0) + 1
    if (state.metrics.samples.length < 20) {
        state.metrics.samples.push({ run: state.run, turn: state.turn, type, detail, board: state.board.map(item => item?.key || '-') })
    }
}

function validateState(state, expectStable = true) {
    if (state.board.length !== ROWS * COLS || state.board.some(item => !item?.key)) {
        recordFailure(state, 'invalid_board_size')
        return false
    }
    const currentDanger = FOOD_GROUPS[state.themeIndex].danger
    const highKeys = state.board.filter(item => HIGH_KEYS.has(item.key)).map(item => item.key)
    if (highKeys.some(key => key !== currentDanger)) recordFailure(state, 'wrong_theme_danger', highKeys.join(','))
    if (highKeys.length > HIGH_CAP) recordFailure(state, 'danger_cap_exceeded', String(highKeys.length))

    const allowed = new Set([...state.activeSafeKeys, 'camel'])
    if (state.transition) allowed.add(state.transition.from)
    const stale = state.board.filter(item => !HIGH_KEYS.has(item.key) && !allowed.has(item.key)).map(item => item.key)
    if (stale.length) recordFailure(state, 'stale_food', stale.join(','))

    const normalTypes = new Set(state.board.filter(item => SAFE_KEYS.has(item.key)).map(item => item.key))
    if (normalTypes.size > 5) recordFailure(state, 'too_many_normal_types', String(normalTypes.size))
    if (new Set(state.activeSafeKeys).size !== 4) recordFailure(state, 'duplicate_active_food')
    if (state.transition) {
        const remaining = state.board.filter(item => item.key === state.transition.from).length
        if (remaining <= 2) recordFailure(state, 'orphan_transition_tail', `${state.transition.from}:${remaining}`)
    }
    if (expectStable && findMatches(state.board).length) recordFailure(state, 'unresolved_match')
    return true
}

function createMetrics() {
    return {
        runs: RUNS,
        turnsPerRun: TURNS,
        totalTurns: 0,
        validMoves: 0,
        reshuffles: 0,
        reshuffleImports: 0,
        guaranteedFallbacks: 0,
        stableFallbacks: 0,
        themeChanges: 0,
        toolUses: 0,
        tailConversions: 0,
        automaticHighAvoided: 0,
        cascadeCaps: 0,
        maxCascade: 0,
        unsafeHighMoveProbes: 0,
        maxTransitionAge: 0,
        maxQueuedThemes: 0,
        transitionDrainTurns: 0,
        unfinishedTransitions: 0,
        failures: {},
        samples: []
    }
}

function runTargetedTailTests(metrics) {
    for (let groupIndex = 0; groupIndex < FOOD_GROUPS.length; groupIndex += 1) {
        const nextIndex = (groupIndex + 1) % FOOD_GROUPS.length
        const previousGroup = FOOD_GROUPS[groupIndex]
        const nextGroup = FOOD_GROUPS[nextIndex]
        // 相邻主题允许在相同槽位保留同一种食物。定向测试应选择真正退出下一组的食物，
        // 不能固定测试第 0 槽，否则“牛奶→牛奶”会被误报为尾巴未转换。
        const slot = previousGroup.safe.findIndex(key => !nextGroup.safe.includes(key))
        if (slot < 0) continue
        for (const remaining of [0, 1, 2]) {
            const state = {
                run: -1,
                turn: remaining,
                rng: createRng(BASE_SEED + groupIndex * 17 + remaining),
                metrics,
                themeIndex: nextIndex,
                activeSafeKeys: [...nextGroup.safe],
                transition: {
                    from: previousGroup.safe[slot],
                    to: nextGroup.safe[slot],
                    slot,
                    age: 0
                },
                queuedSafeGroups: [[...nextGroup.safe]],
                board: []
            }
            const fill = nextGroup.safe
            state.board = Array.from({ length: ROWS * COLS }, (_, index) => tile(fill[index % fill.length]))
            for (let index = 0; index < remaining; index += 1) state.board[index] = tile(state.transition.from)
            finishTransitionIfReady(state)
            if (state.board.some(item => item.key === state.transition?.from || item.key === previousGroup.safe[slot])) {
                recordFailure(state, 'targeted_tail_not_converted', `${groupIndex}:${remaining}`)
            }
        }
    }
}

const metrics = createMetrics()
runTargetedTailTests(metrics)

for (let run = 0; run < RUNS; run += 1) {
    const state = {
        run,
        turn: 0,
        rng: createRng(BASE_SEED + run * 2654435761),
        metrics,
        themeIndex: run % FOOD_GROUPS.length,
        activeSafeKeys: [...FOOD_GROUPS[run % FOOD_GROUPS.length].safe],
        transition: null,
        queuedSafeGroups: [],
        board: []
    }
    state.board = buildPlayableBoard(state)
    validateState(state)

    let toolsUsed = 0
    for (let turn = 0; turn < TURNS; turn += 1) {
        state.turn = turn
        metrics.totalTurns += 1
        if (state.transition) {
            state.transition.age += 1
            metrics.maxTransitionAge = Math.max(metrics.maxTransitionAge, state.transition.age)
        }
        metrics.maxQueuedThemes = Math.max(metrics.maxQueuedThemes, state.queuedSafeGroups.length)

        // 模拟玩家积攒到驼乳后替换高糖，但每局限制5次，避免测试人为填满棋盘。
        if (toolsUsed < 5 && turn > 0 && turn % 13 === 0 && useCamelTool(state)) {
            toolsUsed += 1
            finishTransitionIfReady(state)
            if (findMatches(state.board).length) state.board = makeStablePlayableBoard(state, state.board)
        }

        let moves = safeMoves(state.board)
        if (!moves.length) {
            reshuffle(state)
            moves = safeMoves(state.board)
        }
        if (!moves.length) {
            recordFailure(state, 'dead_board_after_reshuffle')
            break
        }

        // 额外探测“主动三消高糖会结束”的判定，不改变主模拟棋盘。
        const unsafe = enumerateMatchingMoves(state.board).find(move => move.hitsHigh)
        if (unsafe) {
            const probe = swap(state.board, unsafe.from, unsafe.to)
            const direct = findMatches(probe)
            if (!direct.some(group => group.indices.some(index => HIGH_KEYS.has(probe[index]?.key)))) {
                recordFailure(state, 'unsafe_high_probe_missed')
            }
            metrics.unsafeHighMoveProbes += 1
        }

        const move = moves[Math.floor(state.rng() * moves.length)]
        state.board = swap(state.board, move.from, move.to)
        const groups = findMatches(state.board)
        if (!groups.length) {
            recordFailure(state, 'safe_move_without_match')
            break
        }
        if (groups.some(group => group.indices.some(index => HIGH_KEYS.has(state.board[index]?.key)))) {
            recordFailure(state, 'safe_move_hit_high')
            break
        }
        resolveMatches(state, groups)
        metrics.validMoves += 1

        // 用较快节奏覆盖连续换组和排队逻辑，强度高于正常玩家。
        if ((turn + 1) % 16 === 0 && turn + 1 < TURNS) advanceTheme(state)
        finishTransitionIfReady(state)
        if (findMatches(state.board).length) state.board = makeStablePlayableBoard(state, state.board)
        if (!safeMoves(state.board).length) reshuffle(state)
        validateState(state)
    }

    // 停止新增主题后继续正常消除，验证排队中的旧食物能否全部退出，避免队列永久积压。
    let drainTurn = 0
    while ((state.transition || state.queuedSafeGroups.length) && drainTurn < 80) {
        state.turn = TURNS + drainTurn
        if (state.transition) {
            state.transition.age += 1
            metrics.maxTransitionAge = Math.max(metrics.maxTransitionAge, state.transition.age)
        }
        let moves = safeMoves(state.board)
        if (!moves.length) {
            reshuffle(state)
            moves = safeMoves(state.board)
        }
        if (!moves.length) {
            recordFailure(state, 'dead_board_while_draining')
            break
        }
        const move = moves[Math.floor(state.rng() * moves.length)]
        state.board = swap(state.board, move.from, move.to)
        resolveMatches(state, findMatches(state.board))
        metrics.validMoves += 1
        finishTransitionIfReady(state)
        if (findMatches(state.board).length) state.board = makeStablePlayableBoard(state, state.board)
        if (!safeMoves(state.board).length) reshuffle(state)
        validateState(state)
        drainTurn += 1
    }
    metrics.transitionDrainTurns += drainTurn
    if (state.transition || state.queuedSafeGroups.length) metrics.unfinishedTransitions += 1
}

const failureCount = Object.values(metrics.failures).reduce((sum, count) => sum + count, 0)
const result = {
    ok: failureCount === 0,
    ...metrics,
    failureCount
}
process.stdout.write(`${JSON.stringify(result, null, 2)}\n`)
if (!result.ok) process.exitCode = 1