<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link rel="icon" href="https://bbs.colg.cn/favicon.ico" />
    <title>COLG迷雾系统进度模拟器</title>
    <style>
        :root { 
            --bg: #f0f2f5; --card: #ffffff; 
            --c-green: #2e7d32; --c-yellow: #f57f17; --c-red: #c62828; --c-black: #333;   
            --gold: #ffb300; --primary: #1565c0; --pl-color: #00bcd4; --accent: #d81b60;
            --border-radius: 12px;
        }
        body { 
            font-family: 'Segoe UI', 'Microsoft YaHei', sans-serif; 
            background: var(--bg); margin: 0; padding: 20px; color: #333; 
            user-select: none; -webkit-user-select: none;
        }
        .container { max-width: 1500px; margin: 0 auto; padding-bottom: 50px; } /* 加宽容器 */
        
        /* === 顶部角色面板 === */
        .dashboard-header { 
            background: linear-gradient(135deg, #1565c0, #0d47a1); 
            color: white; padding: 20px 25px; border-radius: var(--border-radius); 
            box-shadow: 0 4px 20px rgba(13, 71, 161, 0.25); margin-bottom: 20px;
        }
        .week-indicator {
            background: rgba(255,255,255,0.2); display: inline-block;
            padding: 4px 12px; border-radius: 20px; font-size: 0.9em; margin-bottom: 10px;
            border: 1px solid rgba(255,255,255,0.3); font-weight: bold;
        }
        .author-tag { text-align: right; color: #1565c0; font-size: 0.85em; font-weight: bold; font-style: italic; margin-bottom: 15px; padding-right: 5px; opacity: 0.7; }

        .dash-content { display: flex; align-items: center; justify-content: space-between; flex-wrap: wrap; gap: 20px; }
        .level-badge { 
            background: rgba(0,0,0,0.25); padding: 10px 20px; border-radius: 12px; 
            text-align: center; min-width: 80px; border: 1px solid rgba(255,255,255,0.2);
        }
        .level-num { font-size: 2.5em; font-weight: bold; color: var(--gold); line-height: 1; text-shadow: 0 2px 4px rgba(0,0,0,0.3); }
        .level-label { font-size: 0.8em; opacity: 0.9; letter-spacing: 1px; }

        .stats-grid { 
            display: grid; grid-template-columns: repeat(4, 1fr); gap: 15px; flex: 1; 
            text-align: center; background: rgba(255,255,255,0.1); padding: 12px; border-radius: 12px;
        }
        .stat-box .s-val { font-size: 1.25em; font-weight: bold; color: #fff; }
        .stat-box .s-label { font-size: 0.85em; color: #e3f2fd; margin-top: 4px; }
        .stat-highlight { color: #81d4fa !important; }

        .total-xp-box { text-align: right; min-width: 120px; }
        .xp-val { font-size: 1.8em; font-weight: bold; }
        .xp-label { font-size: 0.8em; opacity: 0.8; }

        /* === 算法推荐 === */
        .planner-dashboard {
            background: #fff; border-left: 5px solid var(--accent);
            padding: 15px 20px; border-radius: 8px; margin-bottom: 20px;
            box-shadow: 0 2px 10px rgba(0,0,0,0.05);
        }
        .planner-header { font-weight: bold; color: var(--accent); font-size: 1.1em; margin-bottom: 12px; display: flex; align-items: center; gap: 8px; }
        .planner-controls { display: flex; align-items: center; gap: 20px; flex-wrap: wrap; }
        
        .planner-result { 
            margin-top: 15px; font-size: 0.95em; color: #333; padding: 15px; 
            background: #fce4ec; border-radius: 8px; border: 1px solid #f8bbd0; 
            line-height: 1.6;
        }
        .planner-result strong { color: var(--accent); }
        .grad-prediction { 
            margin-top: 10px; padding-top: 10px; border-top: 1px dashed #f8bbd0; 
            color: #880e4f; font-weight: bold; display: flex; align-items: center; gap: 6px; font-size: 1.05em;
        }

        .btn-auto-fill {
            background: var(--accent); color: white; border: none;
            padding: 10px 24px; border-radius: 6px; font-weight: bold; cursor: pointer;
            box-shadow: 0 4px 6px rgba(216, 27, 96, 0.3); transition: transform 0.1s;
            display: flex; align-items: center; gap: 8px; font-size: 0.95em;
        }
        .btn-auto-fill:active { transform: scale(0.98); }

        /* === 账号配置与PL === */
        .config-dashboard {
            background: #fff; padding: 15px 20px; border-radius: var(--border-radius); margin-bottom: 20px;
            box-shadow: 0 2px 10px rgba(0,0,0,0.03);
            display: flex; flex-direction: column; gap: 15px;
        }
        .config-row { display: flex; align-items: center; justify-content: space-between; border-bottom: 1px dashed #eee; padding-bottom: 12px; }
        .char-control { display: flex; align-items: center; gap: 10px; font-weight: bold; color: var(--primary); font-size: 1.05em;}
        .char-input { width: 60px; padding: 6px; border: 2px solid var(--primary); border-radius: 8px; text-align: center; font-size: 1.1em; font-weight: bold; color: var(--primary); }
        
        .pl-header { display: flex; justify-content: space-between; font-size: 0.9em; margin-bottom: 6px; font-weight: bold; color: #555; }
        .pl-bar-bg { background: #e0e0e0; height: 12px; border-radius: 6px; overflow: hidden; }
        .pl-bar-fill { 
            height: 100%; background: var(--pl-color); width: 0%; 
            transition: width 0.3s ease, background-color 0.3s;
        }
        .pl-warning { color: var(--c-red); font-weight: bold; display: none; margin-left: 10px; }

        .lvl-progress-wrapper { margin-top: 15px; position: relative; }
        .lvl-bar-bg { background: rgba(0,0,0,0.3); height: 16px; border-radius: 8px; overflow: hidden; position: relative; }
        .lvl-bar-fill { 
            height: 100%; background: linear-gradient(90deg, #ffca28, #ff6f00); width: 0%; 
            transition: width 0.5s ease; box-shadow: 0 0 10px rgba(255, 160, 0, 0.6);
        }
        .lvl-text { display: flex; justify-content: space-between; font-size: 0.85em; margin-top: 6px; color: #e0e0e0; }
        .lvl-next-highlight { color: #ffca28; font-weight: bold; margin: 0 3px; }

        /* === 结算控制区 === */
        .controls-area {
            background: #fff; padding: 15px 20px; border-radius: var(--border-radius); margin-bottom: 20px;
            box-shadow: 0 2px 10px rgba(0,0,0,0.03); display: flex; justify-content: space-between; align-items: flex-start;
        }
        .btn-group { display: flex; gap: 10px; justify-content: flex-end; }

        .btn-next-week {
            background: linear-gradient(135deg, #2e7d32, #1b5e20); color: white; border: none;
            padding: 10px 24px; border-radius: 8px; font-weight: bold; cursor: pointer; font-size: 1em;
            box-shadow: 0 4px 8px rgba(46, 125, 50, 0.25); transition: transform 0.1s;
        }
        .btn-next-week:active { transform: scale(0.98); }

        .btn-prev-week {
            background: #ff9800; color: white; border: none;
            padding: 10px 18px; border-radius: 8px; font-weight: bold; cursor: pointer; font-size: 1em;
            box-shadow: 0 4px 8px rgba(255, 152, 0, 0.25); transition: opacity 0.2s;
        }
        .btn-prev-week:disabled { background: #bdbdbd; cursor: not-allowed; box-shadow: none; }

        .btn-reset {
            background: #ef5350; color: white; border: none; padding: 8px 15px; 
            border-radius: 6px; font-size: 0.85em; cursor: pointer; opacity: 0.9;
        }
        .save-status { font-size: 0.9em; color: #2e7d32; opacity: 0; transition: opacity 0.5s; font-weight: bold; }
        .save-status.show { opacity: 1; }

        /* === 历史记录 === */
        .history-box {
            margin-top: 10px; border-top: 1px dashed #ddd; padding-top: 10px;
            max-height: 100px; overflow-y: auto; font-size: 0.85em; color: #666; width: 300px;
        }
        .history-item { margin-bottom: 4px; display: flex; justify-content: space-between; }

        /* === 卡片布局 (响应式优化) === */
        .grid { 
            display: flex;             
            flex-wrap: nowrap;         /* 桌面端：不换行，横向滚动 */
            gap: 20px;                 
            overflow-x: auto;          /* 横向滚动条 */
            padding-bottom: 15px;      /* 预留滚动条空间 */
            align-items: stretch;      
            -webkit-overflow-scrolling: touch; 
        }
        
        /* 滚动条样式美化 */
        .grid::-webkit-scrollbar { height: 8px; }
        .grid::-webkit-scrollbar-track { background: #f1f1f1; border-radius: 4px; }
        .grid::-webkit-scrollbar-thumb { background: #ccc; border-radius: 4px; }
        .grid::-webkit-scrollbar-thumb:hover { background: #999; }

        .card { 
            background: var(--card); padding: 20px; border-radius: var(--border-radius); 
            box-shadow: 0 4px 12px rgba(0,0,0,0.05); 
            display: flex; flex-direction: column; 
            flex: 1 0 340px;           /* 核心：卡片等宽，最小340px */
            min-width: 340px;
            height: auto; 
            box-sizing: border-box;
        }

        /* === 手机端适配 (竖向堆叠) === */
        @media (max-width: 768px) {
            .container { padding: 10px; }
            
            .grid {
                flex-wrap: wrap;       /* 允许换行 */
                overflow-x: visible;   /* 取消横向滚动 */
                flex-direction: column;/* 强制竖向排列 */
                gap: 15px;
            }
            
            .card {
                flex: 1 1 100%;        /* 占满宽度 */
                min-width: 0;          /* 取消最小宽度限制 */
                width: 100%;
            }

            .stats-grid { grid-template-columns: repeat(2, 1fr); } 
            .dash-content { gap: 15px; justify-content: center; }
            .total-xp-box { text-align: center; width: 100%; margin-top: 10px; }
            
            .controls-area { flex-direction: column; gap: 15px; }
            .btn-group { width: 100%; justify-content: space-between; }
            .history-box { width: 100%; }
        }
        
        .card-header { 
            font-weight: bold; font-size: 1.15em; border-bottom: 2px solid #f0f0f0; 
            padding-bottom: 12px; margin-bottom: 15px;
            display: flex; justify-content: space-between; align-items: center;
        }
        .cat-pl-tag { font-size: 0.75em; font-weight: normal; background: #f5f5f5; padding: 4px 10px; border-radius: 12px; color: #666; }
        
        .inputs-container { flex: 1; display: flex; flex-direction: column; gap: 8px; }

        .map-row { display: flex; justify-content: space-between; align-items: center; padding: 2px 0; }
        .map-info { display: flex; flex-direction: column; }
        .map-name { font-size: 0.95em; color: #333; font-weight: 600; }
        .map-meta { font-size: 0.75em; color: #999; margin-top: 2px; }
        .pl-tag { background: #e1f5fe; color: #0277bd; padding: 1px 5px; border-radius: 4px; margin-left: 6px; font-weight: bold; font-size: 0.8em; }
        
        .limit-tag-char { color: #1565c0; margin-left: 5px; font-size: 0.85em; font-weight: bold; display: none; }
        .limit-tag-acc { color: #c62828; margin-left: 5px; font-size: 0.85em; font-weight: bold; display: none; }
        
        .error-container { margin-bottom: 10px; display: none; }
        .shared-limit-msg { 
            background: #ffebee; color: #c62828; padding: 8px; border-radius: 6px;
            font-size: 0.85em; font-weight: bold; margin-bottom: 5px; 
            border: 1px solid #ffcdd2;
        }
        
        .week-in { width: 65px; padding: 6px 8px; border: 1px solid #e0e0e0; border-radius: 6px; text-align: center; font-size: 1em; background: #fafafa; transition: all 0.2s; font-weight: 500; }
        .week-in:focus { background: #fff; border-color: #1976d2; outline: none; box-shadow: 0 0 0 2px rgba(25, 118, 210, 0.1); }
        .week-in.error { border-color: #ef5350; background: #ffebee; color: #c62828; }

        .result-box { 
            background: #fafafa; border: 1px solid #eee; padding: 12px; 
            border-radius: 8px; margin-top: 20px;
        }
        .dashboard-stats { display: flex; justify-content: space-between; font-size: 0.85em; background: #fff; padding: 8px; border-radius: 6px; border: 1px solid #eee; margin-bottom: 10px; }
        .stat-item { text-align: center; flex: 1; border-right: 1px solid #eee; }
        .stat-item:last-child { border-right: none; }
        .stat-label { display: block; color: #888; font-size: 0.9em; margin-bottom: 2px; }
        .stat-val { font-weight: bold; font-size: 1.1em; color: #333; }
        .progress-container { height: 10px; background: #e0e0e0; border-radius: 5px; margin: 10px 0; overflow: hidden; display: flex; }
        .progress-segment { height: 100%; transition: width 0.3s; }
        
        .text-green { color: var(--c-green); font-weight: bold; }
        .text-yellow { color: var(--c-yellow); font-weight: bold; }
        .text-red { color: var(--c-red); font-weight: bold; }
        .text-black { color: var(--c-black); font-weight: bold; }
        .bg-green { background-color: var(--c-green); }
        .bg-yellow { background-color: var(--c-yellow); }
        .bg-red { background-color: var(--c-red); }
        .bg-black { background-color: var(--c-black); }

        .breakdown-list { margin-top: 10px; font-size: 0.85em; border-top: 1px dashed #eee; padding-top: 5px; }
        .breakdown-item { display: flex; justify-content: space-between; margin-bottom: 2px; }
        .next-step { background: #e3f2fd; padding: 10px; border-radius: 8px; margin-top: 10px; font-size: 0.9em; color: #0d47a1; }
    </style>
</head>
<body oncontextmenu="return false" onselectstart="return false">

<div class="container">
    <div class="dashboard-header">
        <div class="week-indicator" id="week-display">第 1 周</div>
        <div class="dash-content">
            <div class="level-badge">
                <div class="level-num" id="display-lvl">1</div>
                <div class="level-label">LEVEL</div>
            </div>
            
            <div class="stats-grid">
                <div class="stat-box">
                    <div class="s-val stat-highlight" id="display-skill">10%</div>
                    <div class="s-label">技攻</div>
                </div>
                <div class="stat-box">
                    <div class="s-val" id="display-buff">2400</div>
                    <div class="s-label">增益量</div>
                </div>
                <div class="stat-box">
                    <div class="s-val" id="display-fame">1000</div>
                    <div class="s-label">名望</div>
                </div>
                <div class="stat-box">
                    <div class="s-val" id="display-stats">0</div>
                    <div class="s-label">四维</div>
                </div>
            </div>

            <div class="total-xp-box">
                <div class="xp-val" id="grand-total-display">0</div>
                <div class="xp-label">当前累计总经验</div>
            </div>
        </div>

        <div class="lvl-progress-wrapper">
            <div class="lvl-bar-bg">
                <div class="lvl-bar-fill" id="lvl-bar-fill"></div>
            </div>
            <div class="lvl-text">
                <span id="lvl-progress-text">0 / 5000</span>
                <span id="lvl-next-info">下一级预览</span>
            </div>
        </div>
    </div>
    
    <div class="author-tag">—— by colg胖狗不再胖</div>

    <div class="planner-dashboard">
        <div class="planner-header">
            <span style="font-size:1.2em;">🎯</span> <span>算法推荐</span>
        </div>
        <div class="planner-controls">
            <div style="font-weight:bold; color:#555; display:flex; flex-direction:column; gap:5px;">
                <span>策略模式: <span style="color:var(--accent);">收益最大</span></span>
                <span style="font-size:0.85em; font-weight:normal;">系统将直接填充本周最大收益上限，您可以手动删减不需要的次数</span>
            </div>
            <button class="btn-auto-fill" onclick="generateMaxPlan()">
                <span>填充本周最大收益</span>
            </button>
        </div>
        <div id="planner-result" class="planner-result" style="display:none;"></div>
    </div>

    <div class="config-dashboard">
        <div class="config-row">
            <div class="char-control">
                <span>角色数量 (N):</span>
                <input type="number" id="char-count" class="char-input" value="1" min="1" max="100" onchange="updateLimitsAndCalculate()">
            </div>
        </div>
        <div>
            <div class="pl-header">
                <span>PL 消耗 (账号总上限 <span id="pl-max-display">1316</span>)</span>
                <span><span id="pl-used">0</span> / <span id="pl-max-dynamic">1316</span> <span id="pl-warning" class="pl-warning">⚠️ PL 不足!</span></span>
            </div>
            <div class="pl-bar-bg">
                <div class="pl-bar-fill" id="pl-bar-fill"></div>
            </div>
        </div>
    </div>

    <div class="controls-area">
        <div>
            <div id="save-msg" class="save-status">
                <span style="font-size:1.2em; margin-right:5px;">✓</span> <span>数据已保存</span>
            </div>
            <div id="history-log" class="history-box"></div>
        </div>
        <div style="display:flex; flex-direction:column; align-items:flex-end;">
            <div class="btn-group">
                <button id="btn-undo" class="btn-prev-week" onclick="undoLastWeek()" disabled> 撤销 ⬅️ 上一周</button>
                <button class="btn-next-week" onclick="settleCurrentWeek()">结算 ➡️ 下一周</button>
            </div>
            <div style="margin-top:8px;">
                <button class="btn-reset" onclick="fullReset()">重置所有数据</button>
            </div>
        </div>
    </div>

    <div id="app" class="grid"></div>
</div>

<script>
    document.onkeydown = function(e) {
        if (event.keyCode == 123) return false;
        if (e.ctrlKey && e.shiftKey && (e.keyCode == 'I'.charCodeAt(0) || e.keyCode == 'C'.charCodeAt(0) || e.keyCode == 'J'.charCodeAt(0))) return false;
        if (e.ctrlKey && e.keyCode == 'U'.charCodeAt(0)) return false;
    }

    const levelTable = [
        { lvl: 1,  need: 0,      buff: 2400, skill: 10.0, fame: 1000, stats: 0, total: 0 },
        { lvl: 2,  need: 5000,   buff: 2450, skill: 10.5, fame: 1050, stats: 0, total: 5000 },
        { lvl: 3,  need: 5500,   buff: 2500, skill: 11.0, fame: 1100, stats: 0, total: 10500 },
        { lvl: 4,  need: 6000,   buff: 2550, skill: 11.5, fame: 1150, stats: 0, total: 16500 },
        { lvl: 5,  need: 7000,   buff: 2650, skill: 12.5, fame: 1250, stats: 30, total: 23500 },
        { lvl: 6,  need: 7500,   buff: 2700, skill: 13.0, fame: 1300, stats: 30, total: 31000 },
        { lvl: 7,  need: 8000,   buff: 2750, skill: 13.5, fame: 1350, stats: 30, total: 39000 },
        { lvl: 8,  need: 8500,   buff: 2800, skill: 14.0, fame: 1400, stats: 30, total: 47500 },
        { lvl: 9,  need: 9000,   buff: 2850, skill: 14.5, fame: 1450, stats: 30, total: 56500 },
        { lvl: 10, need: 11500,  buff: 3000, skill: 16.0, fame: 1600, stats: 80, total: 68000 },
        { lvl: 11, need: 12100,  buff: 3050, skill: 16.5, fame: 1650, stats: 80, total: 80100 },
        { lvl: 12, need: 12700,  buff: 3100, skill: 17.0, fame: 1700, stats: 80, total: 92800 },
        { lvl: 13, need: 13300,  buff: 3150, skill: 17.5, fame: 1750, stats: 80, total: 106100 },
        { lvl: 14, need: 14000,  buff: 3200, skill: 18.0, fame: 1800, stats: 80, total: 120100 },
        { lvl: 15, need: 18400,  buff: 3350, skill: 19.5, fame: 1950, stats: 110, total: 138500 }, 
        { lvl: 16, need: 20200,  buff: 3400, skill: 20.0, fame: 2000, stats: 110, total: 158700 },
        { lvl: 17, need: 22200,  buff: 3450, skill: 20.5, fame: 2050, stats: 110, total: 180900 },
        { lvl: 18, need: 24400,  buff: 3500, skill: 21.0, fame: 2100, stats: 110, total: 205300 },
        { lvl: 19, need: 26800,  buff: 3550, skill: 21.5, fame: 2150, stats: 110, total: 232100 },
        { lvl: 20, need: 33600,  buff: 3700, skill: 23.0, fame: 2300, stats: 160, total: 265700 }, 
        { lvl: 21, need: 37000,  buff: 3750, skill: 23.5, fame: 2350, stats: 160, total: 302700 },
        { lvl: 22, need: 40700,  buff: 3800, skill: 24.0, fame: 2400, stats: 160, total: 343400 },
        { lvl: 23, need: 44800,  buff: 3850, skill: 24.5, fame: 2450, stats: 160, total: 388200 },
        { lvl: 24, need: 49300,  buff: 3900, skill: 25.0, fame: 2500, stats: 160, total: 437500 },
        { lvl: 25, need: 59100,  buff: 4050, skill: 26.5, fame: 2650, stats: 190, total: 496600 }, 
        { lvl: 26, need: 65000,  buff: 4100, skill: 27.0, fame: 2700, stats: 190, total: 561600 },
        { lvl: 27, need: 71500,  buff: 4150, skill: 27.5, fame: 2750, stats: 190, total: 633100 },
        { lvl: 28, need: 78700,  buff: 4200, skill: 28.0, fame: 2800, stats: 190, total: 711800 },
        { lvl: 29, need: 86600,  buff: 4250, skill: 28.5, fame: 2850, stats: 190, total: 798400 },
        { lvl: 30, need: 100100,  buff: 4400, skill: 30.0, fame: 3000, stats: 250, total: 898500 } 
    ];

    /* Logic Config */
    const dungeonsData = [
        {
            id: 'normal', name: '普通图 (深渊)', color: '#2e7d32', 
            maps: [
                { name: '妖怪歼灭', xp: 2, cost: 8 }, 
                { name: '白图 (噩梦)', xp: 10, cost: 8 },
                { name: '小深渊', xp: 20, cost: 8, isSmallHell: true }, // T5
                { name: '大深渊', xp: 150, cost: 30, isBigHell: true }, // T4           
                { name: '1+1 图', xp: 30, cost: 8, limit: 14, limitType: 'per_char', is1p1: true, charCap: 20 }, 
                { name: '新深渊 (神器)', xp: 85, cost: 8, isUnique: true },
                { name: '新深渊 (传说)', xp: 350, cost: 8, isLegend: true }, 
                { name: '新深渊 (史诗)', xp: 750, cost: 8, isEpic: true }
            ],
            thresholds: [
                { limit: 22360, rate: 1.0, label: '100% 收益' }, { limit: 27450, rate: 0.5, label: '50% 收益' },
                { limit: 29485, rate: 0.2, label: '20% 收益' }, { limit: 999999, rate: 0.01, label: '1% 收益' }
            ]
        },
        {
            id: 'expedition', name: '征讨图', color: '#1565c0', 
            maps: [
                { name: '白云溪谷', xp: 200, cost: 30, limitGroup: 'ex_share', limit: 2 }, 
                { name: '索利达里斯', xp: 300, cost: 30, limitGroup: 'ex_share', limit: 2 },
                { name: '沉月湖', xp: 500, cost: 30 }, 
                { name: '蔚蓝号', xp: 610, cost: 30, limitGroup: 'ex_share', limit: 2, isHighXP: true },
                { name: '女神殿', xp: 680, cost: 30, limitGroup: 'ex_share', limit: 2, isMaxXP: true }, 
                { name: '噩梦循环', xp: 810, cost: 30, limit: 4, limitType: 'account', isNightmare: true }
            ],
            thresholds: [
                { limit: 16280, rate: 1.0, label: '100%' }, { limit: 18345, rate: 0.2, label: '20%' }, 
                { limit: 999999, rate: 0.01, label: '1%' }
            ]
        },
        {
            id: 'legion', name: '军团 (维纳斯)', color: '#ef6c00', 
            maps: [
                { name: '一阶段/匹配', xp: 600, cost: 30, limitGroup: 'venus_share', limit: 1 }, 
                { name: '维纳斯 (二阶段)', xp: 900, cost: 30, limitGroup: 'venus_share', limit: 1, isTarget: true }, 
                { name: '维纳斯 (降临)', xp: 900, cost: 30, limitGroup: 'venus_share', limit: 1 }
            ],
            thresholds: [
                { limit: 10800, rate: 1.0, label: '100%' }, { limit: 12240, rate: 0.2, label: '20%' }, { limit: 999999, rate: 0.01, label: '1%' }
            ]
        },
        {
            id: 'raid', name: '团本 (雾神/狄瑞吉)', color: '#7b1fa2', 
            maps: [
                { name: '人造神 (单人/匹配)', xp: 600, cost: 0, limitGroup: 'god_share', limit: 1 }, 
                { name: '人造神 (普通/困难)', xp: 1020, cost: 0, limitGroup: 'god_share', limit: 1, isTarget: true }, 
                
                { name: '雾岚黄昏战', xp: 1530, cost: 0, limit: 8, limitType: 'account', isAsrahan: true }, 
                
                { name: '狄瑞吉 (单人/匹配)', xp: 1180, cost: 0, limitGroup: 'diregie_share', limit: 1 }, 
                { name: '狄瑞吉 (普通/英雄)', xp: 2030, cost: 0, limitGroup: 'diregie_share', limit: 1, isTarget: true }
            ],
            thresholds: [
                { limit: 48840, rate: 1.0, label: '100%' }, { limit: 53720, rate: 0.2, label: '20%' }, { limit: 999999, rate: 0.01, label: '1%' }
            ]
        }
    ];

    const PL_PER_CHAR = 188 * 7; 

    // === 全局状态 ===
    const app = document.getElementById('app');
    let historicXP = 0; 
    let currentWeek = 1; 
    let weekHistory = []; 
    let undoStack = [];
    let currentWeekValidXP = [0, 0, 0, 0]; 
    let saveTimeout;
    let charCount = 1;

    // 初始化界面
    dungeonsData.forEach((category, catIndex) => {
        const card = document.createElement('div');
        card.className = 'card';
        const errorContainerId = `error-box-${catIndex}`;
        
        let inputsHtml = category.maps.map((map, mapIndex) => {
            const plTag = map.cost > 0 ? `<span class="pl-tag">${map.cost}PL</span>` : '';
            const limitTagId = `limit-${catIndex}-${mapIndex}`;
            const limitTag = `<span class="limit-tag-char" id="${limitTagId}"></span><span class="limit-tag-acc" id="acc-${limitTagId}"></span>`;
            
            return `
            <div class="map-row">
                <div class="map-info">
                    <span class="map-name">${map.name} ${plTag} ${limitTag}</span>
                    <span class="map-meta">XP: ${map.xp}</span>
                </div>
                <input type="number" min="0" placeholder="本周次" class="week-in" 
                    id="in-${catIndex}-${mapIndex}" oninput="calculate(true)">
            </div>
            `;
        }).join('');

        let optionsHtml = category.maps.map((m, i) => `<option value="${m.xp}">${m.name}</option>`).join('');
        
        const plStatHtml = (category.id !== 'raid') ? `<span id="group-pl-${catIndex}" class="cat-pl-tag">0 PL</span>` : '';

        card.innerHTML = `
            <div class="card-header" style="color:${category.color}">
                <span>${category.name}</span>
                ${plStatHtml}
            </div>
            <div id="${errorContainerId}" class="error-container"></div>
            <div class="inputs-container">
                ${inputsHtml}
            </div>
            <div class="result-box">
                <div class="dashboard-stats">
                    <div class="stat-item"><span class="stat-label">本周有效</span><span class="stat-val" id="val-curr-${catIndex}">0</span></div>
                    <div class="stat-item"><span class="stat-label">阶段上限</span><span class="stat-val" id="val-limit-${catIndex}">0</span></div>
                    <div class="stat-item"><span class="stat-label" id="label-gap-${catIndex}">本阶段余量</span><span class="stat-val" id="val-gap-${catIndex}" style="color:#d32f2f">0</span></div>
                </div>
                <div class="progress-container" id="bar-container-${catIndex}"></div>
                <div id="breakdown-${catIndex}" class="breakdown-list"></div>
                <div class="next-step" id="advice-${catIndex}">
                    <div style="margin-bottom:5px;">填满本周当前阶段：</div>
                    <select id="bench-${catIndex}" onchange="calculate(true)" style="width:100%; padding:5px; margin-bottom:5px;">${optionsHtml}</select>
                    <div id="advice-text-${catIndex}">暂无数据</div>
                </div>
            </div>
        `;
        app.appendChild(card);
        document.getElementById(`bench-${catIndex}`).selectedIndex = category.maps.length - 1;
    });

    // === 智能规划算法 ===
    function generateMaxPlan() {
        if(!confirm(`⚠️ 确定要生成【本周理论最大收益方案】吗？\n此操作将直接填入所有高收益副本的上限次数。\n当前周的输入将被覆盖。`)) return;

        // 清空
        document.querySelectorAll('.week-in').forEach(el => el.value = '');

        let totalPL = charCount * PL_PER_CHAR;
        let currentPL = 0;

        // 通用填充工具函数 (无视XP需求，只看PL和次数)
        function tryFillMax(el, map, maxCount) {
            let existingVal = parseInt(el.value || 0);
            let remain = maxCount - existingVal;
            let count = 0;
            
            for(let i=0; i<remain; i++) {
                if (map.cost > 0 && currentPL + map.cost > totalPL) break; // PL空了
                count++;
                currentPL += map.cost;
            }
            
            if (count > 0) {
                el.value = existingVal + count; 
            }
        }

        // --- T0: 团本 & 噩梦 (无视PL或低PL) ---
        dungeonsData.forEach((cat, cIdx) => {
            cat.maps.forEach((map, mIdx) => {
                const el = document.getElementById(`in-${cIdx}-${mIdx}`);
                let limit = 0;
                
                if (map.isAsrahan) limit = 8; // 雾岚固定8
                if (map.isNightmare) limit = 4; // 噩梦固定4
                if (map.isTarget && cat.id === 'raid') limit = 1 * charCount; // 团本 N
                
                if (limit > 0) tryFillMax(el, map, limit);
            });
        });

        // --- T1: 军团 ---
        dungeonsData.forEach((cat, cIdx) => {
            cat.maps.forEach((map, mIdx) => {
                const el = document.getElementById(`in-${cIdx}-${mIdx}`);
                if (map.isTarget && cat.id === 'legion') tryFillMax(el, map, 1 * charCount);
            });
        });

        // --- T1.5 征讨图 (噩梦+女神+蔚蓝) ---
        // 优先填女神殿 (MaxXP) 1*N
        dungeonsData.forEach((cat, cIdx) => {
            cat.maps.forEach((map, mIdx) => {
                const el = document.getElementById(`in-${cIdx}-${mIdx}`);
                if (map.isMaxXP) tryFillMax(el, map, 1 * charCount); 
            });
        });
        
        // 填蔚蓝号 (N - 噩梦已用次数)
        // 注意：这里需要重新获取噩梦的实际填充值（可能因为PL不够没填满）
        let nightmareFilled = 0;
        dungeonsData.forEach((cat, cIdx) => {
            cat.maps.forEach((map, mIdx) => {
                if(map.isNightmare) nightmareFilled = parseInt(document.getElementById(`in-${cIdx}-${mIdx}`).value || 0);
            });
        });
        let blueHawkLimit = Math.max(0, (1 * charCount) - nightmareFilled);
        dungeonsData.forEach((cat, cIdx) => {
            cat.maps.forEach((map, mIdx) => {
                const el = document.getElementById(`in-${cIdx}-${mIdx}`);
                if (map.isHighXP) tryFillMax(el, map, blueHawkLimit);
            });
        });

        // --- T2: 1+1 图 (锁20) ---
        dungeonsData.forEach((cat, cIdx) => {
            cat.maps.forEach((map, mIdx) => {
                if (map.is1p1) {
                    const el = document.getElementById(`in-${cIdx}-${mIdx}`);
                    let effectiveN = charCount;
                    if(map.charCap) effectiveN = Math.min(charCount, map.charCap);
                    tryFillMax(el, map, 14 * effectiveN);
                }
            });
        });

        // --- T3: 令牌 (固定池 52) ---
        if (currentPL < totalPL) {
            let epicEl, legEl, uniEl;
            dungeonsData.forEach((cat, cIdx) => {
                cat.maps.forEach((map, mIdx) => {
                    if (map.isEpic) epicEl = document.getElementById(`in-${cIdx}-${mIdx}`);
                    if (map.isLegend) legEl = document.getElementById(`in-${cIdx}-${mIdx}`);
                    if (map.isUnique) uniEl = document.getElementById(`in-${cIdx}-${mIdx}`);
                });
            });

            // 循环填充直到 PL 尽 或 池尽
            let poolEpic=2, poolLegend=10, poolUnique=40; 
            let canRun = true;
            while(canRun && currentPL + 8 <= totalPL) {
                canRun = false;
                if(poolEpic > 0 && currentPL+8 <= totalPL) { 
                    epicEl.value = (parseInt(epicEl.value)||0)+1; currentPL+=8; poolEpic--; canRun=true; 
                }
                for(let k=0; k<5; k++) {
                    if(poolLegend > 0 && currentPL+8 <= totalPL) { 
                        legEl.value = (parseInt(legEl.value)||0)+1; currentPL+=8; poolLegend--; canRun=true; 
                    }
                }
                for(let k=0; k<20; k++) {
                    if(poolUnique > 0 && currentPL+8 <= totalPL) { 
                        uniEl.value = (parseInt(uniEl.value)||0)+1; currentPL+=8; poolUnique--; canRun=true; 
                    }
                }
            }
        }

        // --- T4: 大深渊 (1*N) ---
        if (currentPL < totalPL) {
            dungeonsData.forEach((cat, cIdx) => {
                cat.maps.forEach((map, mIdx) => {
                    if (map.isBigHell) {
                        const el = document.getElementById(`in-${cIdx}-${mIdx}`);
                        tryFillMax(el, map, 1 * charCount);
                    }
                });
            });
        }

        // --- T5: 小深渊 (无限) ---
        if (currentPL < totalPL) {
            dungeonsData.forEach((cat, cIdx) => {
                cat.maps.forEach((map, mIdx) => {
                    if (map.isSmallHell) {
                        const el = document.getElementById(`in-${cIdx}-${mIdx}`);
                        tryFillMax(el, map, 9999); 
                    }
                });
            });
        }

        calculate(true); 
        
        // --- 结果计算 ---
        let weeklyXP = 0;
        currentWeekValidXP.forEach(xp => weeklyXP += xp);
        
        const maxLvlXP = levelTable[29].total; 
        const gapToMax = Math.max(0, maxLvlXP - historicXP);
        let gradWeeks = "∞";
        if (weeklyXP > 0) {
            gradWeeks = (gapToMax / weeklyXP).toFixed(1);
        }

        const resEl = document.getElementById('planner-result');
        resEl.style.display = 'block';
        
        let summaryHtml = `
        <div style="font-weight:bold; color:#d81b60; margin-bottom:5px;">🚀 方案已生成！</div>
        <div style="font-size:0.9em; color:#333;">
            📅 预计本周可获经验: <strong style="font-size:1.1em;">${Math.floor(weeklyXP)}</strong><br>
            ⏳ 距离满级 (Lv30) 预计还需: <strong style="font-size:1.1em; color:#d81b60;">${gradWeeks} 周</strong>
        </div>`;
        
        resEl.innerHTML = summaryHtml;
    }

    function updateLimitsAndCalculate() {
        const val = document.getElementById('char-count').value;
        charCount = parseInt(val) || 1;
        if(charCount < 1) charCount = 1;
        if(charCount > 100) charCount = 100;
        
        dungeonsData.forEach((cat, cIdx) => {
            cat.maps.forEach((map, mIdx) => {
                const limitElChar = document.getElementById(`limit-${cIdx}-${mIdx}`);
                const limitElAcc = document.getElementById(`acc-limit-${cIdx}-${mIdx}`);
                const realAccEl = document.getElementById(`acc-limit-${cIdx}-${mIdx}`);

                if (!limitElChar) return;
                limitElChar.style.display = 'none';
                if(realAccEl) realAccEl.style.display = 'none';

                if (map.limitType === 'account') {
                    const accEl = document.getElementById(`acc-limit-${cIdx}-${mIdx}`);
                    if(accEl) {
                        accEl.innerText = `[账号${map.limit}次]`;
                        accEl.style.display = 'inline';
                    }
                }
                if (map.accountLimit) {
                    const accEl = document.getElementById(`acc-limit-${cIdx}-${mIdx}`);
                    if(accEl) {
                        accEl.innerText = `[账号${map.accountLimit}次]`;
                        accEl.style.display = 'inline';
                    }
                }
                if(map.charCap && charCount > map.charCap) {
                     limitElChar.style.display = 'inline';
                     limitElChar.innerText = `[封顶: ${map.limit * map.charCap}]`;
                     limitElChar.style.color = '#e65100';
                }
            });
        });

        const totalMaxPL = PL_PER_CHAR * charCount;
        document.getElementById('pl-max-display').innerText = totalMaxPL;
        document.getElementById('pl-max-dynamic').innerText = totalMaxPL;

        calculate(true);
    }

    function getColorConfig(rate) {
        if (rate >= 0.9) return { textClass: 'text-green', bgClass: 'bg-green' };
        if (rate >= 0.5) return { textClass: 'text-yellow', bgClass: 'bg-yellow' };
        if (rate >= 0.1) return { textClass: 'text-red', bgClass: 'bg-red' };
        return { textClass: 'text-black', bgClass: 'bg-black' };
    }

    function calculate(shouldSave = false) {
        let currentTotalPL = 0;
        const totalMaxPL = PL_PER_CHAR * charCount;

        dungeonsData.forEach((catData, catIndex) => {
            let totalRawXP = 0; 
            let catTotalPL = 0;
            
            let groupSums = {}; 
            let groupInputs = {}; 
            
            // 1. 预计算组总和
            catData.maps.forEach((map, mapIndex) => {
                if (map.limitGroup) {
                    const val = parseInt(document.getElementById(`in-${catIndex}-${mapIndex}`).value) || 0;
                    if (!groupSums[map.limitGroup]) {
                        groupSums[map.limitGroup] = 0;
                        groupInputs[map.limitGroup] = [];
                    }
                    groupSums[map.limitGroup] += val;
                    groupInputs[map.limitGroup].push(document.getElementById(`in-${catIndex}-${mapIndex}`));
                }
            });

            // 2. 显示组错误
            const errorBox = document.getElementById(`error-box-${catIndex}`);
            errorBox.innerHTML = '';
            errorBox.style.display = 'none';

            for (const [group, sum] of Object.entries(groupSums)) {
                const templateMap = catData.maps.find(m => m.limitGroup === group);
                const max = templateMap.limit * charCount;
                
                if (sum > max) {
                    errorBox.style.display = 'block';
                    let groupNameCN = group;
                    if(group === 'ex_share') groupNameCN = '征讨图(共享)';
                    if(group === 'venus_share') groupNameCN = '维纳斯(共享)';
                    if(group === 'god_share') groupNameCN = '人造神(共享)';
                    if(group === 'diregie_share') groupNameCN = '狄瑞吉(共享)';

                    errorBox.innerHTML += `<div class="shared-limit-msg">⚠️ ${groupNameCN} 溢出: ${sum}/${max}</div>`;
                    groupInputs[group].forEach(el => el.classList.add('error'));
                } else {
                    groupInputs[group].forEach(el => el.classList.remove('error'));
                }
            }

            // 3. 遍历计算
            catData.maps.forEach((map, mapIndex) => {
                const el = document.getElementById(`in-${catIndex}-${mapIndex}`);
                const val = parseInt(el.value) || 0;
                
                const plCost = val * map.cost;
                currentTotalPL += plCost;
                catTotalPL += plCost;

                let isOverLimit = false;
                
                // 账号级硬锁
                if (map.limitType === 'account' || map.accountLimit) {
                    const accMax = map.accountLimit || map.limit;
                    if (val > accMax) {
                        isOverLimit = true;
                        errorBox.style.display = 'block';
                        errorBox.innerHTML += `<div class="shared-limit-msg">⚠️ ${map.name.split(' ')[0]} 账号超限: ${val}/${accMax}</div>`;
                    }
                }

                // 角色级限制
                if (map.limitType === 'per_char') {
                    // 1+1 CharCap check
                    let effectiveN = charCount;
                    if(map.charCap) effectiveN = Math.min(charCount, map.charCap);
                    const charMax = map.limit * effectiveN;
                    
                    if (val > charMax) {
                        isOverLimit = true;
                        const charTag = el.parentElement.querySelector('.limit-tag-char');
                        if(charTag) {
                            charTag.style.display = 'inline';
                            charTag.innerText = `[超限: ${val}/${charMax}]`;
                            charTag.style.color = '#d32f2f';
                        }
                    } else {
                        // 正常情况下的 Tag 显示
                        const charTag = el.parentElement.querySelector('.limit-tag-char');
                        if(charTag && map.charCap && charCount > map.charCap) {
                             charTag.style.display = 'inline'; // 保持显示封顶提示
                        } else if (charTag) {
                             charTag.style.display = 'none';
                        }
                    }
                }

                // 组限制红框逻辑
                if (map.limitGroup) {
                    const max = map.limit * charCount;
                    if (groupSums[map.limitGroup] > max) isOverLimit = true;
                }

                if (isOverLimit) el.classList.add('error');
                else if (!map.limitGroup || groupSums[map.limitGroup] <= map.limit * charCount) {
                    el.classList.remove('error');
                }

                totalRawXP += val * map.xp;
            });
            
            // 更新该分类的 PL 统计 (仅非团本显示)
            const plTag = document.getElementById(`group-pl-${catIndex}`);
            if (plTag) plTag.innerText = `${catTotalPL} PL`;

            let remainingRaw = totalRawXP;
            let actualXP = 0;
            let currentTierInfo = catData.thresholds[0];
            let nextLimit = 0;
            let prevLimit = 0;
            let breakdownHtml = '';
            let progressBarHtml = '';
            const visualMax = catData.thresholds[catData.thresholds.length - 2].limit * 1.25;

            for (let i = 0; i < catData.thresholds.length; i++) {
                let tier = catData.thresholds[i];
                let tierCap = tier.limit - prevLimit;
                let rawNeededForTier = tierCap / tier.rate; 
                let xpGainedInThisTier = 0;
                const colorCfg = getColorConfig(tier.rate);

                if (remainingRaw <= rawNeededForTier) {
                    xpGainedInThisTier = remainingRaw * tier.rate;
                    actualXP += xpGainedInThisTier;
                    currentTierInfo = tier;
                    nextLimit = tier.limit;
                    if (xpGainedInThisTier > 0) {
                        breakdownHtml += `<div class="breakdown-item ${colorCfg.textClass}"><span>${tier.label}</span> <span>+${Math.round(xpGainedInThisTier)}</span></div>`;
                    }
                    let pct = (xpGainedInThisTier / visualMax) * 100;
                    progressBarHtml += `<div class="progress-segment ${colorCfg.bgClass}" style="width:${pct}%"></div>`;
                    remainingRaw = 0;
                    break;
                } else {
                    xpGainedInThisTier = tierCap;
                    actualXP += xpGainedInThisTier;
                    remainingRaw -= rawNeededForTier;
                    prevLimit = tier.limit;
                    breakdownHtml += `<div class="breakdown-item ${colorCfg.textClass}" style="opacity:0.7"><span>${tier.label} (满)</span> <span>+${Math.round(xpGainedInThisTier)}</span></div>`;
                    let pct = (xpGainedInThisTier / visualMax) * 100;
                    progressBarHtml += `<div class="progress-segment ${colorCfg.bgClass}" style="width:${pct}%"></div>`;
                }
            }

            document.getElementById(`val-curr-${catIndex}`).innerText = Math.round(actualXP);
            document.getElementById(`val-limit-${catIndex}`).innerText = nextLimit;
            let gapEffective = Math.max(0, nextLimit - actualXP);
            document.getElementById(`val-gap-${catIndex}`).innerText = Math.round(gapEffective);
            
            let tierText = `本阶段余量 (${Math.round(currentTierInfo.rate * 100)}%)`;
            if(currentTierInfo.rate <= 0.01) tierText = "本阶段余量 (1%)";
            document.getElementById(`label-gap-${catIndex}`).innerText = tierText;

            document.getElementById(`breakdown-${catIndex}`).innerHTML = breakdownHtml;
            document.getElementById(`bar-container-${catIndex}`).innerHTML = progressBarHtml;
            
            const adviceDiv = document.getElementById(`advice-text-${catIndex}`);
            const adviceColorCfg = getColorConfig(currentTierInfo.rate);
            if (currentTierInfo.rate <= 0.01) {
                adviceDiv.innerHTML = `<span class="text-black">收益已耗尽 (1%)，本周建议停止。</span>`;
            } else {
                let gapRaw = gapEffective / currentTierInfo.rate;
                const benchSelect = document.getElementById(`bench-${catIndex}`);
                const benchXP = parseInt(benchSelect.options[benchSelect.selectedIndex].value);
                const benchName = benchSelect.options[benchSelect.selectedIndex].text;
                let runsNeeded = Math.ceil(gapRaw / benchXP);
                adviceDiv.innerHTML = `距离下一阶段 (<span class="${adviceColorCfg.textClass}">${currentTierInfo.label}</span>) 约刷 <b>${runsNeeded}</b> 次 [${benchName}]`;
            }

            currentWeekValidXP[catIndex] = actualXP;
        });

        updatePLUI(currentTotalPL, totalMaxPL);
        updateGrandTotal();
        if (shouldSave) triggerAutoSave();
    }

    function updatePLUI(used, max) {
        const fill = document.getElementById('pl-bar-fill');
        const text = document.getElementById('pl-used');
        const warn = document.getElementById('pl-warning');
        
        text.innerText = used;
        const pct = Math.min((used / max) * 100, 100);
        fill.style.width = pct + '%';

        if (used > max) {
            fill.style.backgroundColor = '#c62828'; // Red
            warn.style.display = 'inline';
        } else {
            fill.style.backgroundColor = '#00bcd4'; // Blue
            warn.style.display = 'none';
        }
    }
    
    function updateGrandTotal() {
        const thisWeekTotal = currentWeekValidXP.reduce((a, b) => a + b, 0);
        const totalXP = historicXP + thisWeekTotal;

        document.getElementById('grand-total-display').innerText = Math.floor(totalXP);

        let currentLevelInfo = levelTable[0];
        let xpAccumulated = 0; 
        let xpForNextLevel = 0;
        let isMaxLevel = false;

        for (let i = 0; i < levelTable.length; i++) {
            const lvlData = levelTable[i];
            const nextLvlData = levelTable[i+1];

            if (!nextLvlData) {
                currentLevelInfo = lvlData;
                isMaxLevel = true;
                break;
            }
            if (totalXP < xpAccumulated + nextLvlData.need) {
                currentLevelInfo = lvlData;
                xpForNextLevel = nextLvlData.need;
                break;
            }
            xpAccumulated += nextLvlData.need;
            currentLevelInfo = nextLvlData;
        }

        document.getElementById('display-lvl').innerText = currentLevelInfo.lvl;
        document.getElementById('display-skill').innerText = currentLevelInfo.skill + "%";
        document.getElementById('display-buff').innerText = currentLevelInfo.buff;
        document.getElementById('display-fame').innerText = currentLevelInfo.fame;
        document.getElementById('display-stats').innerText = currentLevelInfo.stats;

        const barFill = document.getElementById('lvl-bar-fill');
        const progressText = document.getElementById('lvl-progress-text');
        const nextInfoText = document.getElementById('lvl-next-info');

        if (isMaxLevel) {
            barFill.style.width = '100%';
            progressText.innerText = "已达最高等级";
            nextInfoText.innerText = "MAX";
        } else {
            const currentProgress = totalXP - xpAccumulated; 
            const target = xpForNextLevel; 
            const pct = Math.min((currentProgress / target) * 100, 100);
            barFill.style.width = pct + '%';
            progressText.innerText = `${Math.floor(currentProgress)} / ${target}`;
            
            const nextStat = levelTable[currentLevelInfo.lvl]; 
            if(nextStat) {
                const skillDiff = (nextStat.skill - currentLevelInfo.skill).toFixed(1);
                const buffDiff = nextStat.buff - currentLevelInfo.buff;
                const fameDiff = nextStat.fame - currentLevelInfo.fame;
                const statsDiff = nextStat.stats - currentLevelInfo.stats;

                nextInfoText.innerHTML = `
                    下级提升: 
                    技攻 <span class="lvl-next-highlight">+${skillDiff}%</span> | 
                    增益 <span class="lvl-next-highlight">+${buffDiff}</span> | 
                    名望 <span class="lvl-next-highlight">+${fameDiff}</span> |
                    四维 <span class="lvl-next-highlight">+${statsDiff}</span>
                `;
            }
        }
    }

    function settleCurrentWeek() {
        const thisWeekTotal = currentWeekValidXP.reduce((a, b) => a + b, 0);
        if (thisWeekTotal === 0 && !confirm("本周经验为 0，确定要直接跳过进入下一周吗？")) return;
        
        const plUsed = parseInt(document.getElementById('pl-used').innerText);
        const plMax = parseInt(document.getElementById('pl-max-dynamic').innerText);
        if (plUsed > plMax && !confirm(`⚠️ 本周 PL 消耗 (${plUsed}) 已超过上限 (${plMax})！\n确定要按此结算吗？`)) return;

        if (thisWeekTotal > 0 && !confirm(`即将结算【第${currentWeek}周】。\n\n本周获得有效经验：${Math.floor(thisWeekTotal)}\n这部分经验将永久保存，同时清空输入框以开始新的一周。\n\n确定吗？`)) return;

        saveStateToUndoStack();
        historicXP += thisWeekTotal;
        const logEntry = `第 ${currentWeek} 周: +${Math.floor(thisWeekTotal)} XP`;
        weekHistory.unshift(logEntry); 
        updateHistoryUI();
        currentWeek++;
        document.getElementById('week-display').innerText = `第 ${currentWeek} 周`;
        document.querySelectorAll('.week-in').forEach(el => el.value = '');
        calculate(true);
        updateUndoButtonState();
        alert("结算成功！已进入新的一周，上限已重置。");
    }

    function saveStateToUndoStack() {
        const currentInputs = {};
        document.querySelectorAll('.week-in').forEach(el => {
            currentInputs[el.id] = el.value;
        });
        const snapshot = {
            historicXP: historicXP,
            currentWeek: currentWeek,
            weekHistory: [...weekHistory], 
            inputs: currentInputs,
            charCount: charCount
        };
        undoStack.push(snapshot);
        if (undoStack.length > 50) undoStack.shift(); 
    }

    function undoLastWeek() {
        if (undoStack.length === 0) return alert("没有可以撤销的记录！");
        if(!confirm("确定要回退到上一周的状态吗？\n当前周的修改将会丢失。")) return;
        const prevState = undoStack.pop();
        historicXP = prevState.historicXP;
        currentWeek = prevState.currentWeek;
        weekHistory = prevState.weekHistory;
        charCount = prevState.charCount || 1; 
        
        document.getElementById('week-display').innerText = `第 ${currentWeek} 周`;
        document.getElementById('char-count').value = charCount;
        
        updateLimitsAndCalculate();
        updateHistoryUI();
        
        document.querySelectorAll('.week-in').forEach(el => el.value = ''); 
        for (const id in prevState.inputs) {
            const el = document.getElementById(id);
            if(el) el.value = prevState.inputs[id];
        }
        calculate(true);
        updateUndoButtonState();
        alert("已成功回退到上一周！");
    }

    function updateUndoButtonState() {
        const btn = document.getElementById('btn-undo');
        btn.disabled = undoStack.length === 0;
        btn.style.opacity = undoStack.length === 0 ? '0.5' : '1';
    }

    function updateHistoryUI() {
        const logDiv = document.getElementById('history-log');
        logDiv.innerHTML = weekHistory.map(item => `<div class="history-item"><span>${item}</span></div>`).join('');
    }

    function fullReset() {
        if(!confirm("⚠️ 警告：这将清除所有周次的历史数据和当前输入！\n\n确定要从零开始吗？")) return;
        localStorage.removeItem(STORAGE_KEY);
        location.reload();
    }

    const STORAGE_KEY = 'dnf_mist_xp_v11_1_responsive';

    function triggerAutoSave() {
        const msg = document.getElementById('save-msg');
        msg.classList.add('show');
        clearTimeout(saveTimeout);
        saveTimeout = setTimeout(() => msg.classList.remove('show'), 2000);
        
        const saveData = {
            historicXP: historicXP,
            currentWeek: currentWeek,
            weekHistory: weekHistory,
            undoStack: undoStack,
            charCount: charCount,
            inputs: {},
            benchmarks: {}
        };
        
        dungeonsData.forEach((cat, cIdx) => {
            cat.maps.forEach((_, mIdx) => { 
                const id = `in-${cIdx}-${mIdx}`;
                saveData.inputs[id] = document.getElementById(id).value;
            });
            saveData.benchmarks[`bench-${cIdx}`] = document.getElementById(`bench-${cIdx}`).selectedIndex;
        });
        
        localStorage.setItem(STORAGE_KEY, JSON.stringify(saveData));
    }

    function loadSavedData() {
        const saved = localStorage.getItem(STORAGE_KEY);
        if (saved) {
            try {
                const data = JSON.parse(saved);
                historicXP = data.historicXP || 0;
                currentWeek = data.currentWeek || 1;
                weekHistory = data.weekHistory || [];
                undoStack = data.undoStack || [];
                charCount = data.charCount || 1;
                
                document.getElementById('week-display').innerText = `第 ${currentWeek} 周`;
                document.getElementById('char-count').value = charCount;
                
                updateHistoryUI();
                updateUndoButtonState();

                if (data.inputs) {
                    for (const key in data.inputs) {
                        const el = document.getElementById(key);
                        if (el) el.value = data.inputs[key]; 
                    }
                }
                if (data.benchmarks) {
                    for (const key in data.benchmarks) {
                        const el = document.getElementById(key);
                        if (el) el.selectedIndex = data.benchmarks[key];
                    }
                }
            } catch(e) { console.error("读取存档失败", e); }
        }
        updateLimitsAndCalculate();
    }
    
    loadSavedData();
</script>
<script src="https://beacon.cdn.qq.com/sdk/4.5.1/beacon_web.min.js"></script>
<script src="//tools.bbs.colg.cn/common/js/colgdata.js?t=20240701"></script>
</body>
</html>