麦田寓言

import sys
import json
import random
import datetime

# ---------- 工具函数 ----------
def get_beijing_time():
    """获取北京时间（UTC+8）"""
    return datetime.datetime.utcnow() + datetime.timedelta(hours=8)

def reset_times_if_needed(storage):
    """每天6点重置剩余次数为2"""
    beijing = get_beijing_time()
    today_str = beijing.strftime("%Y-%m-%d")
    last = storage.get("last_reset_date", "")
    if last != today_str:
        storage["last_reset_date"] = today_str
        storage["remain_times"] = 2
    return storage

# ---------- 游戏核心函数 ----------
def start_new_game(storage, user_id, nickname):
    """开始新一局，消耗一次次数"""
    if storage.get("remain_times", 0) <= 0:
        return storage, None, "今日游戏次数已用完，请明天再试！"
    
    storage["remain_times"] -= 1
    game = {
        "in_game": True,
        "bet": 2000,
        "step": "player_redraw",
        "player_number": random.randint(1, 100),
        "player_redraws_used": 0,
        "judge_number": 0,
        "judge_redraws_used": 0,
        "total_score": storage.get("total_score", 0),
        "highest_score": storage.get("highest_score", 0)
    }
    storage["game"] = game
    msg = (f"🎯 新游戏开始！\n"
           f"你的数字：{game['player_number']}\n"
           f"剩余重抽次数：{3 - game['player_redraws_used']}\n"
           f"请发送「重抽」或「保留」")
    return storage, None, msg

def process_player_redraw(storage, global_data, action):
    game = storage["game"]
    if action == "重抽":
        if game["player_redraws_used"] >= 3:
            return storage, global_data, "重抽次数已用完，请选择「保留」。"
        game["player_number"] = random.randint(1, 100)
        game["player_redraws_used"] += 1
        left = 3 - game["player_redraws_used"]
        msg = f"🔄 重抽成功！新数字：{game['player_number']}\n剩余重抽：{left} 次"
        return storage, global_data, msg + "\n请发送「重抽」或「保留」"
    
    elif action == "保留":
        # 进入裁判抽签
        game["step"] = "judge_draw"
        return process_judge_draw(storage, global_data)
    
    else:
        return storage, global_data, "无效指令，请发送「重抽」或「保留」"

def process_judge_draw(storage, global_data):
    game = storage["game"]
    player_num = game["player_number"]
    judge_num = random.randint(1, 100)
    judge_redraws = 0
    # 裁判重抽：若 ≤ 玩家数字且未用尽重抽次数
    while judge_num <= player_num and judge_redraws < 2:
        judge_num = random.randint(1, 100)
        judge_redraws += 1
    game["judge_number"] = judge_num
    game["judge_redraws_used"] = judge_redraws

    # 判定胜负（平局算玩家赢）
    if judge_num <= player_num:
        game["step"] = "result_win"
        msg = (f"🏆 你赢了！\n"
               f"裁判数字：{judge_num}\n"
               f"你的数字：{player_num}\n"
               f"本局赢得积分：{game['bet']}\n"
               f"请选择「结算」领取积分，或「加倍」继续（投注翻倍）")
        return storage, global_data, msg
    else:
        # 玩家输
        game["step"] = "result_lose"
        storage["game"] = {"in_game": False}  # 清除游戏状态
        msg = f"💔 你输了！\n裁判数字：{judge_num}\n你的数字：{player_num}\n游戏结束。"
        return storage, global_data, msg

def process_result(storage, global_data, action, user_id, nickname):
    game = storage["game"]
    if action == "结算":
        # 获得积分
        gain = game["bet"]
        total = storage.get("total_score", 0) + gain
        highest = max(storage.get("highest_score", 0), gain)
        storage["total_score"] = total
        storage["highest_score"] = highest
        # 更新全局排行榜
        leaderboard = global_data.get("leaderboard", {})
        if user_id not in leaderboard:
            leaderboard[user_id] = {"total": 0, "highest": 0, "nickname": nickname}
        leaderboard[user_id]["total"] = total
        leaderboard[user_id]["highest"] = highest
        leaderboard[user_id]["nickname"] = nickname
        global_data["leaderboard"] = leaderboard
        # 清除游戏
        storage["game"] = {"in_game": False}
        msg = (f"✅ 结算成功！获得 {gain} 积分。\n"
               f"总积分：{total}\n"
               f"单局最高：{highest}")
        return storage, global_data, msg
    
    elif action == "加倍":
        # 投注翻倍，重新开始玩家抽签（不消耗次数）
        game["bet"] *= 2
        game["step"] = "player_redraw"
        game["player_number"] = random.randint(1, 100)
        game["player_redraws_used"] = 0
        game["judge_number"] = 0
        game["judge_redraws_used"] = 0
        msg = (f"🚀 加倍继续！\n"
               f"当前投注：{game['bet']}\n"
               f"新数字：{game['player_number']}\n"
               f"剩余重抽：3 次\n"
               f"请发送「重抽」或「保留」")
        return storage, global_data, msg
    
    else:
        return storage, global_data, "无效指令，请发送「结算」或「加倍」"

def process_leaderboard(global_data):
    """生成排行榜文本"""
    lb = global_data.get("leaderboard", {})
    if not lb:
        return "📊 暂无排行榜数据。"
    
    # 按总积分排序
    total_sorted = sorted(lb.items(), key=lambda x: x[1].get("total", 0), reverse=True)
    # 按单局最高分排序
    highest_sorted = sorted(lb.items(), key=lambda x: x[1].get("highest", 0), reverse=True)
    
    lines = ["===== 🏅 总积分排行榜 ====="]
    for i, (uid, data) in enumerate(total_sorted[:10], 1):
        nick = data.get("nickname", "未知")
        lines.append(f"{i}. {nick} ({uid})：{data.get('total', 0)}")
    lines.append("\n===== ⭐ 单局最高分排行榜 =====")
    for i, (uid, data) in enumerate(highest_sorted[:10], 1):
        nick = data.get("nickname", "未知")
        lines.append(f"{i}. {nick} ({uid})：{data.get('highest', 0)}")
    return "\n".join(lines)

# ---------- 主程序 ----------
def main():
    # 1. 读取输入
    raw_input = sys.stdin.read().strip().split('\n')
    if not raw_input:
        # 无输入，直接结束
        print(json.dumps({"content": "没有输入数据", "storage": "{}", "global": "{}"}))
        return
    
    # 第一行是框架提供的 JSON，包含 storage、global、userID 等
    try:
        input_obj = json.loads(raw_input[0])
    except:
        input_obj = {}
    
    # 解析 storage 和 global（它们都是字符串）
    storage_str = input_obj.get("storage", "{}")
    global_str = input_obj.get("global", "{}")
    try:
        storage = json.loads(storage_str) if storage_str else {}
    except:
        storage = {}
    try:
        global_data = json.loads(global_str) if global_str else {}
    except:
        global_data = {}
    
    # 用户信息
    user_id = input_obj.get("userID")
    nickname = input_obj.get("nickname", "未知")
    
    # 第二行开始为用户指令
    action = raw_input[1] if len(raw_input) > 1 else ""
    
    # 2. 初始化存储默认值
    storage.setdefault("last_reset_date", "")
    storage.setdefault("remain_times", 2)
    storage.setdefault("total_score", 0)
    storage.setdefault("highest_score", 0)
    storage.setdefault("game", {"in_game": False})
    
    # 3. 重置每日次数（北京时间6点）
    storage = reset_times_if_needed(storage)
    
    # 4. 处理指令
    response = ""
    new_storage = storage
    new_global = global_data
    game = storage.get("game", {})
    in_game = game.get("in_game", False)
    
    if action == "排行榜":
        response = process_leaderboard(global_data)
        # 不修改状态
    elif not in_game:
        # 无游戏，开始新游戏
        new_storage, new_global, response = start_new_game(storage, user_id, nickname)
    else:
        step = game.get("step", "")
        if step == "player_redraw":
            new_storage, new_global, response = process_player_redraw(storage, global_data, action)
        elif step == "result_win":
            new_storage, new_global, response = process_result(storage, global_data, action, user_id, nickname)
        elif step == "result_lose":
            # 理论上不会进入，但以防万一
            storage["game"] = {"in_game": False}
            new_storage = storage
            response = "游戏已结束，输入任何指令重新开始。"
        else:
            response = "未知游戏状态，请重新开始。"
            storage["game"] = {"in_game": False}
            new_storage = storage
    
    # 5. 构造输出 JSON
    output = {
        "content": response,
        "storage": json.dumps(new_storage, ensure_ascii=False),
        "global": json.dumps(new_global, ensure_ascii=False)
    }
    print(json.dumps(output, ensure_ascii=False))

if __name__ == "__main__":
    main()