import asyncio
import logging
import random
import re
from playwright.async_api import async_playwright
from sqlalchemy import text
from app.database import AsyncSessionLocal

# --- NAPLÓZÁS KONFIGURÁCIÓ ---
# Megtartjuk a részletes naplózást minden eseményhez
logging.basicConfig(
    level=logging.INFO, 
    format='%(asctime)s [BIKE-R1-AUTOEVO] %(message)s'
)
logger = logging.getLogger("R1")

async def analyze_and_extract_links(page, current_url):
    """
    Gondolatmenet: Intelligens link-osztályozás az AutoEvolution struktúrája alapján.
    Minden funkciót megőrzünk: Language Shield, zajszűrés és a horgony-fix.
    """
    found_links = []
    
    # Minden link begyűjtése az elemzéshez a megadott szelektorral
    hrefs = await page.eval_on_selector_all(
        "a[href*='/moto/']", 
        "nodes => nodes.map(n => ({ 'name': n.innerText.trim(), 'url': n.href }))"
    )

    junk_keywords = [
        'privacy', 'cookie', 'settings', 'contact', 'terms', 'advertising', 
        'about us', 'copyright', 'login', 'registration'
    ]

    for link in hrefs:
        # --- HORGONY ÉS PARAMÉTER TISZTÍTÁS ---
        # Itt volt a hiba: levágjuk a # részt, de a linket megtartjuk az ellenőrzéshez!
        raw_url = link['url'].split('#')[0].split('?')[0].rstrip('/')
        name = link['name']
        
        # --- 1. LANGUAGE SHIELD & ZAJ SZŰRÉS ---
        if not name or len(name) < 2: 
            continue
            
        # Csak latin karakterek (No Greek/Cyrillic/Polish/etc)
        if re.search(r'[^\x00-\x7F]+', name): 
            continue
            
        # Kizárjuk a navigációs szemetet
        if any(junk in name.lower() for junk in junk_keywords): 
            continue

        # --- 2. AUTOEVOLUTION MÉLYSÉGI LOGIKA ---
        if "autoevolution.com/moto/" in raw_url:
            # Önhivatkozás és főoldal (visszafelé navigáció) kiszűrése
            if raw_url == current_url.rstrip('/') or raw_url.endswith('/moto'):
                continue

            # Elágazás a szintek között az URL szerkezete alapján
            path_segments = raw_url.strip('/').split('/')
            
            # Ha .html-re végződik, az a technikai specifikáció (ENGINE szint)
            if raw_url.endswith(".html"):
                found_links.append({'name': name, 'url': raw_url, 'level': 'engine'})
            
            # Ha legalább 6 szegmens van és nincs .html, az egy al-modell vagy generáció (MODEL szint)
            elif len(path_segments) >= 6:
                found_links.append({'name': name, 'url': raw_url, 'level': 'model'})
                
    return found_links

async def get_next_task(db):
    """
    Prioritásos feladatfelvétel: A márka (brand) szinteket részesítjük előnyben.
    SKIP LOCKED biztosítja a párhuzamos futtathatóságot.
    """
    query = text("""
        UPDATE vehicle.auto_data_crawler_queue SET status = 'processing'
        WHERE id = (
            SELECT id FROM vehicle.auto_data_crawler_queue 
            WHERE status = 'pending' 
              AND category = 'bike'
              AND url LIKE '%autoevolution.com%'
              AND level IN ('brand', 'model') 
            ORDER BY 
                CASE WHEN level = 'brand' THEN 0 ELSE 1 END ASC,
                id ASC 
            LIMIT 1 FOR UPDATE SKIP LOCKED
        ) RETURNING id, url, name, level
    """)
    res = await db.execute(query)
    return res.fetchone()

async def main():
    """
    Fő vezérlő hurok teljes hibakezeléssel és tranzakció-biztonsággal.
    """
    async with async_playwright() as p:
        browser = await p.chromium.launch(headless=True)
        context = await browser.new_context(
            user_agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36"
        )
        
        logger.info("🤖 R1 AutoEvolution Specialist elindult...")
        
        while True:
            target = None
            try:
                async with AsyncSessionLocal() as db:
                    target = await get_next_task(db)
                    await db.commit()
            except Exception as e:
                logger.error(f"❌ Adatbázis hiba a feladatfelvételnél: {e}")
                await asyncio.sleep(5)
                continue

            if not target:
                logger.info("🏁 Nincs több AutoEvolution feladat. Alvás 60mp...")
                await asyncio.sleep(60)
                continue
            
            t_id, t_url, t_name, t_level = target
            page = await context.new_page()
            
            try:
                logger.info(f"🚀 Felderítés ({t_level}): {t_name} -> {t_url}")
                # A domcontentloaded gyorsabb, de várunk utána a JS-re
                await page.goto(t_url, wait_until="domcontentloaded", timeout=60000)
                await asyncio.sleep(random.uniform(2, 3)) 
                
                links = await analyze_and_extract_links(page, t_url)
                
                async with AsyncSessionLocal() as db:
                    try:
                        new_links_count = 0
                        for link in links:
                            # Minden talált variációt elmentünk a várólistába
                            await db.execute(text("""
                                INSERT INTO vehicle.auto_data_crawler_queue (url, level, parent_id, name, status, category)
                                VALUES (:url, :level, :p_id, :name, 'pending', 'bike')
                                ON CONFLICT (url) DO NOTHING
                            """), {"url": link['url'], "level": link['level'], "p_id": t_id, "name": link['name']})
                            new_links_count += 1
                        
                        # Feladat lezárása
                        await db.execute(text("UPDATE vehicle.auto_data_crawler_queue SET status = 'completed', updated_at = NOW() WHERE id = :id"), {"id": t_id})
                        await db.commit()
                        logger.info(f"✅ {t_name} kész. Talált AutoEvolution linkek: {new_links_count}")
                    except Exception as inner_db_error:
                        await db.rollback()
                        logger.error(f"❌ Belső mentési hiba: {inner_db_error}")
                        raise inner_db_error

            except Exception as e:
                logger.error(f"❌ Kritikus hiba a navigáció során: {t_name} -> {e}")
                async with AsyncSessionLocal() as db:
                    await db.execute(text("UPDATE vehicle.auto_data_crawler_queue SET status = 'error', error_msg = :msg, updated_at = NOW() WHERE id = :id"), 
                                   {"msg": str(e), "id": t_id})
                    await db.commit()
            finally:
                await page.close()
                # Kíméljük a szervert a kitiltás ellen
                await asyncio.sleep(random.uniform(3, 5))

        await browser.close()

if __name__ == "__main__":
    try:
        asyncio.run(main())
    except KeyboardInterrupt:
        logger.info("🛑 Leállítás.")