from __future__ import annotations

import json
import os
import re
import shutil
import sys
import zipfile
from pathlib import Path
from typing import Any
from urllib.parse import parse_qsl, unquote, urlparse

import click
import requests

SENSITIVE_HEADERS = {"cookie", "authorization", "x-csrf-token", "x-xsrf-token"}
LIST_PATH_HINT = "/sz/api/selfHelpAnalysis/getReportList.ajax"
EXPORT_PATH_HINT = "/sz/api/selfHelpAnalysis/exportPreviewList.ajax"
DEFAULT_CREDENTIAL_DIR = Path("/Users/bot1/.hermes/profiles/it/secrets/jd-report-exporter")


def _json_print(payload: Any) -> None:
    click.echo(json.dumps(payload, ensure_ascii=False, indent=2))


def _load_json(path: str | Path) -> Any:
    return json.loads(Path(path).expanduser().read_text(encoding="utf-8"))


def _write_json(path: Path, payload: Any, mode: int | None = None) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    path.write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")
    if mode is not None:
        os.chmod(path, mode)


def _headers_dict(headers: list[dict[str, str]] | dict[str, str], *, include_sensitive: bool = False) -> dict[str, str]:
    if isinstance(headers, dict):
        pairs = headers.items()
    else:
        pairs = ((h.get("name", ""), h.get("value", "")) for h in headers)
    out: dict[str, str] = {}
    for key, value in pairs:
        if not key:
            continue
        lower = key.lower()
        if lower.startswith(":") or lower in {"content-length", "host", "accept-encoding"}:
            continue
        if not include_sensitive and lower in SENSITIVE_HEADERS:
            continue
        out[key] = value
    return out


def _find_entry(entries: list[dict[str, Any]], path_hint: str, *, method: str | None = None) -> dict[str, Any] | None:
    for entry in entries:
        req = entry.get("request", {})
        url = req.get("url", "")
        if path_hint in url and (method is None or (req.get("method") or "").upper() == method.upper()):
            return entry
    return None


def _find_cookie_header(entry: dict[str, Any]) -> str | None:
    for h in entry.get("request", {}).get("headers", []):
        if h.get("name", "").lower() == "cookie" and h.get("value"):
            return h["value"]
    return None


def _parse_form(text: str | None) -> dict[str, str]:
    if not text:
        return {}
    return dict(parse_qsl(text, keep_blank_values=True))


def _decode_response_text(content: dict[str, Any]) -> str:
    text = content.get("text") or ""
    if content.get("encoding") == "base64":
        import base64
        return base64.b64decode(text).decode("utf-8", "replace")
    return text


def _reports_from_list_payload(payload: Any, *, list_url: str | None = None, export_url: str | None = None) -> list[dict[str, Any]]:
    page = (payload or {}).get("content", {}).get("pageList", {}) if isinstance(payload, dict) else {}
    rows = page.get("data", [])
    meta = page.get("metaIndex", {})
    reports = []
    for row in rows:
        if not isinstance(row, list):
            continue
        def get(key: str, default: Any = None) -> Any:
            idx = meta.get(key)
            if isinstance(idx, int) and 0 <= idx < len(row):
                return row[idx]
            return default
        reports.append({
            "report_name": get("ReportName", ""),
            "update_num": get("UpdateNum"),
            "create_time": get("CreateTime"),
            "report_dim": str(get("ReportDim", "")),
            "query_time": get("QueryTime"),
            "indicators": get("Indicators", []),
            "report_id": str(get("ReportId", "")),
            "start_date": str(get("StartDate", "")),
            "end_date": str(get("EndDate", "")),
            "sku_id": str(get("SkuId", "")),
            "attributions": get("Attributions", []),
            "list_url": list_url,
            "export_url": export_url or "https://sz.jd.com/sz/api/selfHelpAnalysis/exportPreviewList.ajax",
        })
    return reports


def _load_cookie_header(cookie_file: Path | None, credential_dir: Path | None) -> str | None:
    path = cookie_file or ((credential_dir or DEFAULT_CREDENTIAL_DIR) / "cookie.json")
    if not path.exists():
        return None
    text = path.read_text(encoding="utf-8").strip()
    if not text:
        return None
    try:
        data = json.loads(text)
    except json.JSONDecodeError:
        return text
    if isinstance(data, dict):
        for key in ("Cookie", "cookie"):
            if isinstance(data.get(key), str):
                return data[key]
        if all(isinstance(v, str) for v in data.values()):
            return "; ".join(f"{k}={v}" for k, v in data.items())
    if isinstance(data, list):
        return "; ".join(f"{x['name']}={x['value']}" for x in data if isinstance(x, dict) and x.get("name") and x.get("value") is not None)
    raise click.ClickException(f"Unsupported cookie file format: {path}")


def _load_optional_json(path: Path | None, default_path: Path) -> dict[str, Any]:
    p = path or default_path
    if p.exists():
        data = _load_json(p)
        if isinstance(data, dict):
            return data
    return {}


def _safe_filename(name: str) -> str:
    return re.sub(r"[\\/:*?\"<>|]+", "_", name).strip()[:180] or "jd_report"


def _decode_disposition_filename(dispo: str, fallback: str) -> str:
    match = re.search(r'filename\*?=(?:UTF-8\'\')?"?([^";]+)', dispo, re.I)
    if not match:
        return fallback
    raw = unquote(match.group(1)).strip().strip('"')
    if not raw:
        return fallback
    # JD often emits UTF-8 bytes interpreted as latin1 in Content-Disposition.
    for decoder in (
        lambda s: s.encode("latin1").decode("utf-8"),
        lambda s: s.encode("latin1").decode("gbk"),
        lambda s: s,
    ):
        try:
            decoded = decoder(raw)
            if decoded:
                return _safe_filename(decoded)
        except Exception:
            pass
    return _safe_filename(raw)


@click.group(context_settings={"help_option_names": ["-h", "--help"]})
def main() -> None:
    """京东/商智自助分析报表导出 CLI harness."""


@main.command()
def doctor() -> None:
    """检查当前 CLI 运行环境。"""
    _json_print({"ok": True, "python": sys.version.split()[0], "requests": requests.__version__, "default_credential_dir": str(DEFAULT_CREDENTIAL_DIR)})


@main.command("scan-har")
@click.argument("har", type=click.Path(exists=True, dir_okay=False, path_type=Path))
@click.option("--out", "out_path", type=click.Path(path_type=Path), help="输出不含 Cookie 的 manifest JSON。")
def scan_har(har: Path, out_path: Path | None) -> None:
    """扫描京东 HAR，识别报表列表/导出接口和 HAR 内列表快照。"""
    payload = _load_json(har)
    entries = payload.get("log", {}).get("entries", [])
    list_entry = _find_entry(entries, LIST_PATH_HINT, method="GET")
    export_entry = _find_entry(entries, EXPORT_PATH_HINT, method="POST")
    reports = []
    if list_entry:
        txt = _decode_response_text(list_entry.get("response", {}).get("content", {}))
        try:
            list_json = json.loads(txt)
            reports = _reports_from_list_payload(list_json, list_url=list_entry["request"].get("url"), export_url=export_entry["request"].get("url") if export_entry else None)
        except Exception:
            reports = []
    export_form = _parse_form(export_entry.get("request", {}).get("postData", {}).get("text")) if export_entry else {}
    result = {
        "source_har": str(har),
        "total_entries": len(entries),
        "list_endpoint": list_entry["request"].get("url") if list_entry else None,
        "export_endpoint": export_entry["request"].get("url") if export_entry else None,
        "report_count_in_har_snapshot": len(reports),
        "reports": reports,
        "captured_export_sample": {
            "report_name": export_form.get("ReportName"),
            "start_date": export_form.get("startDate"),
            "end_date": export_form.get("endDate"),
            "report_dim": export_form.get("ReportDim"),
            "sku_id": export_form.get("SkuId"),
            "has_identity_fields": all(export_form.get(k) for k in ("User-mup", "User-mnp", "uuid")),
        },
        "notes": ["Cookie/Authorization are not embedded; use extract-credentials to save them locally.", "Export endpoint returns a ZIP containing one XLS file in smoke tests."],
    }
    if out_path:
        _write_json(out_path, result)
        click.echo(str(out_path))
    else:
        _json_print(result)


@main.command("extract-credentials")
@click.argument("har", type=click.Path(exists=True, dir_okay=False, path_type=Path))
@click.option("--out-dir", type=click.Path(path_type=Path), default=DEFAULT_CREDENTIAL_DIR, show_default=True)
def extract_credentials(har: Path, out_dir: Path) -> None:
    """从 HAR 提取 Cookie、非敏感请求头、导出表单身份字段到本地 secrets 目录。"""
    payload = _load_json(har)
    entries = payload.get("log", {}).get("entries", [])
    list_entry = _find_entry(entries, LIST_PATH_HINT, method="GET")
    export_entry = _find_entry(entries, EXPORT_PATH_HINT, method="POST")
    if not export_entry:
        raise click.ClickException("HAR 中没有找到 exportPreviewList.ajax POST 请求；请重新采集包含一次导出的 HAR。")
    cookie = _find_cookie_header(export_entry) or (_find_cookie_header(list_entry) if list_entry else None)
    if not cookie:
        raise click.ClickException("HAR 中没有 Cookie；请导出包含请求头的 HAR。")
    out_dir.mkdir(parents=True, exist_ok=True)
    os.chmod(out_dir, 0o700)
    export_headers = _headers_dict(export_entry.get("request", {}).get("headers", []), include_sensitive=False)
    list_headers = _headers_dict(list_entry.get("request", {}).get("headers", []), include_sensitive=False) if list_entry else {}
    form = _parse_form(export_entry.get("request", {}).get("postData", {}).get("text"))
    identity = {k: form[k] for k in ("User-mup", "User-mnp", "uuid") if k in form}
    _write_json(out_dir / "cookie.json", {"Cookie": cookie}, 0o600)
    _write_json(out_dir / "export_headers.json", export_headers, 0o600)
    _write_json(out_dir / "list_headers.json", list_headers, 0o600)
    _write_json(out_dir / "form_identity.json", identity, 0o600)
    readme = out_dir / "README.md"
    readme.write_text("京东/商智 jd-export 本地登录态目录。不要提交、不要发聊天、不要同步到 NAS。Cookie 过期或风控时重新采集 HAR。\n", encoding="utf-8")
    os.chmod(readme, 0o600)
    _json_print({"out_dir": str(out_dir), "files": ["cookie.json", "export_headers.json", "list_headers.json", "form_identity.json", "README.md"], "cookie_chars": len(cookie), "identity_fields": sorted(identity)})


@main.command("fetch-list")
@click.argument("manifest", type=click.Path(exists=True, dir_okay=False, path_type=Path))
@click.option("--credential-dir", type=click.Path(path_type=Path), default=DEFAULT_CREDENTIAL_DIR, show_default=True)
@click.option("--cookie-file", type=click.Path(exists=True, dir_okay=False, path_type=Path))
@click.option("--headers-file", type=click.Path(exists=True, dir_okay=False, path_type=Path))
@click.option("--out", "out_path", type=click.Path(path_type=Path), required=True)
def fetch_list(manifest: Path, credential_dir: Path, cookie_file: Path | None, headers_file: Path | None, out_path: Path) -> None:
    """用本地 Cookie 重放 getReportList.ajax，保存规范化报表列表。"""
    data = _load_json(manifest)
    list_url = data.get("list_endpoint") or f"https://sz.jd.com{LIST_PATH_HINT}"
    export_url = data.get("export_endpoint") or f"https://sz.jd.com{EXPORT_PATH_HINT}"
    headers = _load_optional_json(headers_file, credential_dir / "list_headers.json")
    cookie = _load_cookie_header(cookie_file, credential_dir)
    if cookie:
        headers["Cookie"] = cookie
    resp = requests.get(list_url, headers=headers, timeout=90)
    try:
        payload = resp.json()
    except Exception as exc:
        raise click.ClickException(f"列表接口没有返回 JSON：status={resp.status_code}, content-type={resp.headers.get('content-type')}, error={exc}") from exc
    reports = _reports_from_list_payload(payload, list_url=list_url, export_url=export_url)
    result = {"source": "jd_getReportList.ajax", "status_code": resp.status_code, "list_endpoint": list_url, "export_endpoint": export_url, "report_count": len(reports), "reports": reports}
    _write_json(out_path, result)
    _json_print({"out": str(out_path), "status": resp.status_code, "report_count": len(reports), "report_names": [r["report_name"] for r in reports]})


@main.command("export-all")
@click.argument("report_list", type=click.Path(exists=True, dir_okay=False, path_type=Path))
@click.option("--credential-dir", type=click.Path(path_type=Path), default=DEFAULT_CREDENTIAL_DIR, show_default=True)
@click.option("--cookie-file", type=click.Path(exists=True, dir_okay=False, path_type=Path))
@click.option("--headers-file", type=click.Path(exists=True, dir_okay=False, path_type=Path))
@click.option("--identity-file", type=click.Path(exists=True, dir_okay=False, path_type=Path))
@click.option("--out-dir", type=click.Path(path_type=Path), default=Path("exports"), show_default=True)
@click.option("--dry-run", is_flag=True)
@click.option("--limit", type=int, default=0, show_default=True)
@click.option("--report-name", multiple=True, help="只导出指定报表名，可重复传。")
@click.option("--extract/--no-extract", default=True, show_default=True, help="导出 ZIP 后是否解压其中 XLS 文件。")
def export_all(report_list: Path, credential_dir: Path, cookie_file: Path | None, headers_file: Path | None, identity_file: Path | None, out_dir: Path, dry_run: bool, limit: int, report_name: tuple[str, ...], extract: bool) -> None:
    """按报表列表逐个 POST exportPreviewList.ajax，保存 ZIP/XLS。"""
    data = _load_json(report_list)
    reports = list(data.get("reports", []))
    if report_name:
        names = set(report_name)
        reports = [r for r in reports if r.get("report_name") in names]
    if limit and limit > 0:
        reports = reports[:limit]
    plan = [{"index": i, "report_name": r.get("report_name"), "start_date": r.get("start_date"), "end_date": r.get("end_date"), "report_dim": r.get("report_dim")} for i, r in enumerate(reports, 1)]
    if dry_run:
        _json_print({"dry_run": True, "count": len(plan), "plan": plan})
        return
    if not reports:
        raise click.ClickException("没有可导出的报表。")
    headers = _load_optional_json(headers_file, credential_dir / "export_headers.json")
    cookie = _load_cookie_header(cookie_file, credential_dir)
    if cookie:
        headers["Cookie"] = cookie
    identity = _load_optional_json(identity_file, credential_dir / "form_identity.json")
    missing = [k for k in ("User-mup", "User-mnp", "uuid") if not identity.get(k)]
    if missing:
        raise click.ClickException(f"缺少导出身份字段：{missing}；请从包含一次导出的 HAR 运行 extract-credentials。")
    out_dir.mkdir(parents=True, exist_ok=True)
    zip_dir = out_dir / "zip"
    xls_dir = out_dir / "xls"
    zip_dir.mkdir(exist_ok=True)
    if extract:
        xls_dir.mkdir(exist_ok=True)
    saved = []
    failed = []
    for idx, r in enumerate(reports, 1):
        export_url = r.get("export_url") or data.get("export_endpoint") or f"https://sz.jd.com{EXPORT_PATH_HINT}"
        payload = {
            "SkuId": r.get("sku_id", ""),
            "ReportDim": r.get("report_dim", ""),
            "Indicators": json.dumps(r.get("indicators") or [], ensure_ascii=False, separators=(",", ":")),
            "Attributions": json.dumps(r.get("attributions") or [], ensure_ascii=False, separators=(",", ":")),
            "startDate": r.get("start_date", ""),
            "endDate": r.get("end_date", ""),
            "ReportName": r.get("report_name", f"report_{idx}"),
            **identity,
        }
        try:
            resp = requests.post(export_url, headers=headers, data=payload, timeout=120)
            ctype = resp.headers.get("content-type", "")
            if resp.status_code != 200 or not (resp.content[:2] == b"PK" or "zip" in ctype.lower()):
                failed.append({"index": idx, "report_name": r.get("report_name"), "status": resp.status_code, "content_type": ctype, "message": "response is not ZIP"})
                continue
            fallback = f"{_safe_filename(str(r.get('report_name') or 'jd_report'))}_{r.get('start_date')}_{r.get('end_date')}.zip"
            filename = _decode_disposition_filename(resp.headers.get("content-disposition", ""), fallback)
            if not filename.lower().endswith(".zip"):
                filename += ".zip"
            zip_path = zip_dir / filename
            zip_path.write_bytes(resp.content)
            record = {"index": idx, "report_name": r.get("report_name"), "zip": str(zip_path), "zip_bytes": zip_path.stat().st_size, "extracted": []}
            if extract:
                try:
                    with zipfile.ZipFile(zip_path) as z:
                        for member in z.infolist():
                            if member.is_dir():
                                continue
                            member_name = _safe_filename(Path(member.filename).name)
                            target = xls_dir / member_name
                            with z.open(member) as src, target.open("wb") as dst:
                                shutil.copyfileobj(src, dst)
                            record["extracted"].append(str(target))
                except Exception as exc:
                    failed.append({"index": idx, "report_name": r.get("report_name"), "zip": str(zip_path), "error": f"zip extract failed: {exc!r}"})
                    continue
            saved.append(record)
        except Exception as exc:
            failed.append({"index": idx, "report_name": r.get("report_name"), "error": repr(exc)})
    _json_print({"saved_count": len(saved), "failed_count": len(failed), "saved": saved, "failed": failed})


if __name__ == "__main__":
    main()