"""Read-only product lookup and an editable taxonomy vocabulary for Journey nodes."""
from __future__ import annotations

import json
import re
import socket
from html import unescape
from typing import Any, Callable
from urllib.error import HTTPError, URLError
from urllib.parse import urlencode, urlsplit
from urllib.request import HTTPRedirectHandler, Request, build_opener

from integrations import IntegrationError, WooCommerceConfig, WooCommerceIntegration


TAXONOMIES = {"category", "tag", "brand"}
PRODUCT_FILTERS = {"category", "tag", "brand", "taste", "weight", "price_min", "price_max", "q", "orderby", "order"}
TERM_ENDPOINTS = {"category": "products/categories", "tag": "products/tags", "brand": "products/brands"}


def normalize_term(value: Any) -> str:
    return re.sub(r"\s+", " ", str(value).strip().casefold().replace("ي", "ی").replace("ك", "ک"))


def safe_slug(value: Any) -> str:
    slug = str(value).strip()
    if not slug or len(slug) > 160 or any(char.isspace() or char in "/?#&\\" for char in slug):
        raise ValueError("slug باید کوتاه و بدون فاصله یا کاراکتر URL باشد.")
    return slug


def resolve_term(taxonomy: str, value: Any, terms: list[dict[str, Any]]) -> str:
    term_value = normalize_term(value)
    matches = {term["slug"] for term in terms if term["taxonomy"] == taxonomy and
               any(term_value == normalize_term(item) for item in
                   [term["slug"], term["name_fa"], *term["aliases"]])}
    if len(matches) == 1:
        return matches.pop()
    if len(matches) > 1:
        raise IntegrationError("ambiguous_term", f"عنوان {taxonomy} مبهم است؛ slug را انتخاب کنید.", status_code=400)
    raise IntegrationError("unknown_term", f"{taxonomy} «{str(value)[:50]}» در بانک اصطلاحات ثبت نشده است.", status_code=400)


def clean_product(item: dict[str, Any], store_host: str) -> dict[str, Any] | None:
    status = item.get("stock_status")
    if status is not None and status not in ("instock", "in_stock", True, 1, "1"):
        return None
    stock = item.get("stock")
    if stock in ("outofstock", "out_of_stock", "onbackorder", False, "0") or (isinstance(stock, (int, float)) and stock <= 0):
        return None
    for key in ("in_stock", "is_in_stock", "instock"):
        if key in item and item[key] in (False, 0, "0", "false", "no"):
            return None
    if item.get("status") in {"draft", "private", "trash"}:
        return None
    title = str(item.get("name") or item.get("title") or "").strip()[:180]
    url = str(item.get("permalink") or item.get("url") or item.get("link") or item.get("product_url") or "").strip()
    parsed = urlsplit(url)
    canonical_host = store_host.removeprefix("www.")
    if not title or parsed.scheme != "https" or parsed.hostname not in {canonical_host, "www." + canonical_host}:
        return None
    image = item.get("image_url") or item.get("image") or item.get("thumbnail") or item.get("image_src") or ""
    if isinstance(image, list):
        image = image[0] if image else ""
    if isinstance(image, dict):
        image = image.get("src") or image.get("url") or ""
    if not image and isinstance(item.get("images"), list) and item["images"]:
        image = item["images"][0].get("src", "") if isinstance(item["images"][0], dict) else ""
    image = str(image)
    if urlsplit(image).scheme != "https":
        image = ""
    price = item.get("price_text") or item.get("formatted_price") or item.get("price_html") or item.get("price") or ""
    if isinstance(price, dict):
        price = price.get("formatted") or price.get("value") or ""
    price = unescape(re.sub(r"<[^>]*>", "", str(price))).strip()[:80]
    return {"title": title, "url": url, "image": image, "price": price}


Transport = Callable[[Request, int], Any]


class StoreOnlyRedirect(HTTPRedirectHandler):
    def __init__(self, host: str):
        self.host = host.removeprefix("www.")

    def redirect_request(self, request, fp, code, msg, headers, newurl):
        target = urlsplit(newurl)
        if target.scheme != "https" or target.hostname not in {self.host, "www." + self.host}:
            raise HTTPError(newurl, code, "Catalog redirected outside store", headers, fp)
        return super().redirect_request(request, fp, code, msg, headers, newurl)


class ProductCatalog:
    def __init__(self, config: WooCommerceConfig | None = None, transport: Transport | None = None):
        self.config = config or WooCommerceConfig.from_env()
        if transport is None:
            opener = build_opener(StoreOnlyRedirect(urlsplit(self.config.base_url).hostname or ""))
            self.transport = lambda request, timeout: opener.open(request, timeout=timeout)
        else:
            self.transport = transport

    def search(self, filters: dict[str, Any], terms: list[dict[str, Any]]) -> dict[str, Any]:
        if urlsplit(self.config.base_url).scheme != "https" or not urlsplit(self.config.base_url).hostname:
            raise IntegrationError("invalid_configuration", "آدرس فروشگاه باید HTTPS باشد.", status_code=500)
        if not isinstance(filters, dict) or set(filters) - PRODUCT_FILTERS:
            raise IntegrationError("invalid_filters", "فیلتر محصولات معتبر نیست.", status_code=400)
        query: dict[str, str | int] = {"instock": 1, "per_page": 4}
        for key, value in filters.items():
            if value is None or value == "":
                continue
            if isinstance(value, (list, dict, bool)) or len(str(value)) > 160:
                raise IntegrationError("invalid_filters", "مقدار فیلتر معتبر نیست.", status_code=400)
            query[key] = resolve_term(key, value, terms) if key in TAXONOMIES else str(value)
        if query.get("orderby") not in (None, "popularity", "rating", "date", "price"):
            raise IntegrationError("invalid_filters", "ترتیب محصولات معتبر نیست.", status_code=400)
        if query.get("order") not in (None, "asc", "desc"):
            raise IntegrationError("invalid_filters", "جهت مرتب‌سازی معتبر نیست.", status_code=400)
        request = Request(
            self.config.base_url + "/wp-json/arcopet/v1/products/compact?" + urlencode(query),
            headers={"Accept": "application/json", "User-Agent": "ArcopetBot/3.1"},
            method="GET",
        )
        try:
            with self.transport(request, self.config.timeout) as response:
                raw = response.read(2_000_001)
        except (HTTPError, URLError, socket.timeout, TimeoutError, OSError) as exc:
            raise IntegrationError("catalog_unavailable", "کاتالوگ محصولات موقتاً در دسترس نیست.") from exc
        if len(raw) > 2_000_000:
            raise IntegrationError("invalid_response", "پاسخ کاتالوگ بیش از حد مجاز است.")
        try:
            payload = json.loads(raw.decode("utf-8"))
        except (UnicodeDecodeError, json.JSONDecodeError) as exc:
            raise IntegrationError("invalid_response", "پاسخ کاتالوگ قابل خواندن نیست.") from exc
        if isinstance(payload, dict):
            payload = payload.get("products", payload.get("items", payload.get("data", payload.get("results"))))
            if isinstance(payload, dict):
                payload = payload.get("products", payload.get("items", payload.get("results")))
        if not isinstance(payload, list):
            raise IntegrationError("invalid_response", "ساختار پاسخ کاتالوگ معتبر نیست.")
        host = urlsplit(self.config.base_url).hostname or ""
        products = [product for item in payload if isinstance(item, dict)
                    if (product := clean_product(item, host)) is not None][:4]
        return {"count": len(products), "products": products}


def fetch_terms_page(taxonomy: str, page: int, integration: WooCommerceIntegration | None = None) -> tuple[list[dict[str, str]], bool]:
    if taxonomy not in TERM_ENDPOINTS or page < 1 or page > 100:
        raise ValueError("نوع یا شماره صفحه معتبر نیست.")
    wc = integration or WooCommerceIntegration()
    payload, total_pages = wc._request(f"{TERM_ENDPOINTS[taxonomy]}?per_page=100&page={page}&_fields=name,slug", with_headers=True)
    if not isinstance(payload, list):
        raise IntegrationError("invalid_response", "لیست اصطلاحات WooCommerce معتبر نیست.")
    terms: list[dict[str, str]] = []
    for item in payload:
        if isinstance(item, dict) and str(item.get("name", "")).strip():
            try:
                terms.append({"slug": safe_slug(item.get("slug", "")), "name_fa": str(item["name"]).strip()[:120]})
            except ValueError:
                continue
    has_more = page < int(total_pages) if total_pages and str(total_pages).isdigit() else len(payload) == 100
    return terms, has_more
