service-finder/backend/app/services/gamification_service.py

# /opt/docker/dev/service_finder/backend/app/services/gamification_service.py
import logging
import math
from decimal import Decimal
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy import select, desc
from app.models import UserStats, PointsLedger, UserBadge, Badge
from app.models.gamification.gamification import PointRule
from app.models.identity import User, Wallet
from app.models import FinancialLedger
from app.services.config_service import config # 2.0 Központi konfigurátor

logger = logging.getLogger("Gamification-Service-2.0")

class GamificationService:
    """
    Gamification Service 2.0 - A 'Jövevény' lelke.
    Felelős a pontozásért, szintekért, büntetésekért és a jutalom-kreditekért.
    
    Refaktor: A process_activity() most már a point_rules táblából is olvas,
    így az admin által definiált pontszabályok elsőbbséget élveznek a master configgal szemben.
    """

    @staticmethod
    async def award_points(db: AsyncSession, user_id: int, amount: int, reason: str, social_points: int = 0, commit: bool = True):
        """ Statikus segédfüggvény a Robotok számára az egyszerűbb híváshoz.
        
        Args:
            commit: If True (default), commits the transaction internally.
                    Set to False when called from within a larger transaction
                    (e.g., from AuthService.complete_kyc).
        """
        service = GamificationService()
        return await service.process_activity(db, user_id, xp_amount=amount, social_amount=social_points, reason=reason, commit=commit)

    async def _get_point_rule(self, db: AsyncSession, action_key: str) -> dict | None:
        """Lekér egy pontszabályt a point_rules táblából action_key alapján.
        
        Returns:
            dict with 'points' and 'description' or None if not found/inactive.
        """
        stmt = select(PointRule).where(
            PointRule.action_key == action_key,
            PointRule.is_active == True
        )
        result = await db.execute(stmt)
        rule = result.scalar_one_or_none()
        if rule:
            return {"points": rule.points, "description": rule.description}
        return None

    async def process_activity(
        self,
        db: AsyncSession,
        user_id: int,
        xp_amount: int,
        social_amount: int,
        reason: str,
        is_penalty: bool = False,
        commit: bool = True,
        action_key: str | None = None,
        source_type: str | None = None,
        source_id: int | None = None,
    ):
        """ A fő folyamat: Pontozás -> Büntetés szűrés -> Szintszámítás -> Kifizetés.
        
        Refaktor 2.0:
        - Ha action_key meg van adva, a point_rules táblából olvassa a pontértékeket.
        - A master config csak fallback, ha nincs a point_rules-ben.
        - Támogatja a source_type és source_id mezőket a PointsLedger naplózáshoz.
        
        Args:
            commit: If True (default), commits the transaction internally.
                    Set to False when called from within a larger transaction.
            action_key: Opcionális. Ha meg van adva, a point_rules táblából
                        olvassa a pontértékeket a master config helyett.
            source_type: Opcionális. A pontok forrásának típusa (pl. 'service_submission').
            source_id: Opcionális. A pontok forrásának ID-ja.
        """
        try:
            # 1. ADMIN KONFIGURÁCIÓ BETÖLTÉSE
            # Minden paraméter az admin felületről módosítható JSON-ként
            cfg = await config.get_setting(db, "GAMIFICATION_MASTER_CONFIG", default={
                "xp_logic": {"base_xp": 500, "exponent": 1.5},
                "penalty_logic": {
                    "recovery_rate": 0.5,
                    "thresholds": {"level_1": 100, "level_2": 500, "level_3": 1000},
                    "multipliers": {"L0": 1.0, "L1": 0.5, "L2": 0.1, "L3": 0.0}
                },
                "conversion_logic": {"social_to_credit_rate": 100},
                "level_rewards": {"credits_per_10_levels": 50}
            })

            # 1/b. POINT RULES TÁBLA LEKÉRÉSE (ha action_key meg van adva)
            # A point_rules tábla elsőbbséget élvez a master config-gal szemben!
            if action_key:
                rule = await self._get_point_rule(db, action_key)
                if rule:
                    # A point_rules-ból jövő pontok felülírják a paraméterként kapott értékeket
                    xp_amount = rule["points"]
                    if rule.get("description"):
                        reason = f"{action_key}: {rule['description']}"
                    logger.debug(f"Point rule applied: {action_key} -> {xp_amount} XP")
                else:
                    logger.debug(f"No active point rule found for action_key='{action_key}', using fallback values.")

            # 2. FELHASZNÁLÓ ÉS STATISZTIKA ELLENŐRZÉSE
            stats_stmt = select(UserStats).where(UserStats.user_id == user_id)
            stats = (await db.execute(stats_stmt)).scalar_one_or_none()
            
            if not stats:
                stats = UserStats(user_id=user_id, total_xp=0, current_level=1, penalty_points=0)
                db.add(stats)
                await db.flush()

            # 3. BÜNTETŐ LOGIKA (Ha negatív esemény történik)
            if is_penalty:
                return await self._apply_penalty(db, stats, xp_amount, reason, cfg, source_type=source_type, source_id=source_id)

            # 4. SZORZÓK ALKALMAZÁSA (Büntetés alatt állók 'bírsága')
            multiplier = await self._calculate_multiplier(stats, cfg)
            if multiplier <= 0:
                logger.warning(f"User {user_id} pontszerzése blokkolva a büntetések miatt.")
                return stats

            # 5. XP SZÁMÍTÁS ÉS SZINTLÉPÉS
            final_xp = int(xp_amount * multiplier)
            if final_xp > 0:
                stats.total_xp += final_xp
                # Büntetés ledolgozás (Recovery)
                if stats.penalty_points > 0:
                    recovery = int(final_xp * cfg["penalty_logic"]["recovery_rate"])
                    stats.penalty_points = max(0, stats.penalty_points - recovery)

                # Új szint számítás hatványfüggvénnyel:
                # $Level = \sqrt[exponent]{\frac{XP}{Base}} + 1$
                xp_cfg = cfg["xp_logic"]
                new_level = int((stats.total_xp / xp_cfg["base_xp"]) ** (1 / xp_cfg["exponent"])) + 1
                
                if new_level > stats.current_level:
                    await self._handle_level_up(db, user_id, stats.current_level, new_level, cfg)
                    stats.current_level = new_level

            # 6. SOCIAL PONT ÉS KREDIT KONVERZIÓ
            final_social = int(social_amount * multiplier)
            if final_social > 0:
                stats.social_points += final_social
                rate = cfg["conversion_logic"]["social_to_credit_rate"]
                
                if stats.social_points >= rate:
                    credits_to_add = stats.social_points // rate
                    stats.social_points %= rate # A maradék pont megmarad
                    await self._add_earned_credits(db, user_id, credits_to_add, "SOCIAL_ACTIVITY_CONVERSION")

            # 7. NAPLÓZÁS (kibővítve xp, source_type, source_id mezőkkel)
            db.add(PointsLedger(
                user_id=user_id,
                points=final_xp,
                xp=final_xp,
                reason=reason,
                source_type=source_type,
                source_id=source_id,
            ))
            
            # Only commit if caller wants us to manage the transaction
            if commit:
                await db.commit()
                await db.refresh(stats)
            return stats

        except Exception as e:
            if commit:
                await db.rollback()
            logger.error(f"Gamification Error for user {user_id}: {e}")
            raise e

    # --- PRIVÁT SEGÉDFÜGGVÉNYEK ---

    async def _apply_penalty(self, db: AsyncSession, stats: UserStats, amount: int, reason: str, cfg: dict,
                              source_type: str | None = None, source_id: int | None = None):
        """Büntetőpontok hozzáadása és korlátozási szintek emelése.
        
        Refaktor: Most már támogatja a source_type és source_id mezőket a naplózáshoz.
        """
        stats.penalty_points += amount
        th = cfg["penalty_logic"]["thresholds"]
        
        if stats.penalty_points >= th["level_3"]: stats.restriction_level = 3
        elif stats.penalty_points >= th["level_2"]: stats.restriction_level = 2
        elif stats.penalty_points >= th["level_1"]: stats.restriction_level = 1
        
        db.add(PointsLedger(
            user_id=stats.user_id,
            points=0,
            penalty_change=amount,
            reason=f"🔴 PENALTY: {reason}",
            source_type=source_type,
            source_id=source_id,
        ))
        await db.commit()
        return stats

    async def _calculate_multiplier(self, stats: UserStats, cfg: dict) -> float:
        """Kiszámolja a szorzót a jelenlegi büntetési szint alapján."""
        m = cfg["penalty_logic"]["multipliers"]
        if stats.restriction_level == 3: return m["L3"]
        if stats.restriction_level == 2: return m["L2"]
        if stats.restriction_level == 1: return m["L1"]
        return m["L0"]

    async def _handle_level_up(self, db: AsyncSession, user_id: int, old_lvl: int, new_lvl: int, cfg: dict):
        """Szintlépési jutalmak (pl. minden 10. szintnél kredit)."""
        logger.info(f"✨ Level Up: User {user_id} ({old_lvl} -> {new_lvl})")
        if new_lvl % 10 == 0:
            reward = cfg["level_rewards"]["credits_per_10_levels"]
            await self._add_earned_credits(db, user_id, reward, f"LEVEL_{new_lvl}_REWARD")

    async def _add_earned_credits(self, db: AsyncSession, user_id: int, amount: int, reason: str):
        """Kredit jóváírása a Wallet-ben és a pénzügyi naplóban."""
        wallet_stmt = select(Wallet).where(Wallet.user_id == user_id)
        wallet = (await db.execute(wallet_stmt)).scalar_one_or_none()
        if wallet:
            wallet.earned_credits += Decimal(str(amount))
            db.add(FinancialLedger(
                user_id=user_id,
                amount=float(amount),
                transaction_type="GAMIFICATION_CREDIT",
                details={"reason": reason}
            ))

gamification_service = GamificationService()