# YYB-Go-Enhanced 适配说明：配置多行 YYB_SERVER=地址@账号标识 或 纯地址（自动拉取 /accounts）；通知兼容青龙/呆呆面板 notify.py。

# ==========================================================
# 功能说明：code 换 token（含缓存与自动刷新）
# 机制：yyb_go 自动获取存活账号并换取微信 code → 换取 token → 缓存到本地 JSON；
#       下次运行先读取缓存 token，并调用用户信息接口验证是否仍有效；
#       有效则直接复用（无需再获取 code）；失效或过期则重新获取 code 自动刷新。
# ==========================================================
# name: 白鲸鱼旧衣服回收
# cron: 5 9,20 * * *

"""
白鲸鱼旧衣服回收动态 code 版

功能：
  1. yyb_go 自动获取存活账号并换取微信 code
  2. /api/app/weapp.php 使用 code 换 token
  3. 每日签到
  4. 九宫格抽奖（任务卡动态领取）
  5. 福利任务自动处理（收藏小程序等）
  6. 成长值任务汇总
  7. 查询积分与余额
  8. 品赞代理，业务请求优先代理，失败直连兜底

环境变量：
  YYB_SERVER        YYB-Go-Enhanced 路由，每行：地址@账号标识 或 纯地址（自动请求 /accounts 拉取全部账号）
  账号直接来自 YYB_SERVER；无需配置 WX_ID
  BJY_blacklist     黑名单账号（昵称或 openid），逗号/分号/换行分隔，命中的跳过
  PROXY_API         品赞代理提取 API，可选
  PROXY_TYPE        http / socks5，默认 http
  BJY_CHANNEL_ID    渠道 ID，默认 wx1008
  BJY_OAID          设备 oaid，默认使用抓包中的值
  BJY_DRAW_MODE     task=任务卡动态抽奖，fixed=固定次数，默认 task
  BJY_DRAW_TIMES    固定模式抽奖次数，默认 1

依赖：
  pip install requests
  socks5 代理需：
  pip install requests[socks]
"""

import hashlib
import json
import os
import random
import re
import sys
import time
import traceback
from datetime import datetime
from typing import Any, Dict, List, Tuple
from urllib.parse import quote

import requests

# 将脚本所在目录加入搜索路径（确保能找到 yyb.py 等同目录模块）
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))

# ===== YYB-Go-Enhanced + QingLong standalone adapter =====
def _yyb_fetch_accounts(server: str) -> List[Dict[str, str]]:
    """请求 GET /accounts 拉取全部账号，兼容 {code,msg,data} 包装与直接数组返回。"""
    import requests as _requests
    response = _requests.get(server.rstrip("/") + "/accounts", timeout=15)
    response.raise_for_status()
    body = response.json()
    if isinstance(body, dict):
        if int(body.get("code", -1)) != 0:
            raise RuntimeError(f"/accounts 返回失败：{body.get('msg') or body}")
        data = body.get("data")
    else:
        data = body
    if not isinstance(data, list):
        raise RuntimeError("/accounts 未返回账号数组")
    accounts: List[Dict[str, str]] = []
    for item in data:
        if not isinstance(item, dict):
            continue
        ref = str(item.get("openid") or item.get("id") or "").strip()
        if not ref:
            continue
        nickname = str(item.get("nickname") or item.get("alias") or ref).strip()
        accounts.append({"server": server, "ref": ref, "nickname": nickname})
    if not accounts:
        raise RuntimeError(f"/accounts 未返回任何有效账号（{server}）")
    return accounts


def _yyb_routes():
    routes = []
    for number, line in enumerate(os.getenv("YYB_SERVER", "").splitlines(), 1):
        line = line.strip()
        if not line:
            continue
        if "@" in line:
            server, ref = line.rsplit("@", 1)
            if not server.strip() or not ref.strip():
                raise RuntimeError(f"YYB_SERVER 第 {number} 行格式错误，应为 地址@账号标识")
            server = server.strip().rstrip("/")
            if not server.lower().startswith(("http://", "https://")):
                server = "http://" + server
            routes.append({"server": server, "ref": ref.strip(), "nickname": ref.strip()})
        else:
            server = line.rstrip("/")
            if not server.lower().startswith(("http://", "https://")):
                server = "http://" + server
            try:
                routes.extend(_yyb_fetch_accounts(server))
            except Exception as exc:
                raise RuntimeError(f"YYB_SERVER 第 {number} 行（纯地址）拉取账号失败：{exc}")
    if not routes:
        raise RuntimeError("未配置 YYB_SERVER（每行：地址@账号标识 或 纯地址）")
    return routes


def _yyb_clean_ref(value):
    text = str(value or "").split("#", 1)[0].strip()
    for prefix in ("wx:", "yyb:", "wmpf:", "syzs:"):
        if text.lower().startswith(prefix):
            return text[len(prefix):].strip()
    return text


def _yyb_route(identifier):
    routes = _yyb_routes()
    wanted = _yyb_clean_ref(identifier)
    for route in routes:
        if _yyb_clean_ref(route["ref"]) == wanted:
            return route
    if wanted.isdigit() and 0 < int(wanted) <= len(routes):
        return routes[int(wanted) - 1]
    if len(routes) == 1:
        return routes[0]
    raise RuntimeError(f"YYB_SERVER 中找不到账号标识：{wanted or '(空)'}")


def _yyb_call(endpoint, app_id, identifier):
    import requests as _requests
    route = _yyb_route(identifier)
    response = _requests.post(route["server"] + endpoint,
                              json={"ref": route["ref"], "app_id": app_id}, timeout=30)
    response.raise_for_status()
    body = response.json()
    if not isinstance(body, dict) or int(body.get("code", -1)) != 0:
        raise RuntimeError(f"{endpoint} 返回失败：{body.get('msg') or body.get('message') or body}")
    result = (body.get("data") or {}).get("result")
    if result is None:
        raise RuntimeError(f"{endpoint} 未返回 data.result")
    return result


class _YybClient:
    def get_online_accounts(self):
        return [{"id": x["ref"], "openid": x["ref"], "wxid": x["ref"],
                 "remark": x.get("nickname") or x["ref"], "nickname": x.get("nickname") or x["ref"],
                 "status": "online", "login_type": "WX"}
                for x in _yyb_routes()]

    def get_accounts(self, force_refresh=False):
        return self.get_online_accounts()


class _YybCompat:
    YYBClient = _YybClient

    @staticmethod
    def load_accounts(*_args, **_kwargs):
        return _YybClient().get_online_accounts()

    @staticmethod
    def resolve_accounts(env_name=""):
        return [x["ref"] for x in _yyb_routes()]

    @staticmethod
    def get_global_server_url():
        return _yyb_routes()[0]["server"]

    @staticmethod
    def get_single_code(app_id, identifier):
        result = _yyb_call("/wxapp/getCode", app_id, identifier)
        code = result if isinstance(result, str) else result.get("code")
        if not code:
            raise RuntimeError("/wxapp/getCode 未返回 data.result.code")
        return str(code)

    @staticmethod
    def get_single_phone_code(app_id, identifier, login_type=None):
        result = _yyb_call("/wxapp/getPhoneNumber", app_id, identifier)
        return str(result if isinstance(result, str) else result.get("code") or "")

    @staticmethod
    def normalize_login_type(value):
        return str(value or "WX").upper()

    @staticmethod
    def login_type_label(value):
        return {"WX": "应用宝", "WMPF": "微信小程序", "SYZS": "手游助手"}.get(
            _YybCompat.normalize_login_type(value), "应用宝")

    @staticmethod
    def _cache_path(name):
        import pathlib
        safe = "".join(ch if ch.isalnum() or ch in "-_" else "_" for ch in name)
        return pathlib.Path(os.getenv("QL_DIR", "/ql/data")) / "config" / "yyb_token_caches" / f"{safe}.json"

    @classmethod
    def _read_cache(cls, name):
        try:
            return json.loads(cls._cache_path(name).read_text(encoding="utf-8"))
        except Exception:
            return {}

    @classmethod
    def get_cached_token(cls, name, identifier, options=None):
        item = cls._read_cache(name).get(_yyb_clean_ref(identifier))
        if not item:
            return None
        max_age = int((options or {}).get("max_age_ms", 0))
        if max_age and int(time.time() * 1000) - int(item.get("_saved_at", 0)) > max_age:
            return None
        return item

    @classmethod
    def save_cached_token(cls, name, identifier, value):
        data = cls._read_cache(name)
        data[_yyb_clean_ref(identifier)] = dict(value, _saved_at=int(time.time() * 1000))
        path = cls._cache_path(name)
        path.parent.mkdir(parents=True, exist_ok=True)
        path.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
        try:
            path.chmod(0o600)
        except OSError:
            pass

    @classmethod
    def remove_cached_token(cls, name, identifier):
        data = cls._read_cache(name)
        data.pop(_yyb_clean_ref(identifier), None)
        path = cls._cache_path(name)
        path.parent.mkdir(parents=True, exist_ok=True)
        path.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")


yyb = _YybCompat()


def _send_qinglong_notify(title, content):
    import sys as _sys
    for path in (os.path.dirname(os.path.abspath(__file__)), "/ql/data/scripts", "/ql/scripts"):
        if path not in _sys.path:
            _sys.path.insert(0, path)
    try:
        from notify import send as _ql_send
        _ql_send(title, content)
        return True
    except Exception as exc:
        print(f"青龙通知失败（不影响任务结果）：{exc}")
        return False
# ===== adapter end =====

ql_send = _send_qinglong_notify


APP_NAME = "白鲸鱼旧衣服回收小程序"
APPID = "wxc525caf8e3a9e434"
APP_PLATFORM = "wx"

# 账号列表：自动从 yyb_go 同步存活账号（与小米社区一致，无需单独配置服务与账号）
ACCOUNT_NAMES: Dict[str, str] = {}


def load_accounts() -> List[str]:
    """从 yyb_go 拉取存活账号，返回账号标识列表（可用 WX_ID 指定白名单）"""
    try:
        accounts = yyb.load_accounts()
    except Exception as exc:
        print(f"❌ 拉取 yyb_go 账号失败：{exc}")
        return []
    refs: List[str] = []
    for account in accounts or []:
        ref = str(account.get("id") or account.get("openid") or account.get("wxid") or "").strip()
        if not ref:
            continue
        ACCOUNT_NAMES[ref] = str(account.get("remark") or account.get("nickname") or account.get("alias") or ref)
        refs.append(ref)
    if refs:
        print(f"✅ 已从 yyb_go 同步 {len(refs)} 个存活账号")
    return refs


SERVERS = load_accounts()


CHANNEL_ID = os.getenv("BJY_CHANNEL_ID", "wx1008")
OAID = os.getenv("BJY_OAID", "260827105351e14208")
DRAW_MODE = os.getenv("BJY_DRAW_MODE", "task").lower()
DRAW_TIMES = int(os.getenv("BJY_DRAW_TIMES", "1"))
CLUB_GID = os.getenv("BJY_CLUB_GID", "304")
AUTO_GROWTH_TYPES = ("weixin",)
CLUB_POST_CONTENTS = [
    "今天把家里的旧衣服整理了一大袋，预约了白鲸鱼上门回收，环保又省心，给平台点赞！",
    "换季整理出一堆旧衣服和旧书，交给白鲸鱼回收，还能攒成长值，一举两得。",
    "旧衣回收又一次打卡，快递小哥准时上门，流程很顺畅，支持环保事业！",
    "把闲置的衣物都回收了，白鲸鱼的处理方式很规范，推荐给大家。",
    "断舍离成功！旧衣服旧书统统交给白鲸鱼，为地球减负一点点。",
]

PROXY_API = os.getenv("PROXY_API", "")
PROXY_TYPE = os.getenv("PROXY_TYPE", "http").lower()

PROXY_RETRY_TIMES = 3
PROXY_VALIDATE_URL = "http://httpbin.org/ip"
PROXY_FETCH_INTERVAL = 3
ENABLE_DIRECT_FALLBACK = True
REQUEST_TIMEOUT = 30

BASE_URL = "https://www.52bjy.com"
APPKEY = "1f70a57fdf4061a7"
SECRET = "eBRaFLkuJ5"
LOGIN_URL = f"{BASE_URL}/api/app/weapp.php"

SIGN_INFO_URL = f"{BASE_URL}/api/app/user.php"
SIGN_URL = f"{BASE_URL}/api/app/user.php"
USERINFO_URL = f"{BASE_URL}/api/app/user.php"
DRAW_LIST_URL = f"{BASE_URL}/api/app/promotionjgg.php"
DRAW_RESULT_URL = f"{BASE_URL}/api/app/promotionjgg.php"
TASK_LIST_URL = f"{BASE_URL}/api/app/promotion.php"
GROWTH_URL = f"{BASE_URL}/api/app/membervip.php"

COOKIE_FILE = os.path.join(os.path.dirname(os.path.abspath(__file__)), "bjycookie.json")

USER_AGENT = (
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 "
    "(KHTML, like Gecko) Chrome/132.0.0.0 Safari/537.36 "
    "MicroMessenger/7.0.20.1781(0x6700143B) NetType/WIFI "
    "MiniProgramEnv/Windows WindowsWechat/WMPF WindowsWechat(0x63090a13) "
    "UnifiedPCWindowsWechat(0xf2541923) XWEB/25364"
)


def now_text() -> str:
    return datetime.now().strftime("%Y-%m-%d %H:%M:%S")


def sleep(seconds: float) -> None:
    time.sleep(seconds)


def mask(value: Any) -> str:
    value = str(value or "")
    if len(value) <= 12:
        return value
    return f"{value[:6]}...{value[-6:]}"


def json_preview(data: Any, limit: int = 800) -> str:
    try:
        return json.dumps(data, ensure_ascii=False)[:limit]
    except Exception:
        return str(data)[:limit]


def to_float(value: Any) -> float:
    try:
        return float(value or 0)
    except (TypeError, ValueError):
        return 0.0


def to_int(value: Any, default: int = 0) -> int:
    try:
        return int(float(value or default))
    except (TypeError, ValueError):
        return default


def safe_data(resp: Dict[str, Any]) -> Dict[str, Any]:
    """Safely extract 'data' from an API response, handling null/missing."""
    return resp.get("data") or {}


def log_title() -> None:
    print()
    print("╔" + "═" * 50 + "╗")
    print("║ ♻️ 白鲸鱼旧衣服回收动态 code 版             ║")
    print(f"║ 🕒 启动时间: {now_text():<32}║")
    print(f"║ 🔢 账号数量: {len(SERVERS):<34}║")
    print("╚" + "═" * 50 + "╝")


def log_account_header(index: int, total: int, server: str) -> None:
    print()
    print("┌" + "─" * 50 + "┐")
    print(f"│ 🧩 账号 {index} / {total:<37}│")
    print(f"│ 🌍 来源 {ACCOUNT_NAMES.get(server, server):<40}│")
    print("└" + "─" * 50 + "┘")


def direct_session() -> requests.Session:
    session = requests.Session()
    session.trust_env = False
    return session


def parse_proxy_response(text: Any) -> Dict[str, Any] | None:
    if not isinstance(text, str):
        text = json.dumps(text, ensure_ascii=False)

    text = text.strip()
    if not text:
        return None

    try:
        data = json.loads(text)
        proxy_obj = None

        if isinstance(data.get("data"), list) and data["data"]:
            proxy_obj = data["data"][0]
        elif isinstance(data.get("data"), dict):
            proxy_obj = data["data"]
        elif data.get("ip") and data.get("port"):
            proxy_obj = data
        elif isinstance(data.get("result"), dict):
            proxy_obj = data["result"]

        if proxy_obj:
            host = proxy_obj.get("ip") or proxy_obj.get("host")
            port = proxy_obj.get("port")
            if host and port:
                return {
                    "host": str(host),
                    "port": int(port),
                    "username": proxy_obj.get("user") or proxy_obj.get("username") or "",
                    "password": proxy_obj.get("pass") or proxy_obj.get("password") or "",
                }
    except Exception:
        pass

    if ":" in text:
        parts = text.split(":")
        if len(parts) >= 2:
            return {
                "host": parts[0],
                "port": int(parts[1]),
                "username": parts[2] if len(parts) > 2 else "",
                "password": parts[3] if len(parts) > 3 else "",
            }

    return None


def build_proxy_dict(proxy_info: Dict[str, Any] | None) -> Dict[str, str] | None:
    if not proxy_info:
        return None

    host = proxy_info["host"]
    port = proxy_info["port"]
    username = proxy_info.get("username", "")
    password = proxy_info.get("password", "")

    auth = ""
    if username and password:
        auth = f"{quote(username)}:{quote(password)}@"

    scheme = "socks5" if PROXY_TYPE == "socks5" else "http"
    proxy_url = f"{scheme}://{auth}{host}:{port}"

    print(f"🛠️ [代理] 生成 {scheme.upper()} 代理 {host}:{port}")

    return {
        "http": proxy_url,
        "https": proxy_url,
    }


def validate_proxy(proxies: Dict[str, str] | None) -> Tuple[bool, str]:
    if not proxies:
        return False, ""

    try:
        response = requests.get(PROXY_VALIDATE_URL, proxies=proxies, timeout=15)
        if response.status_code == 200:
            try:
                ip = response.json().get("origin", "未知")
            except Exception:
                ip = "未知"
            print(f"✅ [代理] 验证通过，出口 IP: {ip}")
            return True, ip
    except Exception as exc:
        print(f"⚠️ [代理] 验证失败: {exc}")

    return False, ""


def get_valid_proxy(account_name: str) -> Tuple[Dict[str, str] | None, str]:
    if not PROXY_API:
        print(f"⚠️ [代理] {account_name} 未配置 PROXY_API，使用直连")
        return None, ""

    print(f"🌐 [代理] {account_name} 正在获取品赞代理...")

    for index in range(1, PROXY_RETRY_TIMES + 1):
        try:
            response = direct_session().get(PROXY_API, timeout=15)
            proxy_info = parse_proxy_response(response.text)

            if not proxy_info:
                print(f"⚠️ [代理] 第 {index} 次代理解析失败")
                continue

            print(f"✅ [代理] 提取到 {proxy_info['host']}:{proxy_info['port']}")
            proxies = build_proxy_dict(proxy_info)

            ok, ip = validate_proxy(proxies)
            if ok:
                return proxies, ip

            print(f"⚠️ [代理] 第 {index} 次代理不可用")
        except Exception as exc:
            print(f"⚠️ [代理] 第 {index} 次获取代理异常: {exc}")

        if index < PROXY_RETRY_TIMES:
            sleep(2)

    print("⚠️ [代理] 获取失败，使用直连")
    return None, ""


def request_with_proxy(
    method: str,
    url: str,
    *,
    proxies: Dict[str, str] | None = None,
    server: str = "",
    **kwargs,
) -> requests.Response:
    kwargs.setdefault("timeout", REQUEST_TIMEOUT)

    if proxies:
        try:
            return requests.request(method, url, proxies=proxies, **kwargs)
        except Exception as exc:
            print(f"⚠️ [代理] {server} 代理请求失败: {exc}")
            if not ENABLE_DIRECT_FALLBACK:
                raise
            print("🔁 [兜底] 切换直连重试")

    session = direct_session()
    return session.request(method, url, **kwargs)


def get_code(server: str) -> str | None:
    """从 yyb_go 获取一次性微信 code（server 为账号标识）"""
    try:
        print(f"🔐 [授权] YYB 获取 code（账号 {ACCOUNT_NAMES.get(server, mask(server))}）")
        code = yyb.get_single_code(APPID, server)
        if not code:
            print("❌ [授权] code 获取失败")
            return None
        print("✅ [授权] code 获取成功")
        return str(code)
    except Exception as exc:
        print(f"❌ [授权] code 获取异常: {exc}")
        return None


def js_encode(value: str) -> str:
    """Encode a value like JS encodeURIComponent with Destoon's extra escaping."""
    encoded = quote(str(value), safe="-_.~")
    encoded = encoded.replace("!", "%21").replace("'", "%27")
    encoded = encoded.replace("(", "%28").replace(")", "%29")
    encoded = encoded.replace("*", "%2A")
    return encoded


def bjy_query_value(value: Any) -> str:
    text = str(value)
    if any("\u4e00" <= ch <= "\u9fff" for ch in text):
        return js_encode(text)
    return text


def bjy_sign(params: Dict[str, Any]) -> str:
    """小程序 sign 算法：参数按键名排序，拼接 key=value，再追加 secret 取 md5。"""
    qs = "&".join(f"{key}={bjy_query_value(value)}" for key, value in sorted(params.items()))
    return hashlib.md5((qs + SECRET).encode("utf-8")).hexdigest()


def build_api_url(php: str, params: Dict[str, Any]) -> str:
    """构造 /api/app/{php}.php 的签名 URL。"""
    data = dict(params)
    data.setdefault("sign_type", "md5")
    data.pop("php", None)
    data.setdefault("appkey", APPKEY)
    query = "&".join(f"{key}={bjy_query_value(value)}" for key, value in sorted(data.items()))
    sign = bjy_sign(data)
    return f"{BASE_URL}/api/app/{php}.php?{query}&sign={sign}"

def bjy_sign_raw(params: Dict[str, Any]) -> str:
    """POST 表单签名：原始值按键名排序拼接后追加 secret 取 md5（与小程序 axPost 一致）。"""
    qs = "&".join(f"{key}={params[key]}" for key in sorted(params))
    return hashlib.md5((qs + SECRET).encode("utf-8")).hexdigest()


def common_headers(token: str | None = None) -> Dict[str, str]:
    headers = {
        "User-Agent": USER_AGENT,
        "Accept": "*/*",
        "Content-Type": "application/json",
        "EnvConnection": "test",
        "Referer": f"https://servicewechat.com/{APPID}/392/page-frame.html",
        "Accept-Language": "zh-CN,zh;q=0.9",
    }
    if token:
        headers["auth"] = token
    return headers


def extract_auth(data: Any) -> Tuple[str | None, str | None]:
    if not isinstance(data, dict):
        return None, None

    inner = data.get("data")
    if isinstance(inner, dict):
        token = inner.get("jiufy_auth") or inner.get("token") or inner.get("accessToken")
        username = inner.get("username")
        if token and token != "null":
            return str(token), str(username or "")
    return None, None


def login_by_code(server: str, code: str, proxies: Dict[str, str] | None) -> Tuple[str | None, str | None, Dict[str, Any] | None]:
    try:
        print("🔐 [登录] 使用 code 换 token")
        url = (
            f"{LOGIN_URL}?action=bind&app={APP_PLATFORM}&appkey={APPKEY}"
            f"&channel={CHANNEL_ID}&inviter=&merchant_id=1&login_source=scan"
        )
        response = request_with_proxy(
            "POST",
            url,
            data={
                "encryptedData": "",
                "iv": "",
                "code": code,
            },
            headers={
                "User-Agent": USER_AGENT,
                "Content-Type": "application/x-www-form-urlencoded",
                "EnvConnection": "test",
                "Referer": f"https://servicewechat.com/{APPID}/392/page-frame.html",
            },
            proxies=proxies,
            server=server,
        )
        response.encoding = "utf-8"
        try:
            data = response.json()
        except Exception:
            data = {"raw": response.text[:800]}

        token, username = extract_auth(data)
        if token:
            print(f"✅ [登录] token 获取成功: {mask(token)}")
            return token, username, data

        print(f"❌ [登录] 未识别 token 字段: {json_preview(data)}")
        return None, None, data
    except Exception as exc:
        print(f"❌ [登录] 请求异常: {exc}")
        return None, None, None


def api_get(server: str, url: str, proxies: Dict[str, str] | None) -> Dict[str, Any]:
    response = request_with_proxy(
        "GET",
        url,
        headers=common_headers(),
        proxies=proxies,
        server=server,
    )
    response.encoding = "utf-8"
    try:
        return response.json()
    except Exception:
        return {
            "code": -1,
            "msg": f"JSON解析失败: {response.text[:300]}",
        }

def api_post(server: str, php: str, params: Dict[str, Any], proxies: Dict[str, str] | None) -> Dict[str, Any]:
    """POST 表单请求（小程序 axPost 风格）：参数放 body，sign 用原始值计算。"""
    data = dict(params)
    data.pop("php", None)
    data.pop("sign_type", None)
    data.setdefault("appkey", APPKEY)
    data["sign"] = bjy_sign_raw(data)
    response = request_with_proxy(
        "POST",
        f"{BASE_URL}/api/app/{php}.php",
        data=data,
        headers={**common_headers(), "Content-Type": "application/x-www-form-urlencoded"},
        proxies=proxies,
        server=server,
    )
    response.encoding = "utf-8"
    try:
        return response.json()
    except Exception:
        return {
            "code": -1,
            "msg": f"JSON解析失败: {response.text[:300]}",
        }


# ====================== Token缓存管理 ======================
def load_token_cache() -> Dict[str, Any]:
    try:
        if os.path.exists(COOKIE_FILE):
            with open(COOKIE_FILE, "r", encoding="utf-8") as f:
                return json.load(f)
    except Exception as exc:
        print(f"⚠️ [缓存] 读取失败: {exc}")
    return {}


def save_token_cache(cache: Dict[str, Any]) -> None:
    try:
        with open(COOKIE_FILE, "w", encoding="utf-8") as f:
            json.dump(cache, f, ensure_ascii=False, indent=2)
        print("✅ [缓存] Token保存成功")
    except Exception as exc:
        print(f"❌ [缓存] 保存失败: {exc}")


def get_cached_token(server: str) -> Tuple[str | None, str | None]:
    cache = load_token_cache()
    data = cache.get(server)
    if data and data.get("token") and data.get("expireTime"):
        try:
            expire = datetime.fromisoformat(data["expireTime"]).timestamp() * 1000
            if time.time() * 1000 < expire - 3600 * 1000:
                print(f"✅ [缓存] 使用 {server} token")
                return data["token"], data.get("username") or ""
        except Exception as exc:
            print(f"⚠️ [缓存] 过期时间解析异常: {exc}")
    return None, None


def set_cached_token(server: str, token: str, expire_time: str, username: str) -> None:
    cache = load_token_cache()
    cache[server] = {
        "token": token,
        "username": username,
        "expireTime": expire_time,
        "updateTime": datetime.now().isoformat(),
    }
    save_token_cache(cache)


def login_with_cache(server: str, proxies: Dict[str, str] | None) -> Tuple[str | None, str | None, Dict[str, Any] | None]:
    """优先使用缓存 token（用户信息接口验证），失效自动 code 刷新"""
    cache_token, cache_username = get_cached_token(server)
    if cache_token and cache_username:
        print("🔍 [缓存] 验证 token")
        try:
            url = build_api_url(
                "user",
                {
                    "action": "userinfo",
                    "auth": cache_token,
                    "username": cache_username,
                    "merchant_id": 1,
                },
            )
            account_resp = api_get(server, url, proxies)
            if account_resp.get("isSucess") or account_resp.get("is_success"):
                print("✅ [缓存] token 有效")
                return cache_token, cache_username, None
        except Exception as exc:
            print(f"⚠️ [缓存] 验证异常: {exc}")
        print("⚠️ [缓存] token 已失效，重新登录")

    code = get_code(server)
    if not code:
        return None, None, None

    token, username, raw_login = login_by_code(server, code, proxies)
    if not token:
        return None, None, raw_login

    expire_time = datetime.fromtimestamp(time.time() + 7 * 24 * 3600).isoformat()
    set_cached_token(server, token, expire_time, username)
    return token, username, raw_login


# ====================== 任务辅助 ======================
def fetch_task_list(server: str, task_type: str, username: str, proxies) -> List[Dict[str, Any]]:
    resp = api_get(
        server,
        build_api_url(
            "promotion",
            {
                "action": "tasklist",
                "app": APP_PLATFORM,
                "merchant_id": 1,
                "type": task_type,
                "username": username,
            },
        ),
        proxies,
    )
    data = resp.get("data") or []
    return [item for item in data if isinstance(item, dict)]


def summarize_task_list(tasks: List[Dict[str, Any]]) -> str:
    """任务列表摘要：X/N 已完成 + 待完成标题（供 run_welfare_tasks 使用，勿与通知版 summarize_tasks 混淆）。"""
    done = sum(1 for item in tasks if to_int(item.get("is_done")) == 1)
    pending = [str(item.get("title") or item.get("type")) for item in tasks if to_int(item.get("is_done")) != 1]
    text = f"{done}/{len(tasks)} 已完成"
    if pending:
        text += "，待完成：" + "、".join(pending[:4]) + ("..." if len(pending) > 4 else "")
    return text


def direct_task_action(server: str, task: Dict[str, Any], token: str, username: str, proxies) -> Tuple[Dict[str, Any] | None, str]:
    task_type = task.get("type") or ""
    if task_type == "fav":
        url = build_api_url("weapp", {"action": "addmyapp", "username": username})
        result = api_get(server, url, proxies)
        return result, result.get("message") or "收藏请求已提交"
    if task_type in ("sharefriends", "browse", "myminiprogram"):
        url = build_api_url(
            "user",
            {
                "action": "task",
                "app": APP_PLATFORM,
                "auth": token,
                "type": task_type,
                "username": username,
            },
        )
        result = api_get(server, url, proxies)
        return result, result.get("message") or f"{task.get('title') or task_type} 上报成功"
    return None, "需要真实客户端/业务动作"


def run_welfare_tasks(server: str, token: str, username: str, proxies) -> str:
    tasks = fetch_task_list(server, "welfare", username, proxies)
    action_messages: List[str] = []
    for task in tasks:
        if to_int(task.get("is_done")) == 1:
            continue
        action_resp, action_msg = direct_task_action(server, task, token, username, proxies)
        ok = bool(action_resp is None or action_resp.get("isSucess") or action_resp.get("is_success"))
        name = task.get("title") or task.get("type") or "未命名任务"
        if action_resp is not None and not ok:
            action_msg = action_resp.get("message") or action_msg
        action_messages.append(f"{name}: {'成功' if ok else '失败'} {action_msg}")
        sleep(random.randint(1, 2))

    refreshed = fetch_task_list(server, "welfare", username, proxies)
    profile = safe_data(api_get(
        server,
        build_api_url(
            "user",
            {
                "action": "userinfo",
                "auth": token,
                "username": username,
            },
        ),
        proxies,
    ))
    fav_flag = ""
    if isinstance(profile, dict) and profile.get("weapp_fav") is not None:
        fav_flag = f"，资料 weapp_fav={profile.get('weapp_fav', '?')}"
    result = summarize_task_list(refreshed)
    if action_messages:
        result += "；已处理：" + "；".join(action_messages[:5])
    result += fav_flag
    return result


def run_growth_summary(server: str, username: str, proxies) -> str:
    resp = api_get(
        server,
        build_api_url(
            "membervip",
            {
                "action": "growth",
                "app": APP_PLATFORM,
                "merchant_id": 1,
                "username": username,
            },
        ),
        proxies,
    )
    if not (resp.get("isSucess") or resp.get("is_success")):
        return resp.get("message") or "成长值查询失败"

    data = safe_data(resp)
    growth_task = data.get("growth_task") or {}
    daily_tasks = list(growth_task.get("day") or []) + list(growth_task.get("new") or [])
    daily_done = sum(1 for item in daily_tasks if to_int(item.get("is_done")) == 1)
    pending = [str(item.get("title")) for item in daily_tasks if to_int(item.get("is_done")) != 1]
    base_task = data.get("base_task") or {}
    brand_orders = (base_task.get("brandorder") or {}).get("list") or []
    brand_done = sum(1 for item in brand_orders if to_int(item.get("is_done")) == 1)
    info = base_task.get("information") or {}

    parts = [
        f"累计 {data.get('growths', 0)}（今日 +{data.get('growth', 0)}）",
        f"每日任务 {daily_done}/{len(daily_tasks)}",
        f"基础资料 {'已完成' if to_int(info.get('is_done')) == 1 else '未完成'}",
        f"回收成长任务 {brand_done}/{len(brand_orders)}",
    ]
    if pending:
        parts.append("待完成：" + "、".join(pending[:5]) + ("..." if len(pending) > 5 else ""))
    return "；".join(parts)

def fetch_club_topics(server: str, username: str, proxies) -> List[Dict[str, Any]]:
    resp = api_get(server, build_api_url("club", {"action": "list", "username": username}), proxies)
    data = resp.get("data") or []
    return [item for item in data if isinstance(item, dict) and str(item.get("catid")) != "507"]

def count_today_posts(server: str, token: str, username: str, proxies) -> int:
    resp = api_get(
        server,
        build_api_url(
            "club",
            {"action": "mypublish", "auth": token, "username": username},
        ),
        proxies,
    )
    today = datetime.now().strftime("%Y-%m-%d")
    posts = resp.get("data") or []
    return sum(1 for item in posts if isinstance(item, dict) and str(item.get("addtime", "")).startswith(today))

def run_club_post(server: str, token: str, username: str, proxies, limit: int = 3) -> str:
    ban = api_get(server, build_api_url("club", {"action": "ban_status", "username": username}), proxies)
    if to_int(safe_data(ban).get("status")) == 1:
        return f"账号被禁言：{safe_data(ban).get('tip') or '无法发帖'}"

    posted_today = count_today_posts(server, token, username, proxies)
    if posted_today >= limit:
        return f"今日已发帖 {posted_today}/{limit} 篇，达到上限"

    topics = fetch_club_topics(server, username, proxies)
    gid = CLUB_GID
    title = ""
    for item in topics:
        if str(item.get("gid")) == str(CLUB_GID):
            title = str(item.get("title") or "")
            break
    if not title and topics:
        gid = str(topics[0].get("gid"))
        title = str(topics[0].get("title") or "")
    if not title:
        return "未找到可发布的话题"

    content = CLUB_POST_CONTENTS[(datetime.now().toordinal() + posted_today) % len(CLUB_POST_CONTENTS)]
    sec_response = request_with_proxy(
        "POST",
        f"{BASE_URL}/api/app/weapp.php?action=msgseccheck",
        data={"content": content},
        headers={**common_headers(), "Content-Type": "application/x-www-form-urlencoded"},
        proxies=proxies,
        server=server,
    )
    try:
        sec_data = sec_response.json()
    except Exception:
        sec_data = {}
    errcode = (sec_data.get("data") or {}).get("errcode")
    if str(errcode) != "0":
        return f"内容安全检测未通过（{errcode}），跳过发帖"

    add_resp = api_post(
        server,
        "club",
        {
            "action": "add",
            "auth": token,
            "content": content,
            "gid": gid,
            "thumb": "",
            "title": title,
            "username": username,
            "version": "2",
        },
        proxies,
    )
    if add_resp.get("isSucess") or add_resp.get("is_success"):
        return f"发帖成功（话题：{title}），成长值待审核后发放"
    return f"发帖失败：{add_resp.get('message') or '未知错误'}"

def run_growth_tasks(server: str, token: str, username: str, proxies) -> str:
    messages: List[str] = []
    resp = api_get(
        server,
        build_api_url(
            "membervip",
            {"action": "growth", "app": APP_PLATFORM, "merchant_id": 1, "username": username},
        ),
        proxies,
    )
    if resp.get("isSucess") or resp.get("is_success"):
        growth_task = safe_data(resp).get("growth_task") or {}
        for task in list(growth_task.get("day") or []) + list(growth_task.get("new") or []):
            if to_int(task.get("is_done")) == 1:
                continue
            task_type = task.get("type") or ""
            name = task.get("title") or task_type
            if task_type in AUTO_GROWTH_TYPES:
                report = api_get(
                    server,
                    build_api_url(
                        "user",
                        {"action": "task", "app": APP_PLATFORM, "auth": token, "type": task_type, "username": username},
                    ),
                    proxies,
                )
                ok = bool(report.get("isSucess") or report.get("is_success"))
                messages.append(f"{name}: {'上报成功' if ok else '上报失败 ' + str(report.get('message') or '')}")
                sleep(random.randint(1, 2))
            elif task_type == "club":
                limit = to_int(task.get("period_num"), 3) or 3
                if to_int(task.get("counter")) < limit:
                    messages.append("发帖: " + run_club_post(server, token, username, proxies, limit=limit))
                    sleep(random.randint(1, 2))

    summary = run_growth_summary(server, username, proxies)
    if messages:
        summary += "；已处理：" + "；".join(messages[:6])
    return summary


def get_draw_cards(server: str, username: str, proxies) -> int:
    resp = api_get(
        server,
        build_api_url(
            "promotionjgg",
            {
                "action": "count",
                "channel": "promotion_jgg",
                "merchant_id": 1,
                "username": username,
            },
        ),
        proxies,
    )
    return max(0, to_int(safe_data(resp).get("new_count")))


def run_jgg_tasks(server: str, token: str, username: str, proxies) -> Tuple[str, List[str]]:
    tasks = fetch_task_list(server, "jgg", username, proxies)
    completed: List[str] = []
    skipped: List[str] = []
    for task in tasks:
        if to_int(task.get("is_done")) == 1:
            continue
        task_type = task.get("type") or ""
        name = task.get("title") or task_type
        if task_type == "qiandao":
            skipped.append(f"{name} 由签到流程处理")
            continue
        if task_type in ("sharefriends", "browse", "myminiprogram"):
            action_resp, action_msg = direct_task_action(server, task, token, username, proxies)
            ok = bool(action_resp is None or action_resp.get("isSucess") or action_resp.get("is_success"))
            completed.append(f"{name}: {'成功' if ok else '失败'} {action_msg}")
            sleep(random.randint(1, 2))
        else:
            skipped.append(f"{name} 需真实预约/捐赠/回复")
    text = "；".join(completed) if completed else "无可自动上报任务"
    if skipped:
        text += "；待真实动作：" + "、".join(skipped[:6])
    return text, completed


# ====================== 账号流程 ======================
def run_account(index: int, total: int, server: str) -> Dict[str, Any]:
    result = {
        "server": server,
        "success": False,
        "proxyStatus": "未使用代理",
        "proxyIp": "-",
        "token": "-",
        "username": "-",
        "signMsg": "-",
        "welfareMsg": "-",
        "growthMsg": "-",
        "drawTaskMsg": "-",
        "lotteryMsg": "-",
        "balance": "-",
        "error": "",
    }

    log_account_header(index, total, server)

    proxies, proxy_ip = get_valid_proxy(server)
    result["proxyStatus"] = "使用专属代理" if proxies else "使用直连"
    result["proxyIp"] = proxy_ip or "-"

    sleep(PROXY_FETCH_INTERVAL)

    delay = random.randint(2, 6)
    print(f"⏳ [延迟] 启动延迟 {delay}s")
    sleep(delay)

    token, username, raw_login = login_with_cache(server, proxies)
    if not token:
        result["error"] = f"登录失败: {json_preview(raw_login)}"
        return result

    result["token"] = mask(token)
    result["username"] = username

    try:
        # ====================== 每日签到 ======================
        sign_info = api_get(
            server,
            build_api_url(
                "user",
                {
                    "action": "getsigninfo",
                    "app": APP_PLATFORM,
                    "auth": token,
                    "username": username,
                },
            ),
            proxies,
        )
        if not (sign_info.get("isSucess") or sign_info.get("is_success")):
            result["signMsg"] = sign_info.get("message") or "签到状态查询失败"
            print(f"⚠️ [签到] {result['signMsg']}")
        else:
            sign_data = safe_data(sign_info)
            has_sign = str(sign_data.get("hassign", "0"))
            days = to_int(sign_data.get("thisturn"))
            if has_sign == "1":
                result["signMsg"] = f"今日已签到，连续 {days} 天"
                print(f"✅ [签到] {result['signMsg']}")
            else:
                sign_resp = api_get(
                    server,
                    build_api_url(
                        "user",
                        {
                            "action": "qiandao",
                            "app": APP_PLATFORM,
                            "auth": token,
                            "username": username,
                        },
                    ),
                    proxies,
                )
                if sign_resp.get("isSucess") or sign_resp.get("is_success"):
                    result["signMsg"] = f"每日签到成功，连续 {days + 1} 天"
                    print(f"✅ [签到] {result['signMsg']}")
                else:
                    result["signMsg"] = sign_resp.get("message") or "签到失败"
                    print(f"⚠️ [签到] {result['signMsg']}")

        # ====================== 福利任务 ======================
        result["welfareMsg"] = run_welfare_tasks(server, token, username, proxies)
        print(f"🧧 [福利] {result['welfareMsg']}")

        # ====================== 成长值任务 ======================
        result["growthMsg"] = run_growth_tasks(server, token, username, proxies)
        print(f"🌱 [成长] {result['growthMsg']}")

        # ====================== 九宫格任务卡与抽奖 ======================
        jgg_task_msg, _ = run_jgg_tasks(server, token, username, proxies)
        result["drawTaskMsg"] = jgg_task_msg
        print(f"🎟️ [抽奖任务] {jgg_task_msg}")

        cards = get_draw_cards(server, username, proxies)
        if DRAW_MODE == "fixed":
            cards = max(cards, DRAW_TIMES)
        print(f"🎰 [抽奖] 当前任务卡 {cards} 张")

        draw_config = api_get(
            server,
            build_api_url(
                "promotionjgg",
                {
                    "action": "list",
                    "app": APP_PLATFORM,
                    "merchant_id": "1",
                    "username": username,
                },
            ),
            proxies,
        )
        prize_count = len(safe_data(draw_config).get("items") or []) if (draw_config.get("isSucess") or draw_config.get("is_success")) else 0

        prizes: List[str] = []
        success_draws = 0
        for draw_index in range(1, cards + 1):
            wait_time = random.randint(2, 5)
            print(f"⏳ [抽奖] 第 {draw_index} 次抽奖前等待 {wait_time}s")
            sleep(wait_time)

            draw_resp = api_get(
                server,
                build_api_url(
                    "promotionjgg",
                    {
                        "action": "prize_draw",
                        "app": APP_PLATFORM,
                        "merchant_id": 1,
                        "username": username,
                    },
                ),
                proxies,
            )
            if not (draw_resp.get("isSucess") or draw_resp.get("is_success")):
                msg = draw_resp.get("message") or "抽奖失败"
                prizes.append(f"第{draw_index}次: {msg}")
                print(f"❌ [抽奖] {msg}")
                if "用完" in str(msg):
                    break
                continue

            prize_data = draw_resp.get("data") or {}
            prize_name = prize_data.get("title") or prize_data.get("goodName") or "未知奖品"
            prizes.append(prize_name)
            success_draws += 1
            print(f"✅ [抽奖] 第 {draw_index} 次获得: {prize_name}")

        cards_after = get_draw_cards(server, username, proxies)
        result["lotteryMsg"] = (
            f"奖品格 {prize_count} 个；任务卡后剩余 {cards_after} 张；"
            f"成功 {success_draws} 次；" + ("、".join(prizes) if prizes else "无奖品")
        )

        # ====================== 余额查询 ======================
        user_resp = api_get(
            server,
            build_api_url(
                "user",
                {
                    "action": "userinfo",
                    "auth": token,
                    "username": username,
                    "merchant_id": 1,
                },
            ),
            proxies,
        )
        if not (user_resp.get("isSucess") or user_resp.get("is_success")):
            result["balance"] = user_resp.get("message") or "余额获取失败"
            print(f"⚠️ [余额] {result['balance']}")
        else:
            user_data = safe_data(user_resp)
            credit = user_data.get("credit", 0)
            money = user_data.get("money", "0.00")
            result["balance"] = f"鲸币 {credit} / 现金 {money} 元"
            print(f"💰 [余额] {result['balance']}")

        result["success"] = True
        return result

    except Exception as exc:
        result["error"] = traceback.format_exc().strip()
        print(f"❌ [账号] 执行失败: {exc}")
        return result


def _compact_balance(balance: str) -> str:
    """精简余额：现金为 0.00 元时省略，只保留鲸币。"""
    if not balance or balance == "-":
        return balance
    if "现金 0.00 元" in balance:
        return balance.split(" / 现金 0.00 元")[0]
    return balance


def summarize_tasks(res: Dict[str, Any]) -> Tuple[List[str], List[str]]:
    """从各任务消息中提取「已跑/未跑」简要标签（通知用，详情留在运行日志）。"""
    done: List[str] = []
    pending: List[str] = []

    sign = res.get("signMsg") or ""
    if "已签到" in sign or "签到成功" in sign:
        done.append("签到")

    welfare = res.get("welfareMsg") or ""
    if "已处理" in welfare and "成功" in welfare:
        done.append("收藏")

    growth = res.get("growthMsg") or ""
    if "发帖" in growth and "成功" in growth:
        done.append("发帖")
    if "完成旧衣回收" in growth or "完成回收旧书" in growth:
        pending.append("回收")
    if "邀请新用户" in growth or "购买商品" in growth:
        pending.append("邀请/购买")

    draw_task = res.get("drawTaskMsg") or ""
    if "分享好友" in draw_task and "成功" in draw_task:
        done.append("分享好友")
    if "待真实动作" in draw_task:
        pending.append("预约/捐赠/回复")

    lottery = res.get("lotteryMsg") or ""
    m = re.search(r"成功 (\d+) 次", lottery)
    draws = int(m.group(1)) if m else 0
    if draws > 0:
        done.append(f"抽奖×{draws}")
    else:
        pending.append("抽奖(需真实动作)")

    return done, pending


def build_notify(results: List[Dict[str, Any]]) -> str:
    success_count = sum(1 for item in results if item["success"])
    fail_count = len(results) - success_count

    content = f"""♻️ 白鲸鱼旧衣回收 · {now_text()}
✅ {success_count} 成功 / {fail_count} 失败
"""

    for res in results:
        name = ACCOUNT_NAMES.get(res.get("server") or "", res.get("server") or "-")
        if res["success"]:
            content += f"""
▸ {name}
✅ {_compact_balance(res.get("balance") or "-")}
"""
            done, pending = summarize_tasks(res)
            if done:
                content += f"已跑: {'、'.join(done)}\n"
            if pending:
                content += f"未跑: {'、'.join(pending)}\n"
        else:
            content += f"""
▸ {name}
❌ 失败
原因: {(res.get('error') or '未知错误').strip()}
"""
        content += "\n"

    return content.strip()


def parse_blacklist(value: str) -> set:
    """解析 BJY_blacklist：支持逗号/分号/换行分隔，自动去空白，空值返回空集合。"""
    items = set()
    for part in (value or "").replace(",", "\n").replace(";", "\n").splitlines():
        part = part.strip()
        if part:
            items.add(part)
    return items


def main() -> None:
    log_title()

    if not SERVERS:
        print("❌ 未从 yyb_go 获取到存活账号，请确认 YYB_SERVER 已配置且服务内有在线账号")
        ql_send(
            "♻️ 白鲸鱼旧衣服回收任务失败",
            "未从 yyb_go 获取到存活账号，请确认 YYB_SERVER 已配置且服务内有在线账号",
        )
        return

    blacklist = parse_blacklist(os.getenv("BJY_blacklist", ""))
    if blacklist:
        print(f"⏭️ [黑名单] BJY_blacklist 共 {len(blacklist)} 项，命中账号将跳过")

    results: List[Dict[str, Any]] = []
    active_index = 0
    prev_ran = False

    for server in SERVERS:
        display_name = ACCOUNT_NAMES.get(server, server)
        if server in blacklist or display_name in blacklist:
            print(f"⏭️ 命中 BJY_blacklist，跳过：{display_name}")
            continue

        if prev_ran:
            delay = random.randint(5, 20)
            print(f"⏳ [间隔] 等待 {delay}s 后处理下一个账号")
            sleep(delay)

        active_index += 1
        try:
            result = run_account(active_index, len(SERVERS), server)
            results.append(result)
        except Exception as exc:
            print(f"❌ [主程序] {server} 执行异常: {exc}")
            results.append({
                "server": server,
                "success": False,
                "proxyStatus": "-",
                "proxyIp": "-",
                "token": "-",
                "username": "-",
                "signMsg": "-",
                "welfareMsg": "-",
                "growthMsg": "-",
                "drawTaskMsg": "-",
                "lotteryMsg": "-",
                "balance": "-",
                "error": traceback.format_exc().strip(),
            })

        prev_ran = True

    success_count = sum(1 for item in results if item["success"])
    fail_count = len(results) - success_count

    print()
    print("╔" + "═" * 50 + "╗")
    print("║ 🏁 白鲸鱼旧衣服回收任务执行完成              ║")
    print(f"║ ✅ 成功: {success_count:<39}║")
    print(f"║ ❌ 失败: {fail_count:<39}║")
    print(f"║ 🕒 结束时间: {now_text():<32}║")
    print("╚" + "═" * 50 + "╝")

    ql_send("♻️ 白鲸鱼旧衣服回收任务完成", build_notify(results))


if __name__ == "__main__":
    main()