orion/app/modules/billing/routes/api/store.py

# app/modules/billing/routes/api/store.py
"""
Billing module store routes.

Provides subscription status, tier listing, and invoice history
for store-level users. Resolves store_id to (merchant_id, platform_id)
for all billing service calls.
"""

import logging

from fastapi import APIRouter, Depends, HTTPException, Query
from pydantic import BaseModel
from sqlalchemy.orm import Session

from app.api.deps import get_current_store_api, require_module_access
from app.core.database import get_db
from app.modules.billing.services import billing_service, subscription_service
from app.modules.enums import FrontendType
from app.modules.tenancy.models import User

logger = logging.getLogger(__name__)

# Store router with module access control
store_router = APIRouter(
    prefix="/billing",
    dependencies=[Depends(require_module_access("billing", FrontendType.STORE))],
)


# ============================================================================
# Helpers
# ============================================================================


def _resolve_store_to_merchant(db: Session, store_id: int) -> tuple[int, int]:
    """Resolve store_id to (merchant_id, platform_id)."""
    from app.modules.tenancy.models import Store, StorePlatform

    store = db.query(Store).filter(Store.id == store_id).first()
    if not store or not store.merchant_id:
        raise HTTPException(status_code=404, detail="Store not found")

    sp = db.query(StorePlatform.platform_id).filter(
        StorePlatform.store_id == store_id
    ).first()
    if not sp:
        raise HTTPException(status_code=404, detail="Store not linked to platform")

    return store.merchant_id, sp[0]


# ============================================================================
# Schemas
# ============================================================================


class SubscriptionStatusResponse(BaseModel):
    """Current subscription status."""

    tier_code: str
    tier_name: str
    status: str
    is_trial: bool
    trial_ends_at: str | None = None
    period_start: str | None = None
    period_end: str | None = None
    cancelled_at: str | None = None
    cancellation_reason: str | None = None
    has_payment_method: bool
    last_payment_error: str | None = None
    feature_codes: list[str] = []

    class Config:
        from_attributes = True


class TierResponse(BaseModel):
    """Subscription tier information."""

    code: str
    name: str
    description: str | None = None
    price_monthly_cents: int
    price_annual_cents: int | None = None
    feature_codes: list[str] = []
    is_current: bool = False
    can_upgrade: bool = False
    can_downgrade: bool = False


class TierListResponse(BaseModel):
    """List of available tiers."""

    tiers: list[TierResponse]
    current_tier: str


class InvoiceResponse(BaseModel):
    """Invoice information."""

    id: int
    invoice_number: str | None = None
    invoice_date: str
    due_date: str | None = None
    total_cents: int
    amount_paid_cents: int
    currency: str
    status: str
    pdf_url: str | None = None
    hosted_url: str | None = None


class InvoiceListResponse(BaseModel):
    """List of invoices."""

    invoices: list[InvoiceResponse]
    total: int


# ============================================================================
# Core Billing Endpoints
# ============================================================================


@store_router.get("/subscription", response_model=SubscriptionStatusResponse)
def get_subscription_status(
    current_user: User = Depends(get_current_store_api),
    db: Session = Depends(get_db),
):
    """Get current subscription status."""
    store_id = current_user.token_store_id
    merchant_id, platform_id = _resolve_store_to_merchant(db, store_id)

    subscription, tier = billing_service.get_subscription_with_tier(db, merchant_id, platform_id)

    feature_codes = sorted(tier.get_feature_codes()) if tier else []

    return SubscriptionStatusResponse(
        tier_code=tier.code if tier else "unknown",
        tier_name=tier.name if tier else "Unknown",
        status=subscription.status,
        is_trial=subscription.status == "trial",
        trial_ends_at=subscription.trial_ends_at.isoformat()
        if subscription.trial_ends_at
        else None,
        period_start=subscription.period_start.isoformat()
        if subscription.period_start
        else None,
        period_end=subscription.period_end.isoformat()
        if subscription.period_end
        else None,
        cancelled_at=subscription.cancelled_at.isoformat()
        if subscription.cancelled_at
        else None,
        cancellation_reason=subscription.cancellation_reason,
        has_payment_method=bool(subscription.stripe_payment_method_id),
        last_payment_error=subscription.last_payment_error,
        feature_codes=feature_codes,
    )


@store_router.get("/tiers", response_model=TierListResponse)
def get_available_tiers(
    current_user: User = Depends(get_current_store_api),
    db: Session = Depends(get_db),
):
    """Get available subscription tiers for upgrade/downgrade."""
    store_id = current_user.token_store_id
    merchant_id, platform_id = _resolve_store_to_merchant(db, store_id)

    subscription = subscription_service.get_or_create_subscription(db, merchant_id, platform_id)
    current_tier_id = subscription.tier_id

    tier_list, _ = billing_service.get_available_tiers(db, current_tier_id, platform_id)

    tier_responses = [TierResponse(**tier_data) for tier_data in tier_list]
    current_tier_code = subscription.tier.code if subscription.tier else "unknown"

    return TierListResponse(tiers=tier_responses, current_tier=current_tier_code)


@store_router.get("/invoices", response_model=InvoiceListResponse)
def get_invoices(
    skip: int = Query(0, ge=0),
    limit: int = Query(20, ge=1, le=100),
    current_user: User = Depends(get_current_store_api),
    db: Session = Depends(get_db),
):
    """Get invoice history."""
    store_id = current_user.token_store_id
    merchant_id, platform_id = _resolve_store_to_merchant(db, store_id)

    invoices, total = billing_service.get_invoices(db, merchant_id, skip=skip, limit=limit)

    invoice_responses = [
        InvoiceResponse(
            id=inv.id,
            invoice_number=inv.invoice_number,
            invoice_date=inv.invoice_date.isoformat(),
            due_date=inv.due_date.isoformat() if inv.due_date else None,
            total_cents=inv.total_cents,
            amount_paid_cents=inv.amount_paid_cents,
            currency=inv.currency,
            status=inv.status,
            pdf_url=inv.invoice_pdf_url,
            hosted_url=inv.hosted_invoice_url,
        )
        for inv in invoices
    ]

    return InvoiceListResponse(invoices=invoice_responses, total=total)


# ============================================================================
# Aggregate Sub-Routers
# ============================================================================
# Include all billing-related store sub-routers

from app.modules.billing.routes.api.store_addons import store_addons_router
from app.modules.billing.routes.api.store_checkout import store_checkout_router
from app.modules.billing.routes.api.store_features import store_features_router
from app.modules.billing.routes.api.store_usage import store_usage_router

store_router.include_router(store_features_router, tags=["store-features"])
store_router.include_router(store_checkout_router, tags=["store-billing"])
store_router.include_router(store_addons_router, tags=["store-billing-addons"])
store_router.include_router(store_usage_router, tags=["store-usage"])