# app/modules/billing/services/platform_pricing_service.py
"""
Platform pricing service.

Handles database operations for subscription tiers and add-on products.
"""

from sqlalchemy.orm import Session

from app.modules.billing.models import (
    AddOnProduct,
    SubscriptionTier,
    TIER_LIMITS,
    TierCode,
)


class PlatformPricingService:
    """Service for handling pricing data operations."""

    def get_public_tiers(self, db: Session) -> list[SubscriptionTier]:
        """
        Get all public subscription tiers from the database.

        Returns:
            List of active, public subscription tiers ordered by display_order
        """
        return (
            db.query(SubscriptionTier)
            .filter(
                SubscriptionTier.is_active == True,
                SubscriptionTier.is_public == True,
            )
            .order_by(SubscriptionTier.display_order)
            .all()
        )

    def get_tier_by_code(self, db: Session, tier_code: str) -> SubscriptionTier | None:
        """
        Get a specific tier by code from the database.

        Args:
            db: Database session
            tier_code: The tier code to look up

        Returns:
            SubscriptionTier if found, None otherwise
        """
        return (
            db.query(SubscriptionTier)
            .filter(
                SubscriptionTier.code == tier_code,
                SubscriptionTier.is_active == True,
            )
            .first()
        )

    def get_tier_from_hardcoded(self, tier_code: str) -> dict | None:
        """
        Get tier limits from hardcoded TIER_LIMITS.

        Args:
            tier_code: The tier code to look up

        Returns:
            Dict with tier limits if valid code, None otherwise
        """
        try:
            tier_enum = TierCode(tier_code)
            limits = TIER_LIMITS[tier_enum]
            return {
                "tier_enum": tier_enum,
                "limits": limits,
            }
        except ValueError:
            return None

    def get_active_addons(self, db: Session) -> list[AddOnProduct]:
        """
        Get all active add-on products from the database.

        Returns:
            List of active add-on products ordered by category and display_order
        """
        return (
            db.query(AddOnProduct)
            .filter(AddOnProduct.is_active == True)
            .order_by(AddOnProduct.category, AddOnProduct.display_order)
            .all()
        )


# Singleton instance
platform_pricing_service = PlatformPricingService()
