"""On-demand disk cache of exact-code product photos from 21vek."""
from __future__ import annotations

import hashlib
import json
import os
import re
import threading
import tempfile
import time
from contextlib import nullcontext
from pathlib import Path
from urllib.parse import urlparse

import httpx

_locks = [threading.Lock() for _ in range(32)]
MISSING_TTL = 86400
MAX_BYTES = 6 * 1024 * 1024


def find_image(payload: dict, code: str) -> str | None:
    for group in payload.get("data", []):
        if group.get("group_type") != "products":
            continue
        for item in group.get("items", []):
            if re.sub(r"\D", "", str(item.get("product_id", ""))) != code:
                continue
            url = item.get("image", "")
            parsed = urlparse(url)
            if (parsed.scheme == "https" and parsed.hostname in
                    {"cdn21vek.by", "www.21vek.by", "21vek.by"}
                    and not parsed.username and parsed.port in (None, 443)):
                return url
    return None


def cached_photo(cache_dir: Path, code: str, *, client: httpx.Client | None = None) -> tuple[Path, str] | None:
    if not re.fullmatch(r"\d{1,12}", code):
        raise ValueError("Неверный код товара")
    cache_dir.mkdir(parents=True, exist_ok=True)
    with _locks[int(code) % len(_locks)]:
        metadata = cache_dir / (code + ".json")
        content = cache_dir / (code + ".image")
        if metadata.exists():
            try:
                record = json.loads(metadata.read_text(encoding="utf-8"))
                if record.get("mime") and content.exists():
                    return content, record["mime"]
                if time.time() - record.get("checked_at", 0) < record.get("retry_after", MISSING_TTL):
                    return None
            except (ValueError, OSError):
                pass
        try:
            with (nullcontext(client) if client else httpx.Client(timeout=12, follow_redirects=False)) as client:
                response = client.get(
                    "https://gate.21vek.by/search-composer/api/v1/search/suggest",
                    params={"query": code, "mode": "desktop"})
                response.raise_for_status()
                url = find_image(response.json(), code)
                if not url:
                    _write_record(metadata, {"checked_at": time.time(), "status": "missing"})
                    return None
                with client.stream("GET", url) as photo:
                    photo.raise_for_status()
                    mime = photo.headers.get("content-type", "").split(";")[0]
                    if mime not in {"image/jpeg", "image/png", "image/webp", "image/avif", "image/gif"}:
                        _write_record(metadata, {"checked_at": time.time(), "status": "error", "retry_after": 300})
                        return None
                    data = bytearray()
                    for chunk in photo.iter_bytes():
                        data.extend(chunk)
                        if len(data) > MAX_BYTES:
                            _write_record(metadata, {"checked_at": time.time(), "status": "error", "retry_after": 300})
                            return None
                if not data:
                    _write_record(metadata, {"checked_at": time.time(), "status": "error", "retry_after": 300})
                    return None
                with tempfile.NamedTemporaryFile(dir=cache_dir, suffix=".tmp", delete=False) as output:
                    output.write(data)
                    temp = output.name
                os.replace(temp, content)
                _write_record(metadata, {"mime": mime, "source": url,
                                        "status": "found",
                                        "checked_at": time.time(),
                                        "sha256": hashlib.sha256(data).hexdigest()})
                return content, mime
        except httpx.HTTPStatusError as exc:
            missing = exc.response.status_code == 404 and exc.request.url.host != "gate.21vek.by"
            _write_record(metadata, {"checked_at": time.time(),
                                     "status": "missing" if missing else "error",
                                     "http_status": exc.response.status_code,
                                     "retry_after": MISSING_TTL if missing else 60})
            return None
        except (httpx.HTTPError, ValueError):
            # Temporary failures are retried sooner than a confirmed missing code.
            _write_record(metadata, {"checked_at": time.time(), "status": "error", "retry_after": 60})
            return None


def _write_record(path: Path, record: dict) -> None:
    with tempfile.NamedTemporaryFile(dir=path.parent, suffix=".tmp", mode="w", encoding="utf-8", delete=False) as output:
        output.write(json.dumps(record))
        temp = output.name
    os.replace(temp, path)
