from __future__ import annotations

import logging
import threading
import time
from typing import Any, List, Dict, Optional, Mapping, Set, Tuple, Callable
from scrapers.base_scraper import BaseScraper, ScrapeRunResult
from scrapers.records import calculate_discount, parse_package, parse_price
from scrapers.settings_schema import ScraperSetting
from scrapers.common import PRODUCT_FIELDNAMES, ProxyPool, ResponseCache, ThreadLocalSessionFactory
from scrapers.exceptions import StructuralError, ScraperAbortError
from scrapers.options import RuntimeOptions

logger = logging.getLogger(__name__)

# Top-level category IDs discovered from live site (2026-05).
# Each search query is capped at 1 000 accessible products by the API.
# Using multiple category buckets maximises unique product coverage.
CATEGORY_IDS = ["020000", "030000", "040000", "050000", "060000", "070000"]
SEARCH_URL = "https://product-search.services.dmtech.com/hu/search/static"
BASE_URL = "https://www.dm.hu"


def _parse_packaging(name: str) -> tuple[str, str]:
    return parse_package(name)


def _parse_price(tile: dict) -> tuple[str, str, str]:
    tracking = tile.get("trackingData", {})
    price_block = tile.get("price", {}).get("price", {})
    current = price_block.get("current", {})
    previous = price_block.get("previous", {})

    price, _ = parse_price(current.get("value", tracking.get("price")))
    old_price, _ = parse_price(previous.get("value", ""))
    return price, old_price, calculate_discount(price, old_price)


class Scraper(BaseScraper):
    execution_mode = "api"
    settings_schema = BaseScraper.settings_schema + (
        ScraperSetting(
            name="page_size",
            type="int",
            default=100,
            label="Page Size",
            description="Number of products per API page request. Higher values reduce round-trips but may trigger rate limits.",
            min=1,
            max=500,
        ),
        ScraperSetting(
            name="user_agent",
            type="str",
            default="",
            label="User Agent",
            description="Override the HTTP User-Agent header. Leave blank to use the scraper default.",
        ),
    )
    store_definitions = (
        {
            "retailer_code": "dm-hu",
            "name": "dm Hungary",
            "country_code": "HU",
            "base_url": "https://www.dm.hu",
            "scraper_module": "scrapers.platform.dm_scraper",
            "scraper_mapping": {"execution_mode": "api", "output_schema": "product"},
        },
    )

    def __init__(
        self,
        workers: int = 4,
        proxy_list: str | None = None,
        retries: int = 3,
        timeout: int = 20,
        max_proxy_failures: int = 3,
        page_size: int = 100,
        request_delay: float = 0.5,
    ):
        super().__init__()
        self.workers = workers
        self.retries = retries
        self.timeout = timeout
        self.page_size = page_size
        self.request_delay = request_delay
        self.proxy_validation_url = "https://www.dm.hu/"
        self.headers = {
            "Accept": "application/json",
            "Referer": "https://www.dm.hu/",
            "Origin": "https://www.dm.hu",
        }
        if hasattr(self, "configure_http_transport"):
            self.configure_http_transport(
                headers=self.headers,
                proxy_list=proxy_list,
                max_proxy_failures=max_proxy_failures,
            )
        else:
            self.cache = ResponseCache(ttl=43200)
            self.proxy_pool = ProxyPool(proxy_list, max_failures=max_proxy_failures)
            self.http_proxies_enabled = True
            self.sessions = ThreadLocalSessionFactory(self.headers)
            self._request_rate_lock = threading.Lock()
            self._last_request_at = 0.0
        self.fieldnames = PRODUCT_FIELDNAMES

    def _fetch_page(self, category_id: str, page: int) -> dict | None:
        params = {
            "allCategories.id": category_id,
            "pageSize": self.page_size,
            "currentPage": page,
            "searchType": "editorial-search",
            "sort": "editorial_relevance",
            "type": "search-static",
        }
        self.throttle_requests(self.request_delay)

        data = self.fetch_json_via_backend(
            SEARCH_URL,
            params=params,
            purpose=f"dm {category_id} p{page}",
            retries=self.retries,
            timeout=self.timeout,
            headers=self.headers,
            retry_sleep=lambda attempt: time.sleep(2 ** attempt if attempt == 1 else 1),
        )
        if data is None:
            logger.debug("DM request failed: category=%s page=%d", category_id, page)
            return None

        try:
            if "products" not in data and "totalPages" not in data:
                raise StructuralError(f"DM API response missing core fields: {list(data.keys())}")
            return data
        except (ValueError, KeyError) as exc:
            if isinstance(exc, StructuralError):
                raise
            logger.debug("DM response parse issue: category=%s page=%d err=%s", category_id, page, exc)
            return None

    def parse_product(self, raw: dict) -> dict | None:
        try:
            from scrapers.records import product_record, parse_package, parse_price, calculate_discount

            dan = str(raw.get("dan", ""))
            if not dan:
                return None

            gtin_int = raw.get("gtin")
            ean = f"{gtin_int:013d}" if gtin_int else ""

            brand = raw.get("brandName", "").strip()
            title = raw.get("title", "").strip()
            name = f"{brand} {title}".strip() if brand else title

            tile = raw.get("tileData", {})
            tracking = tile.get("trackingData", {})

            self_path = tile.get("self", "")
            source_url = f"{BASE_URL}{self_path}" if self_path else ""

            images = tile.get("images", [])
            image_url = images[0].get("tileSrc", "") if images else ""

            categories = tracking.get("categories", [])
            category = " > ".join(categories) if categories else ""

            # Use shared price parser
            current_num = tracking.get("price")
            price_val = str(int(current_num)) if current_num is not None else ""
            
            price_block = tile.get("price", {}).get("price", {})
            previous = price_block.get("previous", {})
            old_price_val = ""
            if previous:
                old_price_val, _ = parse_price(previous.get("value", ""))

            discount_percent = calculate_discount(price_val, old_price_val)

            pkg_value, pkg_unit = parse_package(title)

            return product_record(
                source_product_id=dan,
                name=name,
                price=price_val,
                old_price=old_price_val,
                currency="HUF",
                discount_percent=discount_percent,
                image_url=image_url,
                category=category,
                packaging_value=pkg_value,
                packaging_unit=pkg_unit,
                source_url=source_url,
                ean_code=ean,
                availability="1",
                raw=raw,
            )
        except Exception as exc:
            logger.debug("DM product parse skipped: dan=%s err=%s", raw.get("dan"), exc)
            return None

    def scrape_category(self, category_id: str) -> list[dict]:
        products: dict[str, dict] = {}

        first = self._fetch_page(category_id, 0)
        if not first:
            logger.error("Failed to fetch first page of category %s", category_id)
            return []

        total_pages = min(first.get("totalPages", 1), 10)  # API caps at page 999; we cap at 10
        logger.info("Category %s: %s products, %d pages", category_id, first.get("count", "?"), total_pages)

        for raw in first.get("products", []):
            parsed = self.parse_product(raw)
            if parsed and parsed["source_product_id"] not in products:
                products[parsed["source_product_id"]] = parsed

        for page in range(1, total_pages):
            data = self._fetch_page(category_id, page)
            if not data:
                break
            for raw in data.get("products", []):
                parsed = self.parse_product(raw)
                if parsed and parsed["source_product_id"] not in products:
                    products[parsed["source_product_id"]] = parsed

            if (page + 1) % 5 == 0:
                logger.debug("  %s: page %d/%d, %d unique so far", category_id, page + 1, total_pages, len(products))

        return list(products.values())

    def run(self, target: Any = None, context: dict[str, Any] | None = None) -> ScrapeRunResult:
        opts = RuntimeOptions.from_run_args(target, context)
        records = self.collect_products(
            category_ids=opts.extra.get("category_ids"),
            limit_categories=opts.limit_categories,
            category_filter=opts.category_filter,
        )
        return ScrapeRunResult(
            records=records,
            raw_records=records,
            accepted_records=records,
            rejected_records=[],
            telemetry=self.telemetry,
        )

    def collect_products(
        self,
        category_ids: list[str] | None = None,
        limit_categories: int | None = None,
        category_filter: str | None = None,
    ) -> list[dict[str, Any]]:
        cats = category_ids or CATEGORY_IDS
        if category_filter:
            cats = [c for c in cats if category_filter in c]
        if limit_categories:
            cats = cats[:limit_categories]
            
        if not cats:
            raise ScraperAbortError(
                "dm: no categories to scrape after filtering",
                error_category="validation",
            )
            
        self.log_startup_status(logger, f"dm Hungary scraper started — {len(cats)} categories")

        category_results = self.parallel_map(
            self.scrape_category,
            cats,
            label="dm categories",
            flatten=False,
            unit="categories"
        )

        all_by_dan: dict[str, dict] = {}
        for products in category_results:
            for p in products:
                pid = p["source_product_id"]
                if pid not in all_by_dan:
                    all_by_dan[pid] = p

        unique = list(all_by_dan.values())
        self.log_summary(logger, "dm complete")
        return unique


DmScraper = Scraper