# cron: 19 12,20 * * *
# const $ = new Env("顺丰2026世界杯活动");
"""

顺丰2026世界杯活动 - 射门游戏 + 比赛竞猜 + 每日礼物
Author: Auto-generated (参考端午活动脚本)
Version: 1.2.1
Date: 2026-07-07

更新日志:
  1.2.1 (2026-07-07) 修复多变量解析：支持青龙同名变量换行分隔，兼容 & 分隔
  1.2.0 (2026-07-06) 优化邀请逻辑：支持列表内账号互相邀请，显示已邀请好友列表
  1.1.0 (2026-07-04) 新增下注结算(settleBet)阶段、赔率显示、潜在收益/今日盈亏列
  1.0.0 (2026-07-03) 初版：每日礼物 + 任务(白名单) + 射门游戏 + 比赛下注

活动周期: 2026-07-02 ~ 2026-07-20
货币: GOLD_COIN (金币)
活动码: WORLD_CUP

"""

import hashlib
import json
import os
import random
import re
import time
from datetime import datetime
from typing import Dict, List, Optional, Any
from urllib.parse import unquote
from concurrent.futures import ThreadPoolExecutor, as_completed
from threading import Lock
import requests
from requests.packages.urllib3.exceptions import InsecureRequestWarning

requests.packages.urllib3.disable_warnings(InsecureRequestWarning)

inviteId = []  # 运行时从账号列表动态提取

PROXY_TIMEOUT = 15
MAX_PROXY_RETRIES = 5
REQUEST_RETRY_COUNT = 3
CONCURRENT_NUM = int(os.getenv('SFBF', '1'))
if CONCURRENT_NUM > 20:
    CONCURRENT_NUM = 20
elif CONCURRENT_NUM < 1:
    CONCURRENT_NUM = 1

# 代理开关（默认启用）
ENABLE_PROXY = os.getenv('ENABLE_PROXY', 'true').lower() == 'true'

print_lock = Lock()

ACTIVITY_CODE = "WORLD_CUP"
TOKEN = 'wwesldfs29aniversaryvdld29'
SYS_CODE = 'MCS-MIMP-CORE'

CURRENCY_NAMES = {'GOLD_COIN': '金币'}
CHANNEL = '26sjbapp'
PLATFORM = 'SFAPP'
CITY_CODE = '021'

# ===== 活动阶段开关（True=开启 / False=关闭）=====
ENABLE_DAILY_GIFT = True   # 每日礼物
ENABLE_TASKS      = True   # 任务（仅执行 AUTO_FINISH_TASK_CODES 白名单里的）
ENABLE_GAME       = True   # 射门游戏
ENABLE_BET        = True   # 比赛竞猜（下注）
ENABLE_SETTLE     = True   # 下注结算（早上跑完后，结算前一天已开赛的下注盈亏）

# ===== 下注参数 =====
# 服务端最低下注金币为 10，< 10 会报 notSuccess。修改前请先抓包确认下限。
BET_COIN = 10  # 每场比赛下注金币数

SKIP_TASK_TYPES = [
    'BUY_ADD_VALUE_SERVICE_PACKET',
    'SEND_INTERNATIONAL_PACKAGE',
    'LOOK_BIG_PACKAGE_GET_CASH',
    'SEND_SUCCESS_RECALL',
    'CHARGE_NEW_EXPRESS_CARD',
    'CHARGE_COLLECT_ALL',
    'OPEN_FAMILY_HOME_MUTUAL',
    'INVITEFRIENDS_PARTAKE_ACTIVITY',
    'BROWSE_INTEGRAL_PLANET',
    'BROWSE_FAMILY_HOME_MUTUAL',
]
# 浏览类任务一律跳过（含 BROWSE_/VIEWPAGE_ 前缀），不发起 finishTask
SKIP_TASK_PREFIXES = ('BROWSE_', 'VIEWPAGE_')

# 仅对这些 taskCode 直接调用 finishTask
AUTO_FINISH_TASK_CODES = {
    '0CD7AFA68009402DBE5BF9D3C10D0115',  # 浏览积分商城（验证通过）
    '895011E183CE4E61BBACE8A63B98596A',  # 去看看互寄8折权益（未验证，可移除）
}


class Logger:
    def __init__(self):
        self.messages: List[str] = []
        self.lock = Lock()

    def _log(self, icon: str, msg: str):
        line = f"{icon} {msg}"
        with print_lock:
            print(line)
        with self.lock:
            self.messages.append(line)

    def info(self, msg): self._log('📝', msg)
    def success(self, msg): self._log('✅', msg)
    def warning(self, msg): self._log('⚠️', msg)
    def error(self, msg): self._log('❌', msg)
    def task(self, msg): self._log('🎯', msg)
    def goal(self, msg): self._log('⚽', msg)


class ProxyManager:
    def __init__(self, api_url: str):
        self.api_url = api_url

    def get_proxy(self) -> Optional[Dict[str, str]]:
        # 如果代理开关关闭，直接返回 None
        if not ENABLE_PROXY:
            return None
        try:
            if not self.api_url:
                return None
            response = requests.get(self.api_url, timeout=10)
            if response.status_code == 200:
                # 尝试解析 JSON
                try:
                    data = response.json()
                    if 'data' in data and 'list' in data['data'] and data['data']['list']:
                        proxy_info = data['data']['list'][0]
                        ip = proxy_info.get('ip')
                        port = proxy_info.get('port')
                        if ip and port:
                            proxy = f'http://{ip}:{port}'
                            with print_lock:
                                print(f"✅ 获取代理: {proxy}")
                            return {'http': proxy, 'https': proxy}
                except (json.JSONDecodeError, KeyError, IndexError):
                    # 不是 JSON，按纯文本处理（兼容旧格式）
                    proxy_text = response.text.strip()
                    if ':' in proxy_text:
                        proxy = proxy_text if proxy_text.startswith('http') else f'http://{proxy_text}'
                        display = proxy
                        if '@' in proxy:
                            parts = proxy.split('@')
                            display = f"http://***:***@{parts[-1]}"
                        with print_lock:
                            print(f"✅ 获取代理: {display}")
                        return {'http': proxy, 'https': proxy}
                with print_lock:
                    print(f"❌ 获取代理失败: 无法解析代理数据")
                return None
            with print_lock:
                print(f"❌ 获取代理失败: HTTP {response.status_code}")
            return None
        except Exception as e:
            with print_lock:
                print(f"❌ 获取代理异常: {str(e)[:100]}")
            return None


class SFHttpClient:
    def __init__(self, proxy_manager: ProxyManager):
        self.proxy_manager = proxy_manager
        self.session = requests.Session()
        self.session.verify = False

        # 根据开关决定是否尝试获取代理
        if ENABLE_PROXY:
            proxy = self.proxy_manager.get_proxy()
            if proxy:
                self.session.proxies = proxy
            else:
                if self.proxy_manager.api_url:
                    with print_lock:
                        print("⚠️ 代理获取失败，将不使用代理")

        self.headers = {
            'Host': 'mcs-mimp-web.sf-express.com',
            'User-Agent': 'Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 mediaCode=SFEXPRESSAPP-iOS-ML',
            'Accept': 'application/json, text/plain, */*',
            'Content-Type': 'application/json',
            'channel': CHANNEL,
            'platform': PLATFORM,
            'accept-language': 'zh-CN,zh;q=0.9',
        }

    def _generate_sign(self) -> Dict[str, str]:
        timestamp = str(int(round(time.time() * 1000)))
        data = f'token={TOKEN}&timestamp={timestamp}&sysCode={SYS_CODE}'
        signature = hashlib.md5(data.encode()).hexdigest()
        return {
            'sysCode': SYS_CODE,
            'timestamp': timestamp,
            'signature': signature,
        }

    def request(self, url: str, data: Optional[Dict] = None, method: str = 'POST') -> Optional[Dict]:
        retry_count = 0
        max_proxy_retries = MAX_PROXY_RETRIES if ENABLE_PROXY else 1
        proxy_retry_count = 0

        while proxy_retry_count < max_proxy_retries:
            sign_data = self._generate_sign()
            headers = {**self.headers, **sign_data}

            try:
                if method == 'POST':
                    resp = self.session.post(url, headers=headers, json=data or {}, timeout=PROXY_TIMEOUT)
                else:
                    resp = self.session.get(url, headers=headers, timeout=PROXY_TIMEOUT)
                resp.raise_for_status()

                try:
                    result = resp.json()
                    if result is None:
                        retry_count += 1
                        if retry_count < REQUEST_RETRY_COUNT:
                            time.sleep(2)
                            continue
                        return None
                    return result
                except (json.JSONDecodeError, ValueError):
                    retry_count += 1
                    if retry_count < REQUEST_RETRY_COUNT:
                        time.sleep(2)
                        continue
                    return None

            except requests.exceptions.RequestException as e:
                retry_count += 1
                error_str = str(e)

                if ENABLE_PROXY and ('ProxyError' in error_str or 'SSLError' in error_str or 'ConnectionError' in error_str):
                    proxy_retry_count += 1
                    if proxy_retry_count < MAX_PROXY_RETRIES:
                        new_proxy = self.proxy_manager.get_proxy()
                        if new_proxy:
                            self.session.proxies = new_proxy
                        retry_count = 0
                    time.sleep(2)
                    continue

                if retry_count < REQUEST_RETRY_COUNT:
                    time.sleep(2)
                    continue
                return None

            except Exception:
                return None

        return None

    def login(self, url: str) -> tuple:
        try:
            decoded_input = unquote(url)
            if decoded_input.startswith('sessionId=') or '_login_mobile_=' in decoded_input:
                cookie_dict = {}
                for item in decoded_input.split(';'):
                    item = item.strip()
                    if '=' in item:
                        k, v = item.split('=', 1)
                        cookie_dict[k] = v
                for k, v in cookie_dict.items():
                    self.session.cookies.set(k, v, domain='mcs-mimp-web.sf-express.com')
                user_id = cookie_dict.get('_login_user_id_', '')
                phone = cookie_dict.get('_login_mobile_', '')
                return (True, user_id, phone) if phone else (False, '', '')
            else:
                self.session.get(unquote(url), headers=self.headers, timeout=PROXY_TIMEOUT)
                cookies = self.session.cookies.get_dict()
                user_id = cookies.get('_login_user_id_', '')
                phone = cookies.get('_login_mobile_', '')
                return (True, user_id, phone) if phone else (False, '', '')
        except Exception as e:
            print(f'登录异常: {str(e)}')
            return False, '', ''


class WorldCupExecutor:
    BASE_URL = 'https://mcs-mimp-web.sf-express.com/mcs-mimp'

    def __init__(self, http: SFHttpClient, logger: Logger, user_id: str, invite_pool: list = None):
        self.http = http
        self.logger = logger
        self.user_id = user_id
        self.invite_pool = invite_pool or []
        self.level_list: List[Dict] = []

    def _post(self, path: str, data: Optional[Dict] = None) -> Optional[Dict]:
        url = f'{self.BASE_URL}{path}'
        return self.http.request(url, data=data or {})

    def get_activity_index(self) -> Optional[Dict]:
        resp = self._post('/commonPost/~memberNonactivity~worldCupIndexService~index')
        if resp and resp.get('success'):
            return resp.get('obj', {})
        return None

    def get_game_index(self) -> Optional[Dict]:
        resp = self._post('/commonPost/~memberNonactivity~worldCupGameService~index')
        if resp and resp.get('success'):
            return resp.get('obj', {})
        return None

    def get_bet_status(self) -> Optional[Dict]:
        resp = self._post('/commonPost/~memberNonactivity~worldCupMatchService~betStatus')
        if resp and resp.get('success'):
            return resp.get('obj', {})
        return None

    def get_daily_gift_status(self) -> Optional[Dict]:
        data = {"cityCode": CITY_CODE}
        resp = self._post('/commonPost/~memberNonactivity~worldCupDailyService~getDailyGiftStatus', data)
        if resp and resp.get('success'):
            return resp.get('obj', {})
        return None

    def receive_daily_gift(self) -> Optional[Dict]:
        data = {"cityCode": CITY_CODE}
        resp = self._post('/commonPost/~memberNonactivity~worldCupDailyService~receiveDailyGift', data)
        if resp and resp.get('success'):
            return resp.get('obj', {})
        return None

    def get_task_list(self) -> Optional[List[Dict]]:
        data = {"activityCode": ACTIVITY_CODE, "channelType": PLATFORM}
        resp = self._post('/commonPost/~memberNonactivity~activityTaskService~taskList', data)
        if resp and resp.get('success'):
            return resp.get('obj', [])
        return None

    def finish_task(self, task_code: str) -> bool:
        url = f'{self.BASE_URL}/commonPost/~memberEs~taskRecord~finishTask'
        data = {"taskCode": task_code}
        resp = self.http.request(url, data=data)
        return bool(resp and resp.get('success'))

    def fetch_task_reward(self) -> Optional[Dict]:
        data = {"channelType": PLATFORM, "activityCode": ACTIVITY_CODE}
        resp = self._post('/commonPost/~memberNonactivity~worldCupTaskService~fetchTaskReward', data)
        if resp and resp.get('success'):
            return resp.get('obj', {})
        return None

    def report_pass(self, level: int, shot_num: int) -> Optional[Dict]:
        data = {"level": level, "shotNum": shot_num}
        resp = self._post('/commonPost/~memberNonactivity~worldCupGameService~passReport', data)
        if resp and resp.get('success'):
            return resp.get('obj', {})
        err = resp.get('errorMessage', '未知错误') if resp else '请求失败'
        self.logger.warning(f'第{level}关上报失败: {err}')
        return None

    def place_bet(self, match_id: str, bet_result: int, bet_coin: int) -> bool:
        """下注
        bet_result: 0=主胜 1=平 2=客胜 (与 odds 数组顺序一致)
        bet_coin: 下注金币数
        """
        data = {"matchId": match_id, "betResult": bet_result, "betCoin": bet_coin}
        resp = self._post('/commonPost/~memberNonactivity~worldCupMatchService~placeBet', data)
        if resp and resp.get('success'):
            return True
        err = resp.get('errorMessage', '未知错误') if resp else '请求失败'
        self.logger.warning(f'下注失败(match={match_id}, result={bet_result}): {err}')
        return False

    def settle_bet(self) -> Optional[list]:
        """结算下注
        返回已开赛并结算的下注列表；空数组表示今天没有可结算的
        """
        resp = self._post('/commonPost/~memberNonactivity~worldCupMatchService~settleBet', {})
        if resp and resp.get('success'):
            return resp.get('obj', []) or []
        err = resp.get('errorMessage', '未知错误') if resp else '请求失败'
        self.logger.warning(f'结算请求失败: {err}')
        return None

    # ========== 邀请相关方法 ==========
    def do_invite(self):
        """列表内账号互相邀请"""
        try:
            pool = self.invite_pool if self.invite_pool else inviteId
            available_invites = [inv for inv in pool if inv != self.user_id]
            if not available_invites:
                self.logger.warning("没有可用的邀请对象（排除自身后为空），跳过邀请")
                return
            random_invite = random.choice(available_invites)
            url = f'{self.BASE_URL}/commonPost/~memberNonactivity~worldCupIndexService~index'
            data = {"inviteType": 1, "inviteUserId": random_invite}
            resp = self.http.request(url, data=data)
            if resp and resp.get('success'):
                self.logger.success(f"已向邀请对象发起邀请 (userId: {random_invite})")
            else:
                err = resp.get('errorMessage', '未知错误') if resp else '请求失败'
                self.logger.warning(f"邀请失败: {err}")
        except Exception as e:
            self.logger.error(f"邀请初始化异常: {str(e)}")

    def get_invite_list(self) -> Optional[List[Dict]]:
        """查询已邀请好友列表"""
        resp = self._post('/commonPost/~memberNonactivity~worldCupTaskService~taskInviteList', {})
        if resp and resp.get('success'):
            return resp.get('obj', [])
        err = resp.get('errorMessage', '未知错误') if resp else '请求失败'
        self.logger.warning(f"查询邀请列表失败: {err}")
        return None

    def do_show_invite_list(self) -> None:
        """查询并显示已邀请好友列表"""
        invite_list = self.get_invite_list()
        if invite_list:
            self.logger.success(f"已邀请 {len(invite_list)} 位好友：")
            for i, friend in enumerate(invite_list, 1):
                mobile = friend.get('mobile', '未知')
                invite_date = friend.get('inviteDate', '未知')
                if len(mobile) >= 7:
                    mobile_masked = mobile[:3] + "****" + mobile[7:]
                else:
                    mobile_masked = mobile
                self.logger.info(f"  {i}. {mobile_masked} (邀请时间: {invite_date})")
        else:
            self.logger.info("暂无已邀请好友")
    # =================================

    def do_daily_gift(self, result: Dict) -> None:
        self.logger.task('[每日礼物] 检查状态...')
        status = self.get_daily_gift_status()
        if status is None:
            self.logger.warning('[每日礼物] 获取状态失败')
            return
        if status.get('received'):
            self.logger.success('[每日礼物] 今日已领取')
            return
        if not status.get('canReceive'):
            self.logger.info('[每日礼物] 今日不可领取')
            return
        self.logger.task('[每日礼物] 尝试领取...')
        if self.receive_daily_gift():
            self.logger.success('[每日礼物] 领取成功')
            result['daily_gift'] = True
        else:
            self.logger.warning('[每日礼物] 领取失败')

    def do_tasks(self, result: Dict) -> None:
        self.logger.info('正在获取世界杯活动任务列表...')
        tasks = self.get_task_list()
        if tasks is None:
            return
        self.logger.info(f'共发现 {len(tasks)} 个任务')

        for task in tasks:
            task_name = task.get('taskName', '未知')
            task_type = task.get('taskType', '')
            task_code = task.get('taskCode', '')
            status = task.get('status')
            rest_finish = task.get('restFinishTime', 0)
            can_receive = task.get('canReceiveTokenNum', 0)

            if task_code not in AUTO_FINISH_TASK_CODES:
                continue

            self.logger.info(f'[{task_name}]')

            if status == 3 or (status == 1 and rest_finish <= 0):
                self.logger.success(f'[{task_name}] 已完成')
                continue

            if self.finish_task(task_code):
                self.logger.success(f'[{task_name}] 完成成功')
                result['tasks_completed'] += 1
            else:
                self.logger.warning(f'[{task_name}] 完成失败')
            time.sleep(1)

    def do_fetch_rewards(self, result: Dict) -> None:
        self.logger.info('领取任务奖励...')
        reward_resp = self.fetch_task_reward()
        if reward_resp:
            received = reward_resp.get('receivedAccountList', [])
            if received:
                for item in received:
                    currency = item.get('currency', '')
                    amount = item.get('amount', 0)
                    self.logger.success(f'领取: {currency} x{amount}')
            else:
                self.logger.info('无新奖励可领取')

    def play_game(self, result: Dict) -> None:
        self.logger.info('⚽ 开始挑战射门游戏...')
        game_info = self.get_game_index()
        if game_info is None:
            self.logger.warning('获取游戏配置失败')
            return

        self.level_list = game_info.get('levelList', [])
        cur_stage = game_info.get('curStage', 1)
        cur_level = game_info.get('curLevel', 1)

        if not self.level_list:
            self.logger.warning('游戏关卡列表为空')
            return

        self.logger.info(f'当前进度: 第{cur_stage}阶段 第{cur_level}关')

        for level_cfg in self.level_list:
            level_no = level_cfg.get('level')
            target = level_cfg.get('target', 0)
            reward = level_cfg.get('rewardCoins', 0)

            if level_no < cur_level:
                continue

            self.logger.task(f'挑战第{level_no}关（目标 {target} 次进球，奖励 {reward} 金币）')

            pass_result = self.report_pass(level_no, target)

            attempts = 0
            while attempts < 3 and (pass_result is None or not pass_result.get('coinNum', 0) >= reward):
                time.sleep(1)
                pass_result = self.report_pass(level_no, target)
                attempts += 1

            if pass_result:
                result['stages_passed'].append({
                    'level': level_no,
                    'coins': pass_result.get('coinNum', 0),
                    'reward': reward,
                })
                result['game_coins'] += pass_result.get('coinNum', 0)
                self.logger.goal(f'第{level_no}关完成，获得 {pass_result.get("coinNum", 0)} 金币')
            else:
                self.logger.warning(f'第{level_no}关未通过')

    def do_bet(self, result: Dict) -> None:
        self.logger.info('⚽ 查询比赛竞猜状态...')
        bet_status = self.get_bet_status()
        if bet_status is None:
            return

        account = bet_status.get('currentAccount', {})
        balance = account.get('balance', 0)
        self.logger.info(f'当前金币余额: {balance}')

        matches = bet_status.get('matchList', [])
        pending = [
            m for m in matches
            if m.get('matchStatus') == 'Fixture' and m.get('recordStatus', 0) == 0
        ]
        self.logger.info(f'共 {len(matches)} 场比赛，{len(pending)} 场可下注')
        self.logger.info(f'单场下注: {BET_COIN} 金币')

        if balance < BET_COIN:
            self.logger.warning(f'余额不足 {BET_COIN} 金币，跳过下注')
            result['final_balance'] = balance
            result['final_total'] = account.get('totalAmount', 0)
            return

        choice_map = {0: '主胜', 1: '平', 2: '客胜'}

        for m in pending:
            match_id = m.get('matchId')
            team_a = m.get('teamAName', '?')
            team_b = m.get('teamBName', '?')
            odds_str = m.get('odds', '?,?,?')
            bet_result = random.randint(0, 2)

            try:
                odds_list = [float(x) for x in odds_str.split(',')]
                picked_odds = odds_list[bet_result] if bet_result < len(odds_list) else 0.0
            except (ValueError, IndexError):
                picked_odds = 0.0

            potential_payout = round(BET_COIN * picked_odds, 2)
            potential_profit = round(potential_payout - BET_COIN, 2)

            self.logger.task(
                f'下注: {team_a} vs {team_b}（赔率 {odds_str}）→ '
                f'{choice_map[bet_result]} {BET_COIN} 金币 '
                f'| 命中得 {potential_payout}（净赚 {potential_profit}）'
            )

            time.sleep(1)
            if self.place_bet(match_id, bet_result=bet_result, bet_coin=BET_COIN):
                self.logger.success(
                    f'下注成功: {team_a} vs {team_b}（赔率 {picked_odds}，命中得 {potential_payout}）'
                )
                result['bets_placed'] += 1
                result['bet_details'].append({
                    'match': f'{team_a} vs {team_b}',
                    'choice': choice_map[bet_result],
                    'odds': picked_odds,
                    'bet_coin': BET_COIN,
                    'potential_payout': potential_payout,
                    'potential_profit': potential_profit,
                })
            else:
                self.logger.warning(f'下注失败: {team_a} vs {team_b}')

        status_after = self.get_bet_status()
        if status_after:
            acc_after = status_after.get('currentAccount', {})
            result['final_balance'] = acc_after.get('balance', 0)
            result['final_total'] = acc_after.get('totalAmount', 0)
        else:
            result['final_balance'] = balance
            result['final_total'] = account.get('totalAmount', 0)

    def do_settle(self, result: Dict) -> None:
        """结算已开赛下注的实际盈亏"""
        self.logger.info('💰 结算昨日下注结果...')
        settled = self.settle_bet()
        if settled is None:
            self.logger.warning('结算接口失败，跳过')
            return

        if not settled:
            self.logger.info('今日无新结算记录')
            return

        choice_map = {0: '主胜', 1: '平', 2: '客胜'}

        total_pnl = 0
        wins = 0
        losses = 0

        for m in settled:
            match_id = m.get('matchId', '?')
            team_a = m.get('teamAName', '?')
            team_b = m.get('teamBName', '?')
            score = f"{m.get('teamAScore', '?')}:{m.get('teamBScore', '?')}"
            bet_coin = m.get('betCoin', 0)
            bet_result = m.get('betResult', -1)
            bet_odds_str = m.get('betOdds', '?,?,?')
            win_coin = m.get('betWinCoin', 0)

            pnl = win_coin - bet_coin
            total_pnl += pnl

            try:
                odds_list = [float(x) for x in bet_odds_str.split(',')]
                picked_odds = odds_list[bet_result] if 0 <= bet_result < len(odds_list) else 0.0
            except (ValueError, IndexError):
                picked_odds = 0.0

            if pnl > 0:
                wins += 1
                icon = '🎉'
                pnl_str = f'+{pnl}'
            elif pnl < 0:
                losses += 1
                icon = '💔'
                pnl_str = f'{pnl}'
            else:
                icon = '➖'
                pnl_str = '0'

            self.logger.info(
                f'  {icon} {team_a} vs {team_b}（{score}）→ '
                f'押{choice_map.get(bet_result, "?")} 赔率 {picked_odds} | '
                f'投 {bet_coin} 得 {win_coin} | {pnl_str}'
            )

            result['settle_details'].append({
                'match': f'{team_a} vs {team_b}',
                'score': score,
                'choice': choice_map.get(bet_result, '?'),
                'bet_coin': bet_coin,
                'win_coin': win_coin,
                'pnl': pnl,
            })

        result['settle_pnl'] = total_pnl
        result['settle_wins'] = wins
        result['settle_losses'] = losses

        if total_pnl > 0:
            self.logger.success(f'结算完成: {wins}胜{losses}负，净赚 +{total_pnl} 金币')
        elif total_pnl < 0:
            self.logger.warning(f'结算完成: {wins}胜{losses}负，净亏 {total_pnl} 金币')
        else:
            self.logger.info(f'结算完成: {wins}胜{losses}负，持平')

        status_after = self.get_bet_status()
        if status_after:
            acc_after = status_after.get('currentAccount', {})
            result['final_balance'] = acc_after.get('balance', 0)
            result['final_total'] = acc_after.get('totalAmount', 0)

    def show_status(self) -> None:
        self.logger.info('=' * 20 + '  世界杯活动状态  ' + '=' * 20)
        bet_status = self.get_bet_status()
        if bet_status:
            account = bet_status.get('currentAccount', {})
            self.logger.info(f'金币余额: {account.get("balance", 0)} / 累计: {account.get("totalAmount", 0)}')

        daily = self.get_daily_gift_status()
        if daily:
            status_str = '已领取' if daily.get('received') else ('可领取' if daily.get('canReceive') else '不可领取')
            self.logger.info(f'每日礼物: {status_str}')

        game = self.get_game_index()
        if game:
            self.logger.info(f'游戏阶段: 第{game.get("curStage", 1)}阶段 第{game.get("curLevel", 1)}关')

        index = self.get_activity_index()
        if index:
            self.logger.info(f'活动周期: {index.get("acStartTime", "")} ~ {index.get("acEndTime", "")}')
            self.logger.info(f'可领金币: {index.get("availableRewardCoins", 0)}')

        self.logger.info('=' * 56)

    def run(self) -> Dict[str, Any]:
        result = {
            'tasks_completed': 0,
            'game_coins': 0,
            'stages_passed': [],
            'daily_gift': False,
            'bets_placed': 0,
            'bet_details': [],
            'settle_pnl': 0,
            'settle_wins': 0,
            'settle_losses': 0,
            'settle_details': [],
            'final_balance': 0,
            'final_total': 0,
        }

        # 1. 邀请好友（先发起邀请）
        self.do_invite()

        # 2. 查询并显示已邀请好友列表
        self.do_show_invite_list()

        # 3. 获取活动首页信息
        index_info = self.get_activity_index()
        if index_info:
            self.logger.success(f'已加入世界杯活动，可领 {index_info.get("availableRewardCoins", 0)} 金币')

        if ENABLE_DAILY_GIFT:
            self.do_daily_gift(result)
        if ENABLE_TASKS:
            self.do_tasks(result)
            self.do_fetch_rewards(result)
        if ENABLE_GAME:
            self.play_game(result)
        if ENABLE_BET:
            self.do_bet(result)
        else:
            self.logger.info('⚽ [开关] 比赛下注已关闭，跳过')
        if ENABLE_SETTLE:
            self.do_settle(result)
        else:
            self.logger.info('💰 [开关] 下注结算已关闭，跳过')

        return result


def run_account(account_url: str, index: int, invite_pool: List[str]) -> Dict[str, Any]:
    logger = Logger()
    proxy_url = os.getenv('SF_PROXY_API_URL', '')
    proxy_manager = ProxyManager(proxy_url)

    http = SFHttpClient(proxy_manager)
    retry_count = 0
    login_success = False
    phone = ''
    user_id = ''

    while retry_count < MAX_PROXY_RETRIES and not login_success:
        try:
            if retry_count > 0:
                http = SFHttpClient(proxy_manager)
            success, user_id, phone = http.login(account_url)
            if success:
                login_success = True
                break
        except Exception:
            pass
        retry_count += 1
        if retry_count < MAX_PROXY_RETRIES:
            time.sleep(2)

    if not login_success:
        logger.error(f'账号{index + 1} 登录失败')
        return {
            'success': False, 'phone': '', 'index': index,
            'tasks_completed': 0, 'game_coins': 0, 'stages_passed': [],
            'daily_gift': False, 'bets_placed': 0, 'bet_details': [],
            'settle_pnl': 0, 'settle_wins': 0, 'settle_losses': 0, 'settle_details': [],
            'final_balance': 0, 'final_total': 0,
        }

    masked_phone = phone[:3] + "****" + phone[7:] if len(phone) >= 7 else phone
    logger.success(f'账号{index + 1}: 【{masked_phone}】登录成功')

    time.sleep(random.uniform(1, 3))

    executor = WorldCupExecutor(http, logger, user_id, invite_pool)
    activity_result = executor.run()

    return {
        'success': True,
        'phone': phone,
        'index': index,
        **activity_result,
    }


# ==================== 主程序（重写解析逻辑，支持同名多变量） ====================
def main():
    # 第一步：收集所有可能包含账号信息的环境变量
    raw_values = []
    for key, value in os.environ.items():
        if key == 'sfsyUrl' or key.startswith('sfsyUrl_'):
            raw_values.append(value)

    if not raw_values:
        print("❌ 未找到任何 sfsyUrl / sfsyUrl_* 环境变量，请检查青龙面板变量配置")
        return

    # 第二步：合并所有值，按 & 和 \n 分割
    combined = '&'.join(raw_values)
    parts = []
    for p in combined.split('&'):
        if '\n' in p:
            parts.extend(p.split('\n'))
        else:
            if p.strip():
                parts.append(p.strip())

    # 第三步：提取以 sessionId= 开头的有效账号字符串
    account_urls = []
    for p in parts:
        p = p.strip()
        if not p:
            continue
        if p.startswith('sessionId='):
            account_urls.append(p)
        elif 'sessionId=' in p:
            # 从第一个 sessionId= 开始截取
            idx = p.find('sessionId=')
            account_urls.append(p[idx:])

    # 第四步：去重（保留首次出现顺序）
    seen = set()
    unique_urls = []
    for u in account_urls:
        if u not in seen:
            seen.add(u)
            unique_urls.append(u)
    account_urls = unique_urls

    if not account_urls:
        print("❌ 未能解析出有效的账号 Cookie，请检查格式（应以 sessionId= 开头）")
        print(f"   原始输入片段: {combined[:200]}...")
        return

    # 第五步：提取邀请池（所有 user_id）
    invite_pool = []
    for url in account_urls:
        m = re.search(r'_login_user_id_=([A-Fa-f0-9]+)', url)
        if m:
            invite_pool.append(m.group(1))

    # 设置全局邀请池
    global inviteId
    inviteId = invite_pool

    # 打乱顺序，防止固定顺序触发风控
    random.shuffle(account_urls)

    print("=" * 60)
    print(f"⚽ 顺丰2026世界杯活动 - 射门挑战 + 比赛竞猜")
    print(f"👨‍💻 Author: Auto-generated")
    print(f"📱 共获取到 {len(account_urls)} 个账号")
    print(f"🤝 邀请池: {len(invite_pool)} 个账号")
    print(f"⚙️ 并发数量: {CONCURRENT_NUM}")
    print(f"🎯 阶段开关: 礼物={ENABLE_DAILY_GIFT} 任务={ENABLE_TASKS} 游戏={ENABLE_GAME} 下注={ENABLE_BET} 结算={ENABLE_SETTLE}")
    print(f"💰 单场下注: {BET_COIN} 金币（最低 10）")
    print(f"⏰ 执行时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
    print("=" * 60)

    all_results = []

    if CONCURRENT_NUM <= 1:
        for idx, url in enumerate(account_urls):
            result = run_account(url, idx, invite_pool)
            all_results.append(result)
            if idx < len(account_urls) - 1:
                print("-" * 60)
                time.sleep(2)
    else:
        with ThreadPoolExecutor(max_workers=CONCURRENT_NUM) as pool:
            futures = {pool.submit(run_account, url, idx, invite_pool): idx for idx, url in enumerate(account_urls)}
            for future in as_completed(futures):
                all_results.append(future.result())

    all_results.sort(key=lambda x: x['index'])

    print(f"\n" + "=" * 90)
    print(f"📊 世界杯活动汇总")
    print("=" * 90)
    print(f"{'序号':<6} {'手机号':<15} {'金币余额':<10} {'通关数':<6} {'下注数':<6} {'潜在收益':<10} {'今日盈亏':<10} {'每日礼物':<8}")
    print("-" * 100)

    total_balance = 0
    total_payout = 0.0
    total_pnl = 0

    for r in all_results:
        idx = r['index'] + 1
        phone = r['phone'][:3] + "****" + r['phone'][7:] if r.get('phone') and len(r['phone']) >= 7 else r.get('phone', '未登录')
        daily = '✅' if r.get('daily_gift') else '❌'
        balance = r.get('final_balance', 0)
        stages = len(r.get('stages_passed', []))
        bets = r.get('bets_placed', 0)
        payout = sum(d.get('potential_payout', 0) for d in r.get('bet_details', []))
        pnl = r.get('settle_pnl', 0)
        wins = r.get('settle_wins', 0)
        losses = r.get('settle_losses', 0)
        if wins + losses > 0:
            pnl_str = f'{pnl:+d} ({wins}胜{losses}负)'
        else:
            pnl_str = '-'
        total_payout += payout
        total_pnl += pnl
        total_balance += balance

        print(f"{idx:<6} {phone:<15} {balance:<10} {stages:<6} {bets:<6} {payout:<10} {pnl_str:<10} {daily:<8}")

    print("-" * 100)
    print(f"{'汇总':<6} {'账号: ' + str(len(all_results)):<15} 总金币余额: {total_balance} | 累计盈亏: {total_pnl:+d}")
    print("=" * 90)
    print("\n🎊 所有账号执行完成!")


if __name__ == '__main__':
    main()