"""
Provider Gamification Point Rules Seed Script
=============================================
Cél: Új gamification pontszabályok beszúrása a provider discovery rendszerhez.

Új szabályok:
  - PROVIDER_DISCOVERY (300 pont) — Új provider felfedezése expense rögzítéskor
  - PROVIDER_CONFIRMATION (150 pont) — Meglévő provider adatainak megerősítése
  - PROVIDER_VERIFIED_USE (100 pont) — Már validált provider használata

Használat:
    docker compose exec sf_api python3 /app/backend/app/scripts/seed_provider_point_rules.py
"""

import asyncio
import logging
import sys
from pathlib import Path

# Projekt gyökér hozzáadása a Python path-hoz
sys.path.insert(0, str(Path(__file__).resolve().parent.parent.parent))

from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine, async_sessionmaker
from app.core.config import settings
from app.models.gamification.gamification import PointRule

logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
logger = logging.getLogger("Seed-Provider-Point-Rules")

# Új provider discovery pontszabályok
# A pontértékek a kártya specifikációja szerint (#356, #362):
#   PROVIDER_DISCOVERY          = 300  — Új provider felfedezése
#   PROVIDER_CONFIRMATION       = 150  — Saját pending provider használata
#   PROVIDER_VERIFIED_USE       = 100  — Már validált provider használata
#   USE_UNVERIFIED_PROVIDER     = 200  — Más user által létrehozott, még pending provider használata
SEED_RULES = [
    {
        "action_key": "PROVIDER_DISCOVERY",
        "points": 300,
        "description": "Új, még nem létező provider felfedezése expense rögzítéskor (external_vendor_name alapján)",
        "is_active": True,
    },
    {
        "action_key": "PROVIDER_CONFIRMATION",
        "points": 150,
        "description": "Saját magad által létrehozott, még pending státuszú provider használata",
        "is_active": True,
    },
    {
        "action_key": "PROVIDER_VERIFIED_USE",
        "points": 100,
        "description": "Már jóváhagyott (approved) provider használata költség rögzítésnél",
        "is_active": True,
    },
    {
        "action_key": "USE_UNVERIFIED_PROVIDER",
        "points": 200,
        "description": "Más user által létrehozott, még pending státuszú provider használata (XP farming prevention)",
        "is_active": True,
    },
]


async def seed_provider_point_rules():
    """
    Feltölti a gamification.point_rules táblát a provider discovery szabályokkal.
    Csak azokat a rekordokat szúrja be, amelyek még nem léteznek (action_key alapján).
    """
    engine = create_async_engine(settings.DATABASE_URL, echo=False)
    async_session = async_sessionmaker(engine, class_=AsyncSession, expire_on_commit=False)

    async with async_session() as db:
        try:
            inserted_count = 0
            skipped_count = 0

            for rule_data in SEED_RULES:
                # Ellenőrizzük, hogy létezik-e már ez a szabály
                stmt = select(PointRule).where(
                    PointRule.action_key == rule_data["action_key"]
                )
                result = await db.execute(stmt)
                existing = result.scalar_one_or_none()

                if existing:
                    logger.info(
                        f"⏭️  Szabály már létezik: {rule_data['action_key']} "
                        f"(pont: {existing.points}, ID: {existing.id})"
                    )
                    skipped_count += 1
                    continue

                # Új szabály beszúrása
                new_rule = PointRule(
                    action_key=rule_data["action_key"],
                    points=rule_data["points"],
                    description=rule_data["description"],
                    is_active=rule_data["is_active"],
                )
                db.add(new_rule)
                await db.flush()
                logger.info(
                    f"✅ Szabály létrehozva: {rule_data['action_key']} "
                    f"(pont: {rule_data['points']}, ID: {new_rule.id})"
                )
                inserted_count += 1

            await db.commit()
            logger.info(
                f"\n📊 Összegzés: {inserted_count} új szabály beszúrva, "
                f"{skipped_count} már létezett."
            )

        except Exception as e:
            await db.rollback()
            logger.error(f"❌ Hiba a seedelés során: {e}", exc_info=True)
            raise
        finally:
            await engine.dispose()


if __name__ == "__main__":
    asyncio.run(seed_provider_point_rules())