#!/usr/bin/env python3
"""离线分析切片乱序图片验证码并尝试还原。

脚本只读取本地证据，不打开网页、不控制浏览器、不提交验证码、
不发送网络请求。
"""

from __future__ import annotations

import argparse
import itertools
import json
import math
import re
import sys
from pathlib import Path
from typing import Any

try:
    from PIL import Image, ImageStat
except ImportError:  # pragma: no cover - depends on local environment
    Image = None  # type: ignore[assignment]
    ImageStat = None  # type: ignore[assignment]


def configure_utf8_stdio() -> None:
    for stream in (sys.stdout, sys.stderr):
        if hasattr(stream, "reconfigure"):
            stream.reconfigure(encoding="utf-8")


configure_utf8_stdio()


def read_value(value: str | None) -> str:
    if not value:
        return ""
    path = Path(value)
    if path.exists() and path.is_file():
        for encoding in ("utf-8", "utf-8-sig", "gb18030"):
            try:
                return path.read_text(encoding=encoding)
            except UnicodeDecodeError:
                continue
        return path.read_text(errors="replace")
    return value


def parse_order(value: str | None) -> list[int] | None:
    if not value:
        return None
    numbers = [int(item) for item in re.findall(r"-?\d+", value)]
    return numbers or None


def compact(text: str, limit: int = 100) -> str:
    cleaned = re.sub(r"\s+", " ", text.strip())
    if len(cleaned) <= limit:
        return cleaned
    return cleaned[: limit - 1] + "…"


def collect_text_signals(text: str) -> list[dict[str, str]]:
    patterns = [
        ("切片乱序中文文案", r"切片乱序|分块乱序|图片分割|瓦片重排|分割顺序打乱|乱序图片还原|图片被切成多块|顺序打乱"),
        ("切片乱序英文文案", r"\b(?:scrambled tiles|tile scramble|scrambled image tiles|image tile restore|reorder tiles)\b"),
        ("tileOrder/pieceOrder 字段", r"\b(?:tileOrder|pieceOrder|tile_order|piece_order|restoreOrder|sliceOrder)\b"),
        ("CSS 背景切片线索", r"background-position|background-size|sprite"),
        ("Canvas 绘制切片线索", r"\bdrawImage\s*\("),
        ("布局位置线索", r"\b(?:transform|translate3d|translate|left|top)\b.{0,80}\b(?:px|tile|piece|slice)\b"),
        ("shuffle/scramble 线索", r"\b(?:shuffle|scramble|unscramble|slice|tile|piece)\b.{0,80}\b(?:captcha|verify|challenge|image)\b"),
    ]
    signals: list[dict[str, str]] = []
    for label, pattern in patterns:
        match = re.search(pattern, text, flags=re.IGNORECASE | re.DOTALL)
        if match:
            signals.append({"label": label, "evidence": compact(match.group(0)), "source": "text"})
    return signals


def extract_order_arrays(text: str) -> tuple[list[int] | None, list[dict[str, str]]]:
    signals: list[dict[str, str]] = []
    for pattern in (
        r"\b(?:tileOrder|pieceOrder|tile_order|piece_order|restoreOrder|sliceOrder)\b\s*[:=]\s*\[([^\]]+)\]",
        r"[\"'](?:tileOrder|pieceOrder|tile_order|piece_order|restoreOrder|sliceOrder)[\"']\s*:\s*\[([^\]]+)\]",
    ):
        match = re.search(pattern, text, flags=re.IGNORECASE | re.DOTALL)
        if not match:
            continue
        order = [int(item) for item in re.findall(r"-?\d+", match.group(1))]
        if order:
            signals.append({"label": "抽取显式切片顺序数组", "evidence": compact(match.group(0)), "source": "html"})
            return order, signals
    return None, signals


def extract_background_position_order(
    text: str,
    rows: int | None,
    cols: int | None,
    tile_width: int | None,
    tile_height: int | None,
) -> tuple[list[int] | None, list[dict[str, str]]]:
    if not rows or not cols or not tile_width or not tile_height:
        return None, []
    pattern = r"background-position\s*:\s*(-?\d+(?:\.\d+)?)px\s+(-?\d+(?:\.\d+)?)px"
    order: list[int] = []
    signals: list[dict[str, str]] = []
    for match in re.finditer(pattern, text, flags=re.IGNORECASE):
        x = abs(float(match.group(1)))
        y = abs(float(match.group(2)))
        col = int(round(x / tile_width))
        row = int(round(y / tile_height))
        if 0 <= row < rows and 0 <= col < cols:
            order.append(row * cols + col)
            signals.append({"label": "抽取 background-position 切片来源", "evidence": compact(match.group(0)), "source": "html"})
    expected = rows * cols
    if len(order) == expected:
        return order, signals
    return None, signals


def extract_draw_image_order(
    text: str,
    rows: int | None,
    cols: int | None,
    tile_width: int | None,
    tile_height: int | None,
) -> tuple[list[int] | None, list[dict[str, str]]]:
    if not rows or not cols or not tile_width or not tile_height:
        return None, []
    pattern = r"drawImage\s*\([^,]+,\s*([-\d.]+),\s*([-\d.]+),\s*([-\d.]+),\s*([-\d.]+),\s*([-\d.]+),\s*([-\d.]+)"
    found: dict[int, int] = {}
    signals: list[dict[str, str]] = []
    for match in re.finditer(pattern, text, flags=re.IGNORECASE):
        sx = float(match.group(1))
        sy = float(match.group(2))
        dx = float(match.group(5))
        dy = float(match.group(6))
        src_col = int(round(sx / tile_width))
        src_row = int(round(sy / tile_height))
        dst_col = int(round(dx / tile_width))
        dst_row = int(round(dy / tile_height))
        if 0 <= src_row < rows and 0 <= src_col < cols and 0 <= dst_row < rows and 0 <= dst_col < cols:
            found[dst_row * cols + dst_col] = src_row * cols + src_col
            signals.append({"label": "抽取 drawImage 源/目标切片", "evidence": compact(match.group(0)), "source": "html"})
    expected = rows * cols
    if len(found) == expected:
        return [found[index] for index in range(expected)], signals
    return None, signals


def normalize_order(order: list[int], total: int) -> tuple[list[int] | None, str | None]:
    if len(order) != total:
        return None, f"顺序数组长度为 {len(order)}，但网格需要 {total} 个切片"
    if sorted(order) == list(range(total)):
        return order, None
    if sorted(item - 1 for item in order) == list(range(total)):
        return [item - 1 for item in order], None
    return None, "顺序数组不是 0 基或 1 基的完整排列"


def infer_grid(
    image: Any,
    rows: int | None,
    cols: int | None,
    tile_width: int | None,
    tile_height: int | None,
) -> tuple[int | None, int | None, int | None, int | None, list[str]]:
    warnings: list[str] = []
    width, height = image.size
    if tile_width and not cols:
        cols = width // tile_width
    if tile_height and not rows:
        rows = height // tile_height
    if rows and not tile_height:
        tile_height = height // rows
    if cols and not tile_width:
        tile_width = width // cols
    if not rows or not cols or not tile_width or not tile_height:
        warnings.append("需要提供 rows/cols 或 tile-width/tile-height 才能切片分析图片")
        return rows, cols, tile_width, tile_height, warnings
    if rows * tile_height > height or cols * tile_width > width:
        warnings.append("网格尺寸超过图片尺寸")
    return rows, cols, tile_width, tile_height, warnings


def split_tiles(image: Any, rows: int, cols: int, tile_width: int, tile_height: int) -> list[Any]:
    tiles = []
    for row in range(rows):
        for col in range(cols):
            left = col * tile_width
            top = row * tile_height
            tiles.append(image.crop((left, top, left + tile_width, top + tile_height)).convert("RGB"))
    return tiles


def edge_cost(a: Any, b: Any, direction: str) -> float:
    if direction == "right":
        edge_a = a.crop((a.width - 1, 0, a.width, a.height))
        edge_b = b.crop((0, 0, 1, b.height))
    else:
        edge_a = a.crop((0, a.height - 1, a.width, a.height))
        edge_b = b.crop((0, 0, b.width, 1))
    diff = ImageStat.Stat(Image.eval(ImageChopsCompat.difference(edge_a, edge_b), lambda px: px)).mean
    return float(sum(diff) / len(diff))


class ImageChopsCompat:
    @staticmethod
    def difference(left: Any, right: Any) -> Any:
        from PIL import ImageChops

        return ImageChops.difference(left, right)


def arrangement_cost(order: tuple[int, ...], tiles: list[Any], rows: int, cols: int) -> float:
    total = 0.0
    count = 0
    for row in range(rows):
        for col in range(cols):
            current = tiles[order[row * cols + col]]
            if col + 1 < cols:
                total += edge_cost(current, tiles[order[row * cols + col + 1]], "right")
                count += 1
            if row + 1 < rows:
                total += edge_cost(current, tiles[order[(row + 1) * cols + col]], "down")
                count += 1
    return total / max(count, 1)


def tile_diversity(tiles: list[Any]) -> float:
    means: list[float] = []
    for tile in tiles:
        stat = ImageStat.Stat(tile)
        means.extend(float(value) for value in stat.mean)
    if not means:
        return 0.0
    avg = sum(means) / len(means)
    variance = sum((value - avg) ** 2 for value in means) / len(means)
    return math.sqrt(variance)


def image_edge_match_order(tiles: list[Any], rows: int, cols: int) -> tuple[list[int] | None, float, float, list[str]]:
    total = rows * cols
    warnings: list[str] = []
    if total != len(tiles):
        return None, 0.0, 0.0, ["切片数量和网格不一致"]
    if total > 9:
        warnings.append("切片超过 9 个，第一版不做全排列搜索；请优先使用页面顺序或显式 order")
        return list(range(total)), 0.25, 0.0, warnings

    best_order: tuple[int, ...] | None = None
    best_cost = float("inf")
    second_cost = float("inf")
    for order in itertools.permutations(range(total)):
        cost = arrangement_cost(order, tiles, rows, cols)
        if cost < best_cost:
            second_cost = best_cost
            best_cost = cost
            best_order = order
        elif cost < second_cost:
            second_cost = cost

    diversity = tile_diversity(tiles)
    separation = 0.0 if not math.isfinite(second_cost) else max(0.0, (second_cost - best_cost) / (second_cost + 1e-6))
    confidence = max(0.25, min(0.95, separation * 4.0 + min(diversity / 128.0, 0.35)))
    if separation < 0.02:
        confidence = min(confidence, 0.42)
        warnings.append("候选排列分数接近，可能是重复纹理、纯色块或边缘线索不足")
    if diversity < 6:
        confidence = min(confidence, 0.35)
        warnings.append("切片视觉差异很低，建议改用页面顺序或人工/平台复核")
    return list(best_order or range(total)), round(confidence, 2), round(best_cost, 4), warnings


def restore_image(
    image: Any,
    rows: int,
    cols: int,
    tile_width: int,
    tile_height: int,
    order_source_by_target: list[int],
    output_path: Path,
) -> None:
    tiles = split_tiles(image, rows, cols, tile_width, tile_height)
    restored = Image.new("RGB", (cols * tile_width, rows * tile_height))
    for target_index, source_index in enumerate(order_source_by_target):
        row, col = divmod(target_index, cols)
        restored.paste(tiles[source_index], (col * tile_width, row * tile_height))
    output_path.parent.mkdir(parents=True, exist_ok=True)
    restored.save(output_path)


def build_report(args: argparse.Namespace) -> dict[str, Any]:
    html_text = read_value(args.html)
    plain_text = read_value(args.text)
    combined_text = "\n".join(part for part in (html_text, plain_text) if part)
    signals = collect_text_signals(combined_text)
    warnings: list[str] = []

    rows = args.rows
    cols = args.cols
    tile_width = args.tile_width
    tile_height = args.tile_height
    explicit_order = parse_order(args.order_source_by_target)
    extracted_order: list[int] | None = None

    for extractor in (
        extract_order_arrays,
        lambda text: extract_background_position_order(text, rows, cols, tile_width, tile_height),
        lambda text: extract_draw_image_order(text, rows, cols, tile_width, tile_height),
    ):
        order, found_signals = extractor(combined_text)
        signals.extend(found_signals)
        if order:
            extracted_order = order
            break

    image = None
    if args.image:
        if Image is None:
            warnings.append("当前 Python 环境缺少 Pillow，无法读取图片；只能分析文本/HTML 线索")
        else:
            image_path = Path(args.image)
            if image_path.exists() and image_path.is_file():
                image = Image.open(image_path).convert("RGB")
                rows, cols, tile_width, tile_height, grid_warnings = infer_grid(image, rows, cols, tile_width, tile_height)
                warnings.extend(grid_warnings)
            else:
                warnings.append("图片文件不存在")

    total = rows * cols if rows and cols else 0
    normalized_order: list[int] | None = None
    order_warning: str | None = None
    order_source = ""
    if explicit_order and total:
        normalized_order, order_warning = normalize_order(explicit_order, total)
        order_source = "argument"
    elif extracted_order and total:
        normalized_order, order_warning = normalize_order(extracted_order, total)
        order_source = "page"
    if order_warning:
        warnings.append(order_warning)

    confidence = 0.0
    edge_cost_value: float | None = None
    restore_strategy = "manual-or-platform"
    if normalized_order:
        confidence = 0.92 if order_source == "argument" else 0.86
        restore_strategy = "page-order"
    elif image is not None and rows and cols and tile_width and tile_height:
        tiles = split_tiles(image, rows, cols, tile_width, tile_height)
        normalized_order, confidence, edge_cost_value, edge_warnings = image_edge_match_order(tiles, rows, cols)
        warnings.extend(edge_warnings)
        restore_strategy = "image-edge-match" if confidence >= 0.55 else "manual-or-platform"
    elif signals:
        confidence = 0.58

    restored_image: str | None = None
    if image is not None and rows and cols and tile_width and tile_height and normalized_order and args.output_image:
        if len(normalized_order) == rows * cols:
            output_path = Path(args.output_image)
            restore_image(image, rows, cols, tile_width, tile_height, normalized_order, output_path)
            restored_image = str(output_path)
        else:
            warnings.append("顺序长度不匹配，未输出还原图片")

    is_tile_scramble = bool(signals or normalized_order or (image is not None and rows and cols))
    if not signals and normalized_order:
        signals.append({"label": "提供显式切片顺序", "evidence": ",".join(str(item) for item in normalized_order), "source": "argument"})
    if image is not None and rows and cols:
        signals.append({"label": "图片网格切片证据", "evidence": f"{rows}x{cols}", "source": "image"})

    return {
        "is_tile_scramble": is_tile_scramble,
        "grid": {
            "rows": rows,
            "cols": cols,
            "tile_width": tile_width,
            "tile_height": tile_height,
            "total": total,
        },
        "order_source_by_target": normalized_order,
        "confidence": round(confidence, 2),
        "restore_strategy": restore_strategy,
        "edge_match_cost": edge_cost_value,
        "signals": signals,
        "warnings": warnings,
        "restored_image": restored_image,
        "notes": [
            "脚本只做离线切片判断和图片还原，不打开网页、不点击页面、不提交验证。",
            "优先相信页面逻辑中的顺序字段；纯图片边缘匹配低置信度时应切换人工或平台复核。",
        ],
    }


def build_parser() -> argparse.ArgumentParser:
    parser = argparse.ArgumentParser(description="离线分析切片乱序图片验证码")
    parser.add_argument("--image", help="待分析的乱序图片路径")
    parser.add_argument("--html", help="HTML/CSS/JS 片段或文件路径")
    parser.add_argument("--text", help="页面文案或分析备注")
    parser.add_argument("--rows", type=int, help="切片行数")
    parser.add_argument("--cols", type=int, help="切片列数")
    parser.add_argument("--tile-width", type=int, help="单块宽度")
    parser.add_argument("--tile-height", type=int, help="单块高度")
    parser.add_argument("--order-source-by-target", help="还原顺序：每个目标位置使用哪个当前切片索引，支持逗号分隔")
    parser.add_argument("--output-image", help="输出还原图片路径")
    parser.add_argument("--pretty", action="store_true", help="以缩进格式输出 JSON")
    return parser


def main() -> int:
    args = build_parser().parse_args()
    report = build_report(args)
    print(json.dumps(report, ensure_ascii=False, indent=2 if args.pretty else None))
    return 0


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