Credits and Budget Alerts

import os
import redis
from contextlib import contextmanager

redis_client = redis.Redis.from_url(os.environ.get("REDIS_URL", "redis://localhost:6379"))
USAGE_KEY = "mavera:credits_used:current_period"

def track_credits(credits: int, workspace_id: str = "default"):
    """Increment in-app usage counter."""
    key = f"{USAGE_KEY}:{workspace_id}"
    redis_client.incrby(key, credits)
    redis_client.expire(key, 86400 * 35)  # Expire after ~billing cycle

def get_tracked_usage(workspace_id: str = "default") -> int:
    """Get accumulated credits used this period."""
    key = f"{USAGE_KEY}:{workspace_id}"
    return int(redis_client.get(key) or 0)

def chat_with_tracking(client, messages, persona_id, workspace_id="default"):
    response = client.responses.create(
        model="mavera-1",
        input=messages,
        extra_body={"persona_id": persona_id},
    )
    credits = response.usage.credits_used
    track_credits(credits, workspace_id)
    return response

# Conservative estimates (upper bound)
CREDIT_ESTIMATES = {
    "chat": (1, 5),
    "mave_simple": (10, 15),
    "mave_moderate": (20, 30),
    "mave_complex": (35, 50),
    "focus_group_small": (50, 75),
    "focus_group_medium": (100, 150),
    "focus_group_large": (150, 250),
    "video_short": (100, 150),
    "video_medium": (200, 350),
    "video_long": (400, 600),
}

def estimate_focus_group(sample_size: int, num_questions: int) -> int:
    """Return upper-bound credit estimate for a focus group."""
    if sample_size <= 25:
        base = 75
    elif sample_size <= 50:
        base = 125
    else:
        base = 200
    return base + (num_questions * 2)  # Rough per-question cost

def can_afford(operation: str, estimated_cost: int, remaining_credits: int) -> bool:
    """Check if we have enough credits (with 20% buffer)."""
    buffer = int(estimated_cost * 0.2)
    return remaining_credits >= estimated_cost + buffer

class InsufficientCreditsError(Exception):
    pass


def create_focus_group_with_preflight(payload: dict, remaining_credits_fn) -> dict:
    """Create focus group only if we estimate enough credits."""
    sample_size = payload.get("sample_size", 25)
    num_questions = len(payload.get("questions", []))
    estimated = estimate_focus_group(sample_size, num_questions)
    remaining = remaining_credits_fn()

    if not can_afford("focus_group", estimated, remaining):
        raise InsufficientCreditsError(
            f"Estimated {estimated} credits; only {remaining} remaining. "
            "Please add credits or reduce sample size / questions."
        )

    return requests.post(
        f"{BASE}/focus-groups",
        headers=HEADERS,
        json=payload,
    ).json()

from enum import Enum

class CreditStatus(Enum):
    OK = "ok"
    LOW = "low"
    EXHAUSTED = "exhausted"

def handle_402(error, request_context: dict):
    """Handle 402 and decide: retry later, queue, or fail user-facing."""
    # Log for ops
    logger.warning("Credits exhausted", extra={"context": request_context})

    # Option A: Return user-facing message
    return {
        "success": False,
        "error": "credits_exhausted",
        "message": "You've run out of credits. Please add more in Settings.",
        "action_url": "https://app.mavera.io/settings/billing",
    }

    # Option B: Queue for later (if you have a job queue)
    # queue.push("mavera_retry", request_context, delay_minutes=60)