# -*- coding: utf-8 -*-
"""最小 CDP 客户端：只导航 + 取文本，用来做「域对照实验」"""
import json
import time

import requests
from websocket import create_connection

TARGET_URL = "https://xxx.example.com/search"


def probe(enable_domains=(), timeout=20):
    # 1) 拿到页面 target 的 ws 地址
    targets = requests.get("http://127.0.0.1:9222/json", timeout=5).json()
    page = next(t for t in targets if t["type"] == "page")

    ws = create_connection(page["webSocketDebuggerUrl"], timeout=timeout)
    seq = 0

    def call(method, params=None, wait=True):
        nonlocal seq
        seq += 1
        msg_id = seq
        ws.send(json.dumps({
            "id": msg_id,
            "method": method,
            "params": params or {},
        }))
        if not wait:
            return None
        deadline = time.time() + timeout
        while time.time() < deadline:
            try:
                msg = json.loads(ws.recv())
            except Exception:
                return None
            if msg.get("id") == msg_id:
                return msg
        return None

    # 2) 必开的 Page 域（导航需要）
    call("Page.enable")

    # 3) 按参数 enable 待测域
    for domain in enable_domains:
        call(f"{domain}.enable")

    # 4) 导航
    call("Page.navigate", {"url": TARGET_URL})

    # 5) 等一会儿，取页面文本
    time.sleep(8)
    result = call("Runtime.evaluate", {
        "expression": "document.body ? document.body.innerText.slice(0,200) : ''",
        "returnByValue": True,
    })
    ws.close()

    if not result:
        return None
    value = result.get("result", {}).get("result", {}).get("value", "")
    return value


if __name__ == "__main__":
    cases = [
        (),
        ("Runtime",),
        ("Network",),
        ("DOM",),
        ("Log",),
        ("Debugger",),      # 重点
    ]
    for domains in cases:
        label = "+".join(domains) or "(不 enable 任何域)"
        text = probe(domains)
        print(f"{label:>20} -> {repr((text or '')[:80])}")

from ruyipage import launch

page = launch(
    user_dir="./xxx_firefox",
    headless=False,
    close_on_exit=True,
    window_size=(1920, 1080),
)
page.get("https://xxx.example.com/search", wait="interactive", timeout=20)

print("title =", page.title)
print("html  =", len(page.html or ""))
print("text  =", (page.html or "")[:200])
page.quit()

page.ele(".btn operation")      # class 同时包含 btn 和 operation

# -*- coding: utf-8 -*-
"""DrissionPage 风格 -> ruyipage 的最小适配层"""
import time

from ruyipage import Keys


def translate(sel):
    if not isinstance(sel, str):
        return sel
    s = sel.strip()
    if not s:
        return s
    if s.startswith(("css:", "c:", "xpath:", "x:", "text:", "text=", "tag:")):
        return s
    if s.startswith(("#", "[", "*")):
        return "css:" + s
    if s.startswith(("/", "./")):
        return s
    if s.startswith("."):
        words = [w for w in s[1:].split() if w]
        if not words:
            return "css:body"
        if all(not w.startswith(".") for w in words):
            return "css:" + "".join("." + w for w in words)
        return "css:." + " ".join(words)
    return s


class Actions:
    def __init__(self, owner):
        self._o = owner

    def hold(self, ele=None):
        self._o.actions.hold(getattr(ele, "_el", ele))
        self._o.actions.perform()
        return self

    def move(self, offset_x=0, offset_y=0, duration=100):
        if 0 < duration < 5:            # DP 传秒，ruyipage 要毫秒
            duration *= 1000
        self._o.actions.move(int(round(offset_x)), int(round(offset_y)), int(duration))
        self._o.actions.perform()
        return self

    def release(self):
        self._o.actions.release()
        self._o.actions.perform()
        return self


class Element:
    def __init__(self, el):
        self._el = el

    def __bool__(self):
        try:
            return bool(self._el)
        except Exception:
            return False

    @property
    def text(self):
        try:
            return self._el.text or ""
        except Exception:
            return ""

    @property
    def html(self):
        try:
            return self._el.html or ""
        except Exception:
            return ""

    def attr(self, name):
        try:
            return self._el.attr(name)
        except Exception:
            return None

    def style(self, name):
        try:
            return self._el.style(name)
        except Exception:
            return ""

    @property
    def rect(self):
        return self._el.rect

    def click(self):
        self._el.click_self()
        return self

    def input(self, text, clear=True):
        text = str(text)
        enter = text.endswith("\n")
        body = text.rstrip("\r\n")
        if body:
            self._el.input(body, clear=clear)
        elif clear:
            try:
                self._el.clear()
            except Exception:
                pass
        if enter:
            self._el._owner.actions.press(Keys.ENTER).perform()
        return self

    def clear(self):
        try:
            self._el.clear()
        except Exception:
            pass
        return self

    def run_js(self, js):
        js = str(js).strip()
        if js.startswith(("function", "(", "async")):
            return self._el.run_js(js)
        return self._el.run_js("function(){" + js + "}")

    def ele(self, sel, timeout=None):
        return Element(self._el.ele(translate(sel), timeout=timeout))

    def eles(self, sel, timeout=None):
        return [Element(e) for e in self._el.eles(translate(sel), timeout=timeout)]

    def screenshot(self, as_bytes="png"):
        return self._el.screenshot(as_bytes=as_bytes)


class Tab:
    def __init__(self, obj):
        self._o = obj

    @property
    def tab_id(self):
        return self._o.tab_id

    @property
    def url(self):
        return self._o.url

    @property
    def title(self):
        return self._o.title

    @property
    def html(self):
        return self._o.html or ""

    @property
    def actions(self):
        return Actions(self._o)

    def get(self, url, timeout=20, wait="interactive"):
        self._o.get(url, wait=wait, timeout=timeout)
        return self

    def ele(self, sel, timeout=None):
        return Element(self._o.ele(translate(sel), timeout=timeout))

    def eles(self, sel, timeout=None):
        return [Element(e) for e in self._o.eles(translate(sel), timeout=timeout)]

    def run_js(self, js):
        js = str(js).strip()
        if "return" in js and not js.startswith(("function", "(")):
            return self._o.run_js(js, as_expr=False)
        return self._o.run_js(js, as_expr=True)

    def screenshot(self, as_bytes="png", full_page=False):
        return self._o.screenshot(full_page=full_page, as_bytes=as_bytes)

    def close(self):
        self._o.close()


class Page(Tab):
    @property
    def latest_tab(self):
        return Tab(self._o.latest_tab)

    def get_tabs(self):
        return [Tab(t) for t in self._o.get_tabs()]

    def quit(self):
        self._o.quit()

    def close(self):
        self._o.close()

AUTH_URL = (
    "https://xxx.example.com/oauth/authorize"
    "?response_type=code&scope=openid"
    "&client_id=xxx"
    "&redirect_uri=https://xxx.example.com/init"
)
page.get(AUTH_URL)

def logged_in(page):
    # 1) 不在登录页
    if "login" in str(page.url).lower():
        return False
    # 2) 页头没有「登录/注册」入口
    if page.eles("css:.login-entry", timeout=1):
        return False
    # 3) localStorage 里有 token（或页面上有用户菜单）
    if page.run_js('return localStorage.getItem("token")'):
        return True
    return bool(page.ele("css:.user-menu", timeout=2))

import base64
import re
from io import BytesIO

import cv2
import numpy as np
from PIL import Image


def decode(b64):
    if "," in b64:
        b64 = b64.split(",", 1)[1]
    img = Image.open(BytesIO(base64.b64decode(b64)))
    alpha = np.array(img.split()[-1]) if img.mode in ("RGBA", "LA") else None
    rgb = cv2.cvtColor(np.array(img.convert("RGB")), cv2.COLOR_RGB2BGR)
    return rgb, alpha


def find_gap(bg, sl, alpha):
    bg_gray = cv2.cvtColor(bg, cv2.COLOR_BGR2GRAY)
    sl_gray = cv2.cvtColor(sl, cv2.COLOR_BGR2GRAY)
    if alpha is not None and alpha.shape[:2] == sl_gray.shape[:2]:
        mask = (alpha > 10).astype(np.uint8) * 255
        if mask.sum():
            res = cv2.matchTemplate(bg_gray, sl_gray, cv2.TM_CCORR_NORMED, mask=mask)
        else:
            res = cv2.matchTemplate(bg_gray, sl_gray, cv2.TM_CCOEFF_NORMED)
    else:
        res = cv2.matchTemplate(bg_gray, sl_gray, cv2.TM_CCOEFF_NORMED)
    res = np.nan_to_num(res, nan=0, posinf=0, neginf=0)
    _, score, _, loc = cv2.minMaxLoc(res)
    return loc[0], score

def solve_slider(page):
    bg_el = page.ele("css:.verify-img-panel img", timeout=2)
    sl_el = page.ele("css:.verify-sub-block img", timeout=2)
    if not bg_el or not sl_el:
        return False

    bg, _ = decode(bg_el.attr("src") or "")
    sl, alpha = decode(sl_el.attr("src") or "")
    gap_x, score = find_gap(bg, sl, alpha)

    ratio = 1.0
    try:
        w = float(re.sub(r"[^0-9.]", "", bg_el.style("width") or "") or 0)
        natural = int(bg_el.run_js("return this.naturalWidth") or 0)
        if w and natural:
            ratio = w / natural
    except Exception:
        pass

    distance = max(1.0, gap_x * ratio)
    n = 30
    weights = [0.25 + 3.0 * np.sin(np.pi * (i + 0.5) / n) ** 0.8 for i in range(n)]
    total = sum(weights)
    tracks = [max(1, int(round(distance * w / total))) for w in weights]
    tracks[-1] += int(distance) - sum(tracks)

    handle = page.ele(".verify-move-block")
    if not handle:
        return False
    page.actions.hold(handle)
    time.sleep(0.4)
    for t in tracks:
        page.actions.move(offset_x=t, offset_y=np.random.randint(-2, 3), duration=0.05)
        time.sleep(0.01)
    page.actions.move(offset_x=3, duration=0.05)
    page.actions.move(offset_x=-3, duration=0.05)
    time.sleep(0.3)
    page.actions.release()
    time.sleep(2)

    if "验证成功" in (page.html or "") or "验证通过" in (page.html or ""):
        return True
    return not page.ele("css:.verify-img-panel img", timeout=0.5)

def open_search(page):
    page.get(SEARCH_URL, wait="interactive", timeout=20)
    time.sleep(3)
    box = page.ele(".search-input", timeout=10)
    if not box:
        raise RuntimeError("检索框没出来")
    return box

def search(page, keyword):
    box = open_search(page)
    inp = box.ele("tag:input")
    inp.clear()
    inp.input(keyword + "\n")       # 适配层会把 \n 转成 Enter

    for _ in range(15):
        time.sleep(1)
        tab = page.latest_tab
        if "login" in str(tab.url).lower():
            return "NEED_LOGIN"
        if tab.eles(".result-row", timeout=1):
            return tab
    return None

def open_detail(page, result_tab, timeout=30):
    before = {t.tab_id for t in page.get_tabs()}
    result_tab.eles(".result-row")[0].click()

    deadline = time.time() + timeout
    while time.time() < deadline:
        time.sleep(1)
        for t in page.get_tabs():
            if t.tab_id in before:
                continue
            if t.ele(".detail-panel", timeout=1):
                return t
    return None

from bs4 import BeautifulSoup


def parse_detail(html):
    soup = BeautifulSoup(html, "html.parser")
    root = soup.select_one(".detail-panel")
    data = {}
    if not root:
        return data
    for item in root.select(".kv-item"):
        k = item.select_one(".key")
        v = item.select_one(".value")
        if k and v:
            data[k.get_text(strip=True)] = v.get_text(strip=True)
    return data

def screenshot(tab):
    el = tab.ele(".result-panel", timeout=4)
    if el:
        return base64.b64encode(el.screenshot()).decode("utf-8")
    return base64.b64encode(tab.screenshot(full_page=True)).decode("utf-8")

# -*- coding: utf-8 -*-
import argparse
import base64
import json
import os
import re
import time
from io import BytesIO

import cv2
import numpy as np
from bs4 import BeautifulSoup
from PIL import Image
from ruyipage import Keys, launch

BASE_URL = "https://xxx.example.com"
SEARCH_URL = BASE_URL + "/search"
AUTH_URL = (BASE_URL + "/oauth/authorize?response_type=code&scope=openid"
            "&client_id=xxx&redirect_uri=" + BASE_URL + "/init")

ACCOUNT = os.environ.get("XXX_USER", "")
PASSWORD = os.environ.get("XXX_PASS", "")


# ---------- 依赖（从上面复制进来） ----------
# 1) 第十一节的 translate / Actions / Element / Tab / Page
# 2) 12.3 的 decode / find_gap / solve_slider


def parse_detail(html):
    soup = BeautifulSoup(html, "html.parser")
    root = soup.select_one(".detail-panel")
    data = {}
    if not root:
        return data
    for item in root.select(".kv-item"):
        k = item.select_one(".key")
        v = item.select_one(".value")
        if k and v:
            data[k.get_text(strip=True)] = v.get_text(strip=True)
    return data


def handle_consent(page):
    """点掉免责声明 / 协议页"""
    for word, max_len in (("记住我的选择", 30), ("同意", 12)):
        try:
            els = page.eles(
                f'xpath://*[contains(text(),"{word}") and string-length(text())<{max_len}]',
                timeout=1)
        except Exception:
            els = []
        for el in els:
            txt = (el.text or "").strip()
            if not txt or any(d in txt for d in ("不同意", "拒绝", "取消")):
                continue
            try:
                el.click()
                time.sleep(0.8)
                return True
            except Exception:
                continue
    return False


def logged_in(page):
    if "login" in str(page.url).lower():
        return False
    try:
        if page.eles("css:.login-entry", timeout=1):
            return False
        if page.run_js('return localStorage.getItem("token")'):
            return True
    except Exception:
        pass
    return bool(page.ele("css:.search-input", timeout=2))


def login(page):
    if not ACCOUNT or not PASSWORD:
        raise SystemExit("请设置 XXX_USER / XXX_PASS")

    page.get(AUTH_URL)
    time.sleep(3)
    handle_consent(page)

    inputs = page.eles("css:.login-form input", timeout=10)
    if not inputs:
        return page
    for i, box in enumerate(inputs[:2]):
        inp = box.ele("tag:input")
        try:
            inp.clear()
        except Exception:
            pass
        inp.input([ACCOUNT, PASSWORD][i])
    time.sleep(1)

    page.ele(".login-btn", timeout=8).click()
    time.sleep(4)

    for i in range(1, 7):
        handle_consent(page)
        if not page.ele("css:.verify-img-panel img", timeout=2):
            break
        print(f"滑块第 {i} 次")
        try:
            solve_slider(page)
        except Exception as e:
            print("滑块异常:", e)
        time.sleep(1)

    for _ in range(30):
        time.sleep(2)
        if page.run_js('return localStorage.getItem("token")'):
            print("登录成功")
            break
    return page


def ensure_login(page, force=False):
    page.get(SEARCH_URL)
    time.sleep(4)
    if not force and logged_in(page):
        return page
    for attempt in range(1, 3):
        print(f"第 {attempt} 次登录")
        login(page)
        handle_consent(page)
        page.get(SEARCH_URL)
        time.sleep(4)
        if logged_in(page):
            return page
        time.sleep(10)
    return page


def read_detail(page, result_tab):
    st = ""
    try:
        panel = result_tab.ele(".tab-list", timeout=5)
        if panel:
            panel.ele("text:法律状态").click()
            time.sleep(3)
        for row in result_tab.eles(".table-row", timeout=5):
            st = row.ele("xpath:.//td[3]").text.strip()
            if st:
                break
    except Exception:
        pass

    img = None
    el = result_tab.ele(".result-panel", timeout=4)
    if el:
        img = base64.b64encode(el.screenshot()).decode("utf-8")

    before = {t.tab_id for t in page.get_tabs()}
    result_tab.eles(".result-row")[0].click()
    detail_tab = None
    deadline = time.time() + 30
    while time.time() < deadline:
        time.sleep(1)
        for t in page.get_tabs():
            if t.tab_id not in before and t.ele(".detail-panel", timeout=1):
                detail_tab = t
                break
        if detail_tab:
            break

    fields = {"法律状态": st} if st else {}
    if detail_tab:
        for _ in range(6):
            detail = parse_detail(detail_tab.html or "")
            if detail:
                fields.update(detail)
                break
            time.sleep(2)
        detail_tab.close()
    return fields, img


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--kw", required=True)
    ap.add_argument("--json", action="store_true")
    args = ap.parse_args()

    page = Page(launch(
        user_dir="./xxx_firefox",
        headless=False,
        close_on_exit=True,
        window_size=(1920, 1080),
        timeout_base=15,
        timeout_page_load=60,
    ))
    try:
        page = ensure_login(page)
        result_tab = search(page, args.kw)
        if isinstance(result_tab, str) or result_tab is None:
            print("无结果 / 需要登录")
            return
        fields, img = read_detail(page, result_tab)
        out = {"found": bool(fields), "fields": fields, "img_len": len(img or "")}
        if args.json:
            print(json.dumps(out, ensure_ascii=False, indent=1))
        else:
            for k, v in fields.items():
                print(f"{k} = {v}")
    finally:
        page.quit()


if __name__ == "__main__":
    main()