# /opt/docker/dev/service_finder/backend/app/workers/vehicle/vehicle_robot_1_4_bike_hunter.py
import asyncio
import httpx
import logging
import random
from sqlalchemy import text
from app.database import AsyncSessionLocal

# Naplózás finomhangolása a duplázódás elkerülésére
logging.basicConfig(level=logging.INFO, format='%(asctime)s [%(name)s] %(message)s')
logger = logging.getLogger("Robot-1-4-Bike")
# SQLAlchemy zaj csökkentése
logging.getLogger("sqlalchemy.engine").setLevel(logging.WARNING)

BIKE_MAKES = [
    "HONDA", "YAMAHA", "KAWASAKI", "SUZUKI", "HARLEY-DAVIDSON", 
    "BMW", "DUCATI", "KTM", "TRIUMPH", "APRILIA", "MOTO GUZZI", "INDIAN"
]

class BikeHunter:
    API_URL = "https://vpic.nhtsa.dot.gov/api/vehicles/GetModelsForMakeYear/make/{make}/modelyear/{year}/vehicleType/motorcycle?format=json"

    @classmethod
    async def run(cls):
        """
        THOUGHT PROCESS:
        A robotot úgy alakítjuk át, hogy minden egyes gyártó/év kombinációt 
        külön tranzakcióként kezeljen. Ha egy márka hibát dob, elvégezzük a 
        rollback-et, így a következő márka tiszta lappal indulhat.
        """
        logger.info("🏍️ Robot 1.4 (Bike Hunter) indítása - Tranzakció-biztos mód...")
        years = range(2026, 1969, -1)
        
        async with httpx.AsyncClient(timeout=30.0) as client:
            for year in years:
                for make in BIKE_MAKES:
                    # Minden márkához új session-t nyitunk, vagy biztosítjuk a rollback-et
                    async with AsyncSessionLocal() as db:
                        try:
                            resp = await client.get(cls.API_URL.format(make=make, year=year))
                            if resp.status_code != 200:
                                logger.warning(f"⚠️ {make} ({year}) API hiba: {resp.status_code}")
                                continue
                            
                            models = resp.json().get("Results", [])
                            if not models:
                                continue

                            insert_data = []
                            for m in models:
                                m_name = m.get("Model_Name")
                                if m_name:
                                    model_name = m_name.upper().strip()
                                    insert_data.append({"make": make, "model": model_name, "year": year})
                            
                            if insert_data:
                                # ON CONFLICT használata a CONSTRAINT alapján
                                query = text("""
                                    INSERT INTO vehicle.catalog_discovery
                                    (make, model, vehicle_class, status, market, model_year, priority_score, source)
                                    VALUES (:make, :model, 'motorcycle', 'pending', 'USA_IMPORT', :year, 8, 'NHTSA-V1-BIKE')
                                    ON CONFLICT ON CONSTRAINT _make_model_market_year_uc DO NOTHING
                                """)
                                
                                await db.execute(query, insert_data)
                                await db.commit() # Itt véglegesítjük a sikeres köteget
                                logger.info(f"✅ {make} ({year}): {len(insert_data)} motor feldolgozva.")

                        except Exception as e:
                            # KRITIKUS: Hiba esetén visszaállítjuk a tranzakciót, 
                            # így a következő kör (következő márka) nem bukik el.
                            await db.rollback()
                            logger.error(f"❌ Bike Error {make} ({year}): {str(e)}")
                    
                    # API kímélése (Rate limiting megelőzése)
                    await asyncio.sleep(random.uniform(0.3, 0.6))

if __name__ == "__main__":
    try:
        asyncio.run(BikeHunter.run())
    except KeyboardInterrupt:
        logger.info("🛑 Leállítás felhasználói kérésre.")