"""
Photosweat 去背景 API 的 Python 客户端 —— 零依赖，只用标准库。

    from photosweat import Client
    ps = Client(api_key="sk_free_…")          # 不填就走匿名额度（按出口 IP）
    job = ps.remove_background("photo.jpg", params={"background": "white"})
    open("out.png", "wb").write(ps.result(job))

    # 一批图
    batch = ps.batch(["a.jpg", "b.jpg"], params={"background": "white"})
    for j in batch["jobs"]:
        ps.wait(j["job_id"])

约定（和 llms.txt 同一套口径）：

- 429 rate_limited / 5xx / 503 capacity_full / 网络错误自动退避重试；**同一次调用复用同一个
  Idempotency-Key**，所以重试不会重复扣额度、也不会多建任务。
- 同步接口 20 秒没出图会回 202，这里按 status_url 继续轮询到终态。
- 失败抛 `PhotosweatError`，带 `.code`（机器契约，按它分支）与 `.status`（HTTP 码）。

只用标准库：urllib。Python 3.8+。
"""

from __future__ import annotations

import json
import random
import time
import uuid
from typing import Any, Dict, List, Optional, Union
from urllib.error import HTTPError, URLError
from urllib.parse import quote, urlencode
from urllib.request import Request, urlopen

__all__ = ["Client", "Job", "PhotosweatError", "DEFAULT_BASE"]
__version__ = "1.0.0"

DEFAULT_BASE = "https://photosweat.shop"
_UA = "photosweat-python/1.0"
# CF 的 WAF 会挡 Python-urllib 的默认 UA（403），所以上面这个 UA 是必须的，不是装饰。
_RETRYABLE = {429, 500, 502, 503, 504}
_TERMINAL = {"done", "failed", "error", "expired"}
_MAX_BACKOFF = 8.0


class PhotosweatError(Exception):
    """一次调用失败。`code` 是稳定的机器契约，`status` 是 HTTP 状态码。"""

    def __init__(self, message: str, code: Optional[str] = None,
                 status: Optional[int] = None, body: Optional[dict] = None):
        super().__init__(message)
        self.code = code
        self.status = status
        self.body = body

    def __str__(self) -> str:  # noqa: D105
        bits = [super().__str__()]
        if self.code:
            bits.append("code=%s" % self.code)
        if self.status:
            bits.append("http=%s" % self.status)
        return " ".join(bits)


class Job:
    """任务状态 JSON 的薄封装：`.raw` 是原样响应，其余是常用字段。"""

    def __init__(self, data: Dict[str, Any]):
        self.raw = data

    @property
    def id(self) -> Optional[str]:
        return self.raw.get("job_id") or self.raw.get("jobId")

    @property
    def status(self) -> Optional[str]:
        return self.raw.get("status")

    @property
    def result_url(self) -> Optional[str]:
        return self.raw.get("result_url") or self.raw.get("resultUrl")

    @property
    def status_url(self) -> Optional[str]:
        return self.raw.get("status_url")

    @property
    def error(self) -> Optional[str]:
        return self.raw.get("error")

    def __repr__(self) -> str:  # noqa: D105
        return "<Job %s %s>" % (self.id, self.status)


def _sniff(data: bytes) -> str:
    if data[:8] == b"\x89PNG\r\n\x1a\n":
        return "image/png"
    if data[:3] == b"\xff\xd8\xff":
        return "image/jpeg"
    if data[:4] == b"RIFF" and data[8:12] == b"WEBP":
        return "image/webp"
    raise ValueError("只认 JPEG / PNG / WebP 字节（按文件头判断，不看扩展名）")


def _read(image: Union[str, bytes, bytearray]) -> bytes:
    if isinstance(image, (bytes, bytearray)):
        return bytes(image)
    with open(image, "rb") as fh:
        return fh.read()


def _json_of(body: bytes) -> Optional[dict]:
    try:
        v = json.loads(body.decode("utf-8"))
        return v if isinstance(v, dict) else None
    except Exception:
        return None


def _retry_after(headers: Any, fallback: float) -> float:
    """尊重 retry-after；没有就用指数退避加抖动。"""
    try:
        v = headers.get("retry-after") if headers else None
        if v:
            return max(0.0, float(v))
    except Exception:
        pass
    return min(_MAX_BACKOFF, fallback * (1 + random.random() * 0.5))


class Client:
    """一个 base_url + 一把钥匙 = 一个客户端。线程安全（无本地可变状态）。"""

    def __init__(self, api_key: Optional[str] = None, base_url: str = DEFAULT_BASE,
                 timeout: float = 60.0, retries: int = 3):
        self.api_key = api_key
        self.base_url = base_url.rstrip("/")
        self.timeout = timeout
        self.retries = max(0, int(retries))

    # ---------- 底层 ----------

    def _headers(self, extra: Optional[dict] = None, auth: bool = True) -> Dict[str, str]:
        h = {"Accept": "application/json", "User-Agent": _UA}
        if auth and self.api_key:
            h["Authorization"] = "Bearer " + self.api_key
        if extra:
            h.update(extra)
        return h

    def _request(self, method: str, url: str, data: Optional[bytes] = None,
                 headers: Optional[dict] = None, auth: bool = True,
                 retries: Optional[int] = None):
        attempts = (self.retries if retries is None else retries) + 1
        delay = 0.5
        last: Optional[Exception] = None
        for i in range(attempts):
            req = Request(url, data=data, method=method,
                          headers=self._headers(headers, auth=auth))
            try:
                with urlopen(req, timeout=self.timeout) as resp:
                    return resp.status, dict(resp.headers), resp.read()
            except HTTPError as e:
                body = e.read()
                payload = _json_of(body)
                code = (payload or {}).get("code")
                # 额度用完是确定性失败，重试只是浪费调用方的退避时间
                if e.code == 429 and code == "quota_exhausted":
                    raise PhotosweatError(
                        (payload or {}).get("error") or "quota exhausted",
                        code=code, status=e.code, body=payload)
                if e.code in _RETRYABLE and i + 1 < attempts:
                    last = e
                    time.sleep(_retry_after(e.headers, delay))
                    delay = min(_MAX_BACKOFF, delay * 2)
                    continue
                raise PhotosweatError(
                    (payload or {}).get("error") or ("HTTP %s" % e.code),
                    code=code, status=e.code, body=payload)
            except (URLError, TimeoutError) as e:
                last = e
                if i + 1 < attempts:
                    time.sleep(_retry_after(None, delay))
                    delay = min(_MAX_BACKOFF, delay * 2)
                    continue
                raise PhotosweatError("network error: %s" % getattr(e, "reason", e))
        raise PhotosweatError("request failed: %s" % last)

    # ---------- 单张 ----------

    def remove_background(self, image: Union[str, bytes, bytearray],
                          params: Optional[dict] = None, wait: int = 20,
                          idempotency_key: Optional[str] = None,
                          poll_timeout: float = 180.0) -> Job:
        """传一张图，拿回 `Job`（通常已是 done，带 `result_url`）。

        `params` 例：`{"background": "white"}`、`{"background": "color", "color": "#f2f2f2"}`。
        `wait` 是同步等待上限（秒，服务端最多 25）；超时回 202，这里继续轮询。
        """
        data = _read(image)
        ctype = _sniff(data)
        query = {}
        if params:
            query["params"] = json.dumps(params, separators=(",", ":"))
        if wait:
            query["wait"] = str(int(wait))
        url = "%s/api/remove-background%s" % (
            self.base_url, ("?" + urlencode(query)) if query else "")
        headers = {"Content-Type": ctype,
                   "Idempotency-Key": idempotency_key or uuid.uuid4().hex}
        status, _hdrs, body = self._request("POST", url, data, headers)
        job = Job(json.loads(body.decode("utf-8")))
        if job.status == "done":
            return job
        if status == 202 and job.id:
            return self.wait(job.id, timeout=poll_timeout)
        return job

    # ---------- 任务 ----------

    def get_job(self, job_id: str) -> Job:
        _status, _hdrs, body = self._request(
            "GET", "%s/api/jobs/%s" % (self.base_url, quote(job_id)))
        return Job(json.loads(body.decode("utf-8")))

    def wait(self, job_id: str, timeout: float = 180.0, interval: float = 1.0) -> Job:
        """轮询到终态。done 返回 Job；failed/error/expired 抛 PhotosweatError。"""
        deadline = time.time() + timeout
        while True:
            job = self.get_job(job_id)
            if job.status == "done":
                return job
            if job.status in _TERMINAL:
                raise PhotosweatError(
                    "job %s ended %s: %s" % (job_id, job.status, job.error or ""),
                    code="job_failed", status=None, body=job.raw)
            if time.time() >= deadline:
                raise PhotosweatError(
                    "job %s still %s after %ss" % (job_id, job.status, timeout),
                    code="timeout", body=job.raw)
            time.sleep(interval)

    def result(self, job: Union[Job, str]) -> bytes:
        """下载结果图片字节。传 Job 或 job_id 都行。"""
        if not isinstance(job, Job):
            job = self.get_job(job)
        if not job.result_url:
            raise PhotosweatError("job %s has no result_url (status=%s)" % (job.id, job.status),
                                  code="no_result", body=job.raw)
        # 签名地址自带凭据，不能再带 Authorization（会把签名比坏）
        _status, _hdrs, body = self._request("GET", job.result_url, auth=False, retries=2)
        return body

    # ---------- 批量 ----------

    def batch(self, images: List[Union[str, bytes, bytearray]],
              params: Optional[dict] = None,
              callback_url: Optional[str] = None,
              callback_secret: Optional[str] = None,
              idempotency_key: Optional[str] = None) -> Dict[str, Any]:
        """1–10 张一批，返回 202 的 JSON（`batch_id` / `jobs[]` / `callback`）。

        计费整批原子：有一张扣不动就整批不建单、已扣的退回。
        `callback_url` 只收 https；配 `callback_secret` 时每次投递带 HMAC 签名。
        """
        images = list(images)
        if not 1 <= len(images) <= 10:
            raise ValueError("batch 一次 1–10 张，收到 %d" % len(images))
        boundary = "----photosweat" + uuid.uuid4().hex
        chunks: List[bytes] = []
        for i, img in enumerate(images):
            data = _read(img)
            ctype = _sniff(data)
            name = img if isinstance(img, str) else "image-%d" % i
            head = ('--%s\r\nContent-Disposition: form-data; name="image"; filename="%s"\r\n'
                    'Content-Type: %s\r\n\r\n' % (boundary, name.replace('"', ''), ctype))
            chunks.append(head.encode("utf-8") + data + b"\r\n")

        def field(name: str, value: str) -> None:
            chunks.append(('--%s\r\nContent-Disposition: form-data; name="%s"\r\n\r\n%s\r\n'
                           % (boundary, name, value)).encode("utf-8"))

        if params:
            field("params", json.dumps(params, separators=(",", ":")))
        if callback_url:
            field("callback_url", callback_url)
        if callback_secret:
            field("callback_secret", callback_secret)
        chunks.append(("--%s--\r\n" % boundary).encode("utf-8"))

        headers = {"Content-Type": "multipart/form-data; boundary=" + boundary,
                   "Idempotency-Key": idempotency_key or uuid.uuid4().hex}
        _status, _hdrs, body = self._request(
            "POST", self.base_url + "/api/batch", b"".join(chunks), headers)
        return json.loads(body.decode("utf-8"))

    # ---------- 水位 ----------

    def me(self) -> Dict[str, Any]:
        """今天的用量、预付张数余额（`credits`）与每分钟上限。"""
        _status, _hdrs, body = self._request("GET", self.base_url + "/v1/me")
        return json.loads(body.decode("utf-8"))
