from link_agregator.utils.logger import logger

# --- Słowa-klucze do dynamicznej akceptacji cookies ---
COOKIE_KEYWORDS = [
    "zgadzam się", "akceptuję", "akceptuj", "zaakceptuj", "accept", "accept all",
    "akceptuję wszystkie", "przejdź dalej", "consent", "agree", "got it",
    "potwierdź", "ok, rozumiem", "zgoda", "przyjmuję", "zatwierdzam",
    "zezwalam", "wyrażam zgodę", "przyjmuję wszystkie", "przejdź do serwisu"
]

ELEMENT_TYPES = ["button", "a", "span", "li", "div"]

async def dynamic_accept_cookies(page, timeout=5000):
    """
    Quick dynamic cookie detection with SHORT timeout.
    Tries to find common cookie accept buttons quickly.
    If not found within 5s, fallback to config will handle it.
    """
    try:
        if page.is_closed():
            logger.warning("⚠️ Strona została zamknięta przed próbą akceptacji cookies.")
            return False

        # Quick check for common cookie buttons only (not ALL elements!)
        quick_selectors = [
            "button:has-text('Akceptuję')",
            "button:has-text('Accept')",
            "button:has-text('Przejdź')",
            "button:has-text('Zgadzam')",
            "[class*='accept']:visible",
            "[class*='consent']:visible",
        ]
        
        for selector in quick_selectors:
            try:
                element = page.locator(selector).first
                if await element.is_visible(timeout=1000):
                    await element.click(timeout=3000)
                    logger.info(f"✅ Zaakceptowano cookies dynamicznie: {selector}")
                    await page.wait_for_timeout(1000)  # Short wait
                    return True
            except Exception:
                continue

        logger.debug("🛑 Nie znaleziono przycisku cookies dynamicznie - użyję configu.")
        return False

    except Exception as outer_error:
        logger.error(f"❌ Krytyczny błąd w dynamic_accept_cookies: {outer_error}")
        return False


async def fallback_accept_cookies(page, cookies_config):
    """
    Próbuje kliknąć cookies po selektorze z ai_config, jeśli dynamicznie się nie udało.
    """
    selector = cookies_config.get("accept_selector")
    timeout = cookies_config.get("timeout", 45000)
    accept_text = cookies_config.get("accept_text")

    try:
        if page.is_closed():
            logger.warning("⚠️ Strona zamknięta przed próbą fallback cookies.")
            return False

        if selector:
            logger.info(f"🔧 Próbuję kliknąć cookie przez selektor: {selector}")
            try:
                await page.wait_for_selector(selector, timeout=timeout)
                element = page.locator(selector).first
                if await element.is_visible():
                    await element.click(timeout=5000)
                    logger.info(f"✅ Zaakceptowano cookies przez selektor: {selector}")
                    await page.wait_for_timeout(1000)  # FIX: Was using full timeout! Now 1s
                    return True
                else:
                    logger.warning(f"⚠️ Element {selector} nie jest widoczny")
            except Exception as e:
                logger.warning(f"⚠️ Błąd przy kliku przez selektor {selector}: {e}")

        elif accept_text:
            logger.info(f"🔧 Próbuję kliknąć cookie przez tekst: {accept_text}")
            button = page.locator(f"text={accept_text}")
            if await button.count() > 0:
                first_button = button.first
                if await first_button.is_visible():
                    await first_button.click(timeout=5000)
                    logger.info(f"✅ Zaakceptowano cookies przez tekst: {accept_text}")
                    await page.wait_for_timeout(1000)  # Short wait
                    return True

    except Exception as e:
        logger.warning(f"⚠️ Nie udało się kliknąć cookies przez fallback: {e}")

    return False


import asyncio
import os
from datetime import datetime

async def handle_cookies(page, ai_config, debug_dir="cookies_debug"):
    """
    OPTIMIZED: Tries config FIRST (fast), then dynamic detection if config fails.
    """
    cookies_config = ai_config.get("cookies", {})
    source_name = ai_config.get("source_name", "unknown")

    # TRY CONFIG FIRST (fast - uses known selector)
    if cookies_config:
        clicked = await fallback_accept_cookies(page, cookies_config)
        if clicked:
            logger.info("✅ Cookies accepted via config selector")
            return

    # Fallback to dynamic detection (1 attempt only, quick)
    clicked = await dynamic_accept_cookies(page)
    if clicked:
        logger.info("✅ Cookies accepted via dynamic detection")
        return

    # 🔴 Jeśli nadal nie kliknięto cookies – zapisujemy stronę
    try:
        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        os.makedirs(debug_dir, exist_ok=True)
        screenshot_path = os.path.join(debug_dir, f"{source_name}_{timestamp}.png")
        html_path = os.path.join(debug_dir, f"{source_name}_{timestamp}.html")

        await page.screenshot(path=screenshot_path)
        content = await page.content()
        with open(html_path, "w", encoding="utf-8") as f:
            f.write(content)

        logger.error(f"❌ Nie udało się zaakceptować cookies – zapisano:\n🖼️ Screenshot: {screenshot_path}\n📄 HTML: {html_path}")
    except Exception as e:
        logger.error(f"‼️ Błąd przy zapisie debug cookies: {e}")