#!/usr/bin/env python3
"""
自动注册脚本 v2（Cloudflare catch-all + Gmail IMAP）
流程：生成随机别名 -> Chromium注册 -> 直接IMAP取验证码 -> 填码完成注册
"""
import argparse
import email as email_lib
import imaplib
import json
import os
import random
import re
import string
import sys
import time
from datetime import datetime, timezone
from email.header import decode_header as _decode_header
from email.utils import parsedate_to_datetime
from pathlib import Path

from DrissionPage import Chromium, ChromiumOptions

# ---- 配置 ----
BASE_URL = "https://accounts.x.ai"
SIGNUP_URL = "https://accounts.x.ai/sign-up?redirect=grok-com"
ACCOUNTS_FILE = "accounts_cli.txt"
CPA_DIR = "cpa_auths"
DOMAIN = "zhangyunuo.net"
CODE_TIMEOUT = 180
CODE_POLL = 3
IMAP_HOST = "imap.gmail.com"
IMAP_PORT = 993
EXTENSION_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)), "turnstilePatch")

CHROMIUM_SLIM_FLAGS = [
    "--disable-gpu",
    "--disable-software-rasterizer",
    "--no-sandbox",
    "--disable-dev-shm-usage",
    "--disable-images",
    "--mute-audio",
    "--disable-background-networking",
    "--no-first-run",
]

CODE_PATTERNS = [
    re.compile(r"verification\s+code[:\s]+(\d{4,8})", re.I),
    re.compile(r"your\s+code[:\s]+(\d{4,8})", re.I),
    re.compile(r"confirm(?:ation)?\s+code[:\s]+(\d{4,8})", re.I),
    re.compile(r"code[:\s]+(\d{4,8})", re.I),
    re.compile(r"验证码[：:\\s]+(\d{4,8})"),
]

def load_env(path=".env"):
    data = {}
    if not os.path.exists(path):
        return data
    with open(path) as f:
        for line in f:
            line = line.strip()
            if not line or line.startswith("#"):
                continue
            if "=" in line:
                k, v = line.split("=", 1)
                data[k.strip()] = v.strip().strip('"').strip("'")
    return data

def gen_alias(domain: str, length: int = 10) -> str:
    alias = "".join(random.choices(string.ascii_lowercase + string.digits, k=length))
    return f"{alias}@{domain}"

def gen_password(length: int = 16) -> str:
    # Avoid form-hostile punctuation; keep strong enough for xAI signup rules.
    lower = string.ascii_lowercase
    upper = string.ascii_uppercase
    digits = string.digits
    special = "!@#$%^&*"
    if length < 8:
        length = 8
    base = [
        random.choice(lower),
        random.choice(upper),
        random.choice(digits),
        random.choice(special),
    ]
    pool = lower + upper + digits + special
    base += random.choices(pool, k=length - len(base))
    random.shuffle(base)
    return "".join(base)

def decode_header(raw: str) -> str:
    parts = _decode_header(raw or "")
    out = []
    for part, charset in parts:
        if isinstance(part, bytes):
            out.append(part.decode(charset or "utf-8", errors="replace"))
        else:
            out.append(part)
    return "".join(out)

def message_body(msg) -> str:
    body = ""
    if msg.is_multipart():
        for part in msg.walk():
            ct = part.get_content_type()
            if ct == "text/plain":
                payload = part.get_payload(decode=True)
                if payload:
                    body += payload.decode("utf-8", errors="replace")
    else:
        payload = msg.get_payload(decode=True)
        if payload:
            body += payload.decode("utf-8", errors="replace")
    return body

def extract_code(text: str) -> str | None:
    for pat in CODE_PATTERNS:
        m = pat.search(text)
        if m:
            return m.group(1)
    return None

def imap_login(user: str, password: str):
    imap = imaplib.IMAP4_SSL(IMAP_HOST, IMAP_PORT, timeout=45)
    imap.login(user, password)
    imap.select("INBOX")
    return imap

def fetch_code(imap, target_email: str, timeout: int = CODE_TIMEOUT, poll: int = CODE_POLL) -> str | None:
    deadline = time.time() + timeout
    target_lower = target_email.lower().strip()
    while time.time() < deadline:
        try:
            status, data = imap.search(None, "ALL")
            if status != "OK" or not data or not data[0]:
                time.sleep(poll)
                continue
            msg_ids = data[0].split()[-30:]
            filter_ts = int((time.time() - 900) * 1000)
            for mid in reversed(msg_ids):
                try:
                    _, msg_data = imap.fetch(mid, "(RFC822)")
                except Exception:
                    continue
                if not msg_data or not msg_data[0] or not isinstance(msg_data[0][1], bytes):
                    continue
                msg = email_lib.message_from_bytes(msg_data[0][1])
                date_str = msg.get("Date")
                if date_str:
                    try:
                        dt = parsedate_to_datetime(date_str)
                        if dt.tzinfo is None:
                            dt = dt.replace(tzinfo=timezone.utc)
                        if int(dt.timestamp() * 1000) < filter_ts:
                            continue
                    except Exception:
                        pass
                subject = decode_header(msg.get("Subject", ""))
                sender = decode_header(msg.get("From", ""))
                recipient_blob = " ".join(
                    decode_header(msg.get(h, ""))
                    for h in ("To", "Cc", "Delivered-To", "X-Original-To", "Original-Recipient", "Envelope-To")
                ).lower()
                if target_lower not in recipient_blob:
                    continue
                body = message_body(msg)
                combined = f"{subject}\n{sender}\n{recipient_blob}\n{body}".lower()
                if not any(kw in combined for kw in ["x.ai", "xai", "grok", "verification", "code", "confirm", "验证码", "确认"]):
                    continue
                code = extract_code(combined)
                if code:
                    print(f"[+] Code found for {target_email}: {code}")
                    return code
        except Exception as e:
            print(f"[!] IMAP poll error: {e}")
        time.sleep(poll)
    return None

def save_account(email: str, password: str, sso: str = ""):
    Path(ACCOUNTS_FILE).parent.mkdir(parents=True, exist_ok=True)
    with open(ACCOUNTS_FILE, "a") as f:
        f.write(f"{email}----{password}----{sso}\n")
    print(f"[+] Saved: {email}")

def create_browser_options(headless: bool = False, proxy: str = "") -> ChromiumOptions:
    opts = ChromiumOptions()
    opts.auto_port()
    for flag in CHROMIUM_SLIM_FLAGS:
        opts.set_argument(flag)
    if os.path.exists(EXTENSION_PATH):
        opts.add_extension(EXTENSION_PATH)
    if headless:
        opts.headless()
    if proxy:
        try:
            from urllib.parse import urlparse
            u = urlparse(proxy if "://" in proxy else f"http://{proxy}")
            host = u.hostname or ""
            if host:
                port = u.port or (443 if (u.scheme or "http") == "https" else 80)
                scheme = u.scheme or "http"
                opts.set_argument(f"--proxy-server={scheme}://{host}:{port}")
        except Exception as e:
            print(f"[!] Proxy setup failed: {e}")
    return opts

def wait_for_tab(browser: Chromium, timeout: int = 15) -> any:
    """Wait for browser tab to be ready and return it."""
    deadline = time.time() + timeout
    while time.time() < deadline:
        try:
            tab_ids = browser.tab_ids
            if tab_ids:
                tab = browser.get_tab(tab_ids[0])
                if tab is not None:
                    return tab
        except Exception:
            pass
        time.sleep(0.5)
    # Fallback
    return browser.latest_tab

def bypass_turnstile(page) -> None:
    """Try to bypass Cloudflare Turnstile using multiple methods."""
    try:
        # Method 1: Check if Turnstile token already exists
        token = page.run_js("""
            try {
                const byInput = String((document.querySelector('input[name="cf-turnstile-response"]') || {}).value || '').trim();
                if (byInput) return byInput;
                if (window.turnstile && typeof turnstile.getResponse === 'function') {
                    return String(turnstile.getResponse() || '').trim();
                }
                return '';
            } catch(e) { return ''; }
        """)
        if token and len(token) >= 80:
            print(f"[+] Turnstile token already present (len={len(token)})")
            return
    except Exception:
        pass

    try:
        # Method 2: Try to find and click Turnstile checkbox
        challenge_input = page.ele("@name=cf-turnstile-response", timeout=2)
        if challenge_input:
            try:
                wrapper = challenge_input.parent()
                iframe = None
                try:
                    iframe = wrapper.shadow_root.ele("tag:iframe")
                except Exception:
                    pass
                if iframe:
                    try:
                        iframe.run_js("""
                            window.dtp = 1;
                            function getRandomInt(min, max) { return Math.floor(Math.random() * (max - min + 1)) + min; }
                            let sx = getRandomInt(800, 1200);
                            let sy = getRandomInt(400, 700);
                            Object.defineProperty(MouseEvent.prototype, 'screenX', { value: sx });
                            Object.defineProperty(MouseEvent.prototype, 'screenY', { value: sy });
                        """)
                    except Exception:
                        pass
                    try:
                        body_sr = iframe.ele("tag:body").shadow_root
                        btn = body_sr.ele("tag:input")
                        if btn:
                            btn.click()
                            print("[+] Clicked Turnstile checkbox via shadow DOM")
                    except Exception:
                        pass
            except Exception:
                pass
    except Exception:
        pass

    try:
        # Method 3: Click any visible Turnstile container
        page.run_js("""
            const nodes = Array.from(document.querySelectorAll('div,span,iframe')).filter((n) => {
                const txt = (n.className || '') + ' ' + (n.id || '') + ' ' + (n.getAttribute?.('src') || '');
                return String(txt).toLowerCase().includes('turnstile');
            });
            if (nodes.length && typeof nodes[0].click === 'function') nodes[0].click();
        """)
    except Exception:
        pass

def click_email_signup_button(page, timeout: int = 15) -> bool:
    """Click the 'Sign up with email' button on the landing page."""
    deadline = time.time() + timeout
    while time.time() < deadline:
        clicked = page.run_js("""
            const candidates = Array.from(document.querySelectorAll('button, a, [role="button"]'));
            const target = candidates.find((node) => {
                const text = (node.innerText || node.textContent || '').replace(/\\s+/g, '');
                const lower = text.toLowerCase();
                return (
                    text.includes('使用邮箱注册') ||
                    lower.includes('signupwithemail') ||
                    lower.includes('continuewithemail') ||
                    lower.includes('email')
                );
            });
            if (!target) return false;
            target.click();
            return true;
        """)
        if clicked:
            print("[+] Clicked 'Sign up with email' button")
            return True
        time.sleep(1)
    return False

def fill_email_js(page, email: str) -> bool:
    """Fill email input using React-compatible JS injection."""
    deadline = time.time() + 15
    while time.time() < deadline:
        result = page.run_js("""
            function isVisible(node) {
                if (!node) return false;
                const style = window.getComputedStyle(node);
                if (style.display === 'none' || style.visibility === 'hidden' || style.opacity === '0') return false;
                const rect = node.getBoundingClientRect();
                return rect.width > 0 && rect.height > 0;
            }
            const input = Array.from(document.querySelectorAll('input[data-testid="email"], input[name="email"], input[type="email"], input[autocomplete="email"]')).find((node) => isVisible(node) && !node.disabled && !node.readOnly) || null;
            if (!input) return 'not-ready';
            input.focus(); input.click();
            const valueSetter = Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, 'value')?.set;
            const tracker = input._valueTracker;
            if (tracker) tracker.setValue(arguments[0]);
            if (valueSetter) valueSetter.call(input, arguments[0]); else input.value = arguments[0];
            input.dispatchEvent(new Event('focus', { bubbles: true }));
            input.dispatchEvent(new InputEvent('beforeinput', { bubbles: true, data: arguments[0], inputType: 'insertText' }));
            input.dispatchEvent(new InputEvent('input', { bubbles: true, data: arguments[0], inputType: 'insertText' }));
            input.dispatchEvent(new Event('change', { bubbles: true }));
            input.dispatchEvent(new Event('blur', { bubbles: true }));
            const current = (input.value || '').trim();
            if (current === arguments[0]) return 'filled';
            input.value = '';
            input.dispatchEvent(new Event('input', { bubbles: true }));
            for (const ch of arguments[0]) {
                input.dispatchEvent(new KeyboardEvent('keydown', { key: ch, bubbles: true }));
                input.value += ch;
                input.dispatchEvent(new InputEvent('input', { bubbles: true, data: ch, inputType: 'insertText' }));
                input.dispatchEvent(new KeyboardEvent('keyup', { key: ch, bubbles: true }));
            }
            input.dispatchEvent(new Event('change', { bubbles: true }));
            if ((input.value || '').trim() === arguments[0]) return 'filled';
            return input.value;
        """, email)
        if result == "not-ready":
            time.sleep(0.5)
            continue
        if result == "filled":
            return True
        time.sleep(0.5)
    return False

def click_continue_button(page) -> bool:
    """Click continue/signup button after email is filled."""
    clicked = page.run_js(r"""
        function isVisible(node) {
            if (!node) return false;
            const style = window.getComputedStyle(node);
            if (style.display === 'none' || style.visibility === 'hidden' || style.opacity === '0') return false;
            const rect = node.getBoundingClientRect();
            return rect.width > 0 && rect.height > 0;
        }
        const input = Array.from(document.querySelectorAll('input[data-testid="email"], input[name="email"], input[type="email"], input[autocomplete="email"]')).find((node) => isVisible(node) && !node.disabled && !node.readOnly) || null;
        if (!input || !(input.value || '').trim()) return false;
        const buttons = Array.from(document.querySelectorAll('button[type="submit"], button')).filter((node) => isVisible(node) && !node.disabled && node.getAttribute('aria-disabled') !== 'true');
        const submitButton = buttons.find((node) => {
            const raw = (node.innerText || node.textContent || '').trim();
            const compact = raw.replace(/\s+/g, '').toLowerCase();
            return (
                raw.includes('注册') ||
                compact === 'signup' ||
                compact.includes('signup') ||
                compact.includes('continue') ||
                compact.includes('next') ||
                compact.includes('createaccount') ||
                compact.includes('submit')
            );
        });
        if (!submitButton || submitButton.disabled) return false;
        submitButton.click();
        return true;
    """)
    return bool(clicked)

def gen_name() -> tuple[str, str]:
    first = ["Alex", "Sam", "Jordan", "Taylor", "Casey", "Riley", "Morgan", "Avery", "Quinn", "Jamie"]
    last = ["Smith", "Johnson", "Brown", "Taylor", "Anderson", "Thomas", "Jackson", "White", "Harris", "Martin"]
    return random.choice(first), random.choice(last)


def fill_profile_js(page, password: str, timeout: int = 120) -> dict:
    """Fill given/family name + password and submit after Turnstile is ready."""
    given_name, family_name = gen_name()
    deadline = time.time() + timeout
    form_filled = False
    while time.time() < deadline:
        state = page.run_js(
            r"""
const givenName = arguments[0];
const familyName = arguments[1];
const password = arguments[2];
function isVisible(node) {
  if (!node) return false;
  const style = window.getComputedStyle(node);
  if (style.display === 'none' || style.visibility === 'hidden' || style.opacity === '0') return false;
  const rect = node.getBoundingClientRect();
  return rect.width > 0 && rect.height > 0;
}
function pick(sel) {
  return Array.from(document.querySelectorAll(sel)).find((n) => isVisible(n) && !n.disabled && !n.readOnly) || null;
}
function setVal(input, value) {
  if (!input) return false;
  input.focus(); input.click();
  const setter = Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, 'value')?.set;
  const tracker = input._valueTracker;
  if (tracker) tracker.setValue('');
  if (setter) setter.call(input, value); else input.value = value;
  input.dispatchEvent(new InputEvent('beforeinput', { bubbles: true, data: value, inputType: 'insertText' }));
  input.dispatchEvent(new InputEvent('input', { bubbles: true, data: value, inputType: 'insertText' }));
  input.dispatchEvent(new Event('change', { bubbles: true }));
  input.blur();
  return String(input.value || '').trim() === String(value || '').trim();
}
const givenInput = pick('input[data-testid="givenName"], input[name="givenName"], input[autocomplete="given-name"]');
const familyInput = pick('input[data-testid="familyName"], input[name="familyName"], input[autocomplete="family-name"]');
const passwordInput = pick('input[data-testid="password"], input[name="password"], input[type="password"], input[autocomplete="new-password"]');
if (!givenInput || !familyInput || !passwordInput) return 'not-ready';
const ok1 = setVal(givenInput, givenName);
const ok2 = setVal(familyInput, familyName);
const ok3 = setVal(passwordInput, password);
if (!ok1 || !ok2 || !ok3) return 'fill-failed';
const cfInput = document.querySelector('input[name="cf-turnstile-response"]');
const cfPresent = !!cfInput || !!document.querySelector('iframe[src*="turnstile"], div.cf-turnstile, [data-sitekey]');
if (cfPresent) {
  const token = String((cfInput && cfInput.value) || '').trim();
  if (token.length < 80) return 'wait-cf:' + token.length;
}
const buttons = Array.from(document.querySelectorAll('button[type="submit"], button')).filter((n) => isVisible(n) && !n.disabled && n.getAttribute('aria-disabled') !== 'true');
const submitBtn = buttons.find((n) => {
  const t = (n.innerText || n.textContent || '').replace(/\s+/g, '').toLowerCase();
  return t.includes('完成注册') || t.includes('创建账户') || t.includes('signup') || t.includes('signup') || t.includes('createaccount') || t.includes('continue') || t.includes('confirm');
});
if (!submitBtn) return 'filled-no-submit';
submitBtn.click();
return 'submitted';
            """,
            given_name,
            family_name,
            password,
        )
        if state == "not-ready":
            time.sleep(0.8)
            continue
        if state == "fill-failed":
            time.sleep(0.5)
            continue
        if isinstance(state, str) and state.startswith("wait-cf"):
            form_filled = True
            bypass_turnstile(page)
            time.sleep(1.5)
            continue
        if state == "filled-no-submit":
            form_filled = True
            time.sleep(1)
            continue
        if state == "submitted":
            return {"ok": True, "given_name": given_name, "family_name": family_name, "password": password}
        time.sleep(0.8)
    return {"ok": False, "error": "timeout waiting profile/turnstile", "given_name": given_name, "family_name": family_name}


def wait_for_sso(page, timeout: int = 180) -> str:
    deadline = time.time() + timeout
    last_click = 0.0
    while time.time() < deadline:
        # periodically re-click final submit if still on complete-registration page
        now = time.time()
        if now - last_click >= 3:
            try:
                page.run_js(r"""
function isVisible(node) {
  if (!node) return false;
  const style = window.getComputedStyle(node);
  if (style.display === 'none' || style.visibility === 'hidden' || style.opacity === '0') return false;
  const rect = node.getBoundingClientRect();
  return rect.width > 0 && rect.height > 0;
}
const titleHit = !!Array.from(document.querySelectorAll('h1,h2,div,span')).find((el) => {
  const t = (el.textContent || '').replace(/\s+/g, '');
  return t.includes('完成注册') || t.toLowerCase().includes('complete');
});
if (!titleHit) return false;
const cfInput = document.querySelector('input[name="cf-turnstile-response"]');
if (cfInput && String(cfInput.value || '').trim().length < 80) return false;
const buttons = Array.from(document.querySelectorAll('button[type="submit"], button')).filter((n) => isVisible(n) && !n.disabled);
const submitBtn = buttons.find((n) => {
  const t = (n.innerText || n.textContent || '').replace(/\s+/g, '').toLowerCase();
  return t.includes('完成注册') || t.includes('创建账户') || t.includes('signup') || t.includes('signup') || t.includes('createaccount');
});
if (submitBtn) { submitBtn.click(); return true; }
return false;
""")
            except Exception:
                pass
            last_click = now
        try:
            cookies = None
            for getter in (
                lambda: page.cookies(all_domains=True, all_info=True),
                lambda: page.cookies(all_domains=True),
                lambda: page.cookies(),
            ):
                try:
                    cookies = getter()
                    if cookies:
                        break
                except TypeError:
                    continue
                except Exception:
                    continue
            if isinstance(cookies, list):
                for c in cookies:
                    if not isinstance(c, dict):
                        continue
                    if str(c.get("name", "")).strip() == "sso" and c.get("value"):
                        return str(c.get("value")).strip()
        except Exception:
            pass
        time.sleep(1)
    return ""


def maybe_export_cpa(email: str, password: str, sso: str, page) -> str | None:
    """Best-effort CPA export using project cpa_export + config.json."""
    cfg_path = Path(__file__).resolve().parent / "config.json"
    if not cfg_path.is_file():
        return None
    try:
        cfg = json.loads(cfg_path.read_text(encoding="utf-8"))
    except Exception:
        return None
    if not cfg.get("cpa_export_enabled", True):
        return None
    try:
        import cpa_export
        cookies = cpa_export.export_cookies_from_page(page)
        result = cpa_export.export_cpa_xai_for_account(
            email,
            password,
            page=None,
            cookies=cookies,
            sso=sso,
            config=cfg,
            log_callback=lambda m: print(f"[cpa] {m}"),
        )
        if result.get("ok") and result.get("path"):
            return str(result["path"])
    except Exception as exc:
        print(f"[!] CPA export exception: {exc}")
    return None


def do_register(alias: str, password: str, imap_user: str, imap_password: str, headless: bool = False, proxy: str = "") -> dict:
    email = alias
    print(f"[*] Registering: {email}")

    opts = create_browser_options(headless=headless, proxy=proxy)
    browser = None
    imap_conn = None
    try:
        browser = Chromium(opts)
        page = wait_for_tab(browser, timeout=20)
        if page is None:
            raise Exception("无法获取浏览器标签页")

        page.get(SIGNUP_URL)
        page.wait.doc_loaded(timeout=20)
        time.sleep(2)
        print(f"[+] Page loaded: {page.url}")

        # 尝试绕过 Turnstile
        bypass_turnstile(page)
        time.sleep(1)

        # 点击"使用邮箱注册"按钮
        if not click_email_signup_button(page, timeout=10):
            print("[!] No email signup button found, continuing anyway...")
        time.sleep(2)

        # 填写邮箱
        if not fill_email_js(page, email):
            raise Exception("未找到邮箱输入框或写入失败")
        print(f"[+] Email submitted: {email}")
        time.sleep(0.8)

        # 点击继续
        if not click_continue_button(page):
            raise Exception("未找到注册按钮")
        print(f"[+] Continue clicked")
        time.sleep(3)

        # 连接 IMAP 准备取验证码
        print(f"[*] Connecting IMAP {imap_user}...")
        imap_conn = imap_login(imap_user, imap_password)

        # 等待验证码
        print(f"[*] Waiting for code...")
        code = fetch_code(imap_conn, email, timeout=CODE_TIMEOUT, poll=CODE_POLL)
        if not code:
            raise Exception(f"未收到验证码: {email}")

        # 填写验证码
        code_input = page.ele(
            "css:input[data-input-otp='true'], input[name='code'], input[autocomplete='one-time-code']",
            timeout=5,
        )
        if code_input:
            code_input.clear()
            code_input.input(code)
        else:
            boxes = page.eles("css:input[inputmode='numeric']")
            for i, ch in enumerate(code):
                if i < len(boxes):
                    boxes[i].input(ch)
                    time.sleep(0.1)
        print(f"[+] Code filled: {code}")
        time.sleep(0.5)

        # 点击确认
        page.run_js("""
            const btns = Array.from(document.querySelectorAll('button'));
            const btn = btns.find(b => {
                const t = (b.innerText || b.textContent || '').replace(/\\s+/g, '').toLowerCase();
                return t.includes('continue') || t.includes('confirm') || t.includes('下一步');
            });
            if (btn) btn.click();
        """)
        time.sleep(3)

        # 验证码后通常进入资料页：姓名 + 密码 + Turnstile
        print("[*] Filling profile (name/password)...")
        profile = fill_profile_js(page, password, timeout=120)
        if not profile.get("ok"):
            raise Exception(f"资料填写失败: {profile.get('error') or 'unknown'}")
        print(f"[+] Profile filled: {profile.get('given_name')} {profile.get('family_name')}")

        # 等待 sso cookie（最终提交后）
        print("[*] Waiting for sso cookie...")
        sso_cookie = wait_for_sso(page, timeout=180)
        current_url = page.url
        print(f"[+] Current URL: {current_url}")
        if not sso_cookie:
            raise Exception("未获取到 sso cookie")

        save_account(email, password, sso_cookie)
        result = {"ok": True, "email": email, "password": password, "sso": sso_cookie, "url": current_url}

        # 可选：协议优先 CPA mint
        if os.environ.get("CPA_EXPORT", "1") not in ("0", "false", "False"):
            try:
                cpa_path = maybe_export_cpa(email, password, sso_cookie, page)
                if cpa_path:
                    result["cpa_path"] = cpa_path
                    print(f"[+] CPA auth: {cpa_path}")
            except Exception as cpa_exc:
                print(f"[!] CPA export failed: {cpa_exc}")
                result["cpa_error"] = str(cpa_exc)
        return result

    except Exception as e:
        print(f"[-] Failed: {e}")
        try:
            if browser is not None:
                tab = wait_for_tab(browser, timeout=5)
                if tab is not None:
                    tab.get_screenshot(path="register_error.png", full_page=False)
                    print(f"[!] Screenshot: register_error.png")
        except Exception:
            pass
        return {"ok": False, "error": str(e), "email": email}
    finally:
        if imap_conn:
            try:
                imap_conn.close()
            except Exception:
                pass
            try:
                imap_conn.logout()
            except Exception:
                pass
        if browser is not None:
            try:
                browser.quit()
            except Exception:
                pass

def main():
    parser = argparse.ArgumentParser(description="Grok 自动注册（Cloudflare catch-all + Gmail IMAP）")
    parser.add_argument("--count", type=int, default=1)
    parser.add_argument("--threads", type=int, default=1)
    parser.add_argument("--headless", action="store_true")
    parser.add_argument("--proxy", default=None)
    parser.add_argument("--domain", default=DOMAIN)
    parser.add_argument("--imap-user", default=None)
    parser.add_argument("--imap-password", default=None)
    args = parser.parse_args()

    env = load_env()
    proxy = args.proxy or env.get("proxy") or env.get("cpa_proxy") or ""
    if proxy == "http://127.0.0.1:7890":
        proxy = ""
    imap_user = args.imap_user or env.get("GMAIL_USER") or ""
    imap_password = args.imap_password or env.get("GMAIL_PASSWORD") or ""
    if not imap_user or not imap_password:
        print("Error: IMAP credentials required via --imap-user/--imap-password or GMAIL_USER/GMAIL_PASSWORD")
        return 1

    print(f"[*] Domain: {args.domain}")
    print(f"[*] Proxy: {proxy or 'direct'}")
    print(f"[*] IMAP: {imap_user}")
    print(f"[*] Count: {args.count}, Threads: {args.threads}")

    tasks = []
    for i in range(args.count):
        tasks.append((i + 1, gen_alias(args.domain), gen_password()))

    results = []
    threads = max(1, min(int(args.threads or 1), 10))
    if threads == 1:
        for idx, alias, password in tasks:
            print(f"\n=== Account {idx}/{args.count} ===")
            res = do_register(alias, password, imap_user, imap_password, headless=args.headless, proxy=proxy or None)
            results.append(res)
            if idx < args.count:
                time.sleep(3)
    else:
        from concurrent.futures import ThreadPoolExecutor, as_completed
        print(f"[*] Running with {threads} threads")
        with ThreadPoolExecutor(max_workers=threads) as ex:
            futs = {
                ex.submit(
                    do_register, alias, password, imap_user, imap_password, args.headless, proxy or None
                ): (idx, alias)
                for idx, alias, password in tasks
            }
            for fut in as_completed(futs):
                idx, alias = futs[fut]
                try:
                    res = fut.result()
                except Exception as exc:
                    res = {"ok": False, "email": alias, "error": str(exc)}
                results.append(res)
                status = "OK" if res.get("ok") else "FAIL"
                print(f"[{status}] #{idx} {res.get('email')} {res.get('error', '')[:80]}")

    print(f"\n=== Summary ===")
    ok = sum(1 for r in results if r.get("ok"))
    print(f"Success: {ok}/{len(results)}")
    for r in results:
        status = "OK" if r.get("ok") else "FAIL"
        extra = r.get("cpa_path") or r.get("error", "")
        print(f"  [{status}] {r.get('email')} - {str(extra)[:100]}")
    return 0 if ok else 1

if __name__ == "__main__":
    raise SystemExit(main() or 0)