import logging
import os
import threading
import time

from typing import Any, List, Dict, Optional, Mapping, Set
from scrapers.base_scraper import BaseScraper, ScrapeRunResult
from scrapers.common import PRODUCT_FIELDNAMES, ProxyPool, ResponseCache, ThreadLocalSessionFactory
from scrapers.exceptions import ScraperAbortError
from scrapers.options import RuntimeOptions

logger = logging.getLogger(__name__)


# Optional Playwright import for automatic token extraction
try:
    from playwright.sync_api import sync_playwright
except ImportError:
    sync_playwright: Any = None


class Scraper(BaseScraper):
    execution_mode = "api"
    default_request_backend = "scrapling"
    scrapling_stealth = False
    store_definitions = (
        {
            "retailer_code": "aldi-hu",
            "name": "Aldi Hungary",
            "country_code": "HU",
            "base_url": "https://www.aldi.hu/",
            "scraper_module": "scrapers.platform.aldi_scraper",
            "scraper_mapping": {
                "execution_mode": "api",
                "output_schema": "product",
            },
        },
    )

    def __init__(
        self,
        jwt_token=None,
        headless=True,
        workers=10,
        proxy_list=None,
        request_timeout=20,
        retries=2,
        max_proxy_failures=3,
    ):
        super().__init__()
        self.base_url = "https://shopservice.roksh.com"
        self.jwt_token = jwt_token or os.getenv("ALDI_JWT_TOKEN")
        self.headless = headless
        self.workers = workers
        self.reservoir_size = workers + 5
        self.proxy_validation_url = "https://shop.aldi.hu/"

        self.max_proxy_failures = max_proxy_failures
        self.request_timeout = request_timeout
        self.retries = retries

        self.headers = {
            "Accept": "application/json, text/plain, */*",
            "Referer": "https://shop.aldi.hu/",
            "Origin": "https://shop.aldi.hu",
            "Content-Type": "application/json",
        }
        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, scraper_name=self.scraper_name)
            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 run(self, target: str | Dict[str, Any] | None = None, context: Dict[str, Any] | None = None) -> ScrapeRunResult:
        opts = RuntimeOptions.from_run_args(target, context)
        records = self.collect_products(
            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 request_json(self, url, params=None, purpose="request", use_cache=True):
        return self.fetch_json_via_backend(
            url,
            params=params,
            purpose=purpose,
            use_cache=use_cache,
            retries=self.retries,
            timeout=self.request_timeout,
            headers=self.headers,
            scrapling_stealth=self.scrapling_stealth,
            retry_sleep=lambda attempt: time.sleep(min(0.5 * attempt, 2.0)),
        )

    def get_token_with_playwright(self):
        """Uses Playwright to extract the jwt-token from localStorage automatically."""
        if sync_playwright is None:
            logger.warning("Playwright is not installed.")
            return None

        logger.debug("Launching browser to extract JWT token...")
        
        from catalog.live_snapshot import safe_db_access
        try:
            with safe_db_access():
                with sync_playwright() as p:
                    browser = self.launch_browser(p)
                    context = browser.new_context(user_agent=self.headers["User-Agent"])
                    page = context.new_page()
                    start = time.perf_counter()
                    page.goto("https://shop.aldi.hu/kezdooldal", wait_until="domcontentloaded")
                    self.record_request((time.perf_counter() - start) * 1000)

                    token = None
                    for _ in range(15):
                        token = page.evaluate("localStorage.getItem('jwt-token')")
                        if token:
                            break
                        time.sleep(0.5)

                    browser.close()
                    if token:
                        logger.info("Successfully extracted JWT token from localStorage")
                        return token
                    return None
        except Exception as e:
            logger.error("Error during Playwright token extraction: %s", e)
            return None

    def setup_headers(self):
        if self.jwt_token:
            self.headers["Authorization"] = f"Bearer {self.jwt_token}"
        else:
            self.jwt_token = self.get_token_with_playwright()
            if self.jwt_token:
                self.headers["Authorization"] = f"Bearer {self.jwt_token}"
        
        # Update the session factory headers and the current thread's session
        if hasattr(self, "sessions") and self.sessions:
            self.sessions.headers.update(self.headers)
            # Also update the current thread's session immediately
            current_session = self.sessions.get()
            current_session.headers.update(self.headers)
        
        if hasattr(self, "configure_http_transport"):
            self.configure_http_transport(headers=self.headers)

    def get_categories(self):
        self.setup_headers()
        url = f"{self.base_url}/category/GetFullCategoryList?providerCode=ALDI&isOwnWebshop=true"
        return self.request_json(url, purpose="category list") or []

    def flatten_categories(self, category_list, flat_list=None):
        if flat_list is None:
            flat_list = []
        for cat in category_list:
            if cat.get("ProgID"):
                flat_list.append(
                    {
                        "id": cat.get("CategoryID"),
                        "name": cat.get("CategoryName"),
                        "prog_id": cat.get("ProgID"),
                    }
                )
            if cat.get("ChildList"):
                self.flatten_categories(cat["ChildList"], flat_list)
        return flat_list

    def fetch_category_worker(self, cat):
        category_prog_id = cat["prog_id"]
        category_name = cat["name"]

        url = f"{self.base_url}/productlist/additionalCategoryProductList"
        params = {
            "listResultProductNum": 5000,
            "providerCode": "ALDI",
            "isOwnWebshop": "true",
            "progIdList": category_prog_id,
        }

        data = self.request_json(
            url, params=params, purpose=f"category {category_name}"
        )
        if not data:
            logger.warning("Skipping category after failed retries: %s", category_name)
            return []

        parsed_products = []
        result_products = 0
        block_products = 0

        for result in data.get("ProductListResults", []):
            products = result.get("ProductList", [])
            result_products += len(products)
            for p in products:
                parsed = self.parse_single_product(p, category_name)
                if parsed:
                    parsed_products.append(parsed)

        for block in data.get("ProductBlockList", []):
            products = block.get("ProductList", [])
            block_products += len(products)
            for p in products:
                parsed = self.parse_single_product(p, category_name)
                if parsed:
                    parsed_products.append(parsed)

        logger.debug(
            "Category %s returned %d result products and %d block products",
            category_name,
            result_products,
            block_products,
        )

        return parsed_products

    def parse_single_product(self, p, category_name):
        try:
            from scrapers.records import product_record, parse_package, calculate_discount

            pid = str(p.get("productID", ""))
            name = p.get("productName", "").strip()
            url = f"https://shop.aldi.hu/termekek/{p.get('categorySEOName')}/{p.get('sEOName')}"

            provider_data = p.get("productProvider", [{}])[0]
            img_url = provider_data.get("providerProductImageUrl", "")
            
            price_val = str(p.get("price") or "")
            old_price_val = str(p.get("originalPriceIfOffer") or "")
            
            discount_percent = calculate_discount(price_val, old_price_val)
            
            pkg_value, pkg_unit = parse_package(name)
            if not pkg_unit:
                _, pkg_unit = parse_package(f"1 {provider_data.get('unit', '')}")

            return product_record(
                source_product_id=pid,
                name=name,
                price=price_val,
                old_price=old_price_val,
                currency="HUF",
                discount_percent=discount_percent,
                discount_validity_end=p.get("offerValidTo", ""),
                image_url=img_url or p.get("mediaUrlL", ""),
                category=category_name,
                packaging_value=pkg_value,
                packaging_unit=pkg_unit,
                source_url=url,
                ean_code="",
                availability="1" if p.get("available") else "0",
                raw=p,
            )
        except Exception as exc:
            logger.warning("Error parsing Aldi product %s: %s", p.get("productID"), exc)
            return None

    def collect_products(self, limit_categories: int | None = None, category_filter: str | None = None) -> List[Dict[str, Any]]:
        self.log_startup_status(logger, "Starting Aldi crawl")

        categories = self.get_categories()
        if not categories:
            raise ScraperAbortError(
                "Aldi category API returned no categories — possible auth or site change",
                error_category="network",
            )

        flat_cats = self.flatten_categories(categories)
        seen = set()
        unique_cats = []
        for c in flat_cats:
            if c["prog_id"] not in seen:
                seen.add(c["prog_id"])
                unique_cats.append(c)

        if category_filter:
            unique_cats = [
                c for c in unique_cats if category_filter.lower() in c["name"].lower()
            ]

        if limit_categories:
            unique_cats = unique_cats[:limit_categories]

        all_products = self.parallel_map(
            self.fetch_category_worker, 
            unique_cats, 
            label="Aldi categories",
            unit="categories"
        )

        seen_pids = set()
        unique_products = []
        for product in all_products:
            pid = product.get("source_product_id")
            if pid not in seen_pids:
                seen_pids.add(pid)
                unique_products.append(product)

        self.log_summary(logger, f"Aldi complete, found {len(unique_products)} unique products")
        return unique_products


AldiScraper = Scraper