main.py

"""
FastAPI API Monetization Starter with AsterPay
==============================================

A complete template for monetizing your API with crypto payments.

Features:
- API key authentication
- Per-request billing
- Credit system
- AsterPay webhook handling
- Example AI endpoint

Run with: uvicorn main:app --reload
"""

from fastapi import FastAPI, HTTPException, Depends, Header, Request
from fastapi.middleware.cors import CORSMiddleware
from pydantic import BaseModel
from typing import Optional
import os
from dotenv import load_dotenv

from auth import verify_api_key, get_user_credits, deduct_credits
from payments import create_payment, verify_webhook
from ai_service import generate_text

load_dotenv()

app = FastAPI(
    title="AI Text API",
    description="AI-powered text generation API with crypto payments via AsterPay",
    version="1.0.0",
)

# CORS
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)


# ============================================
# Models
# ============================================

class GenerateRequest(BaseModel):
    prompt: str
    max_tokens: Optional[int] = 500

class GenerateResponse(BaseModel):
    result: str
    credits_used: int
    credits_remaining: int

class BuyCreditsRequest(BaseModel):
    amount: int  # Number of credits to buy

class BuyCreditsResponse(BaseModel):
    checkout_url: str
    payment_id: str

class CreditsResponse(BaseModel):
    credits: int
    api_key: str


# ============================================
# Endpoints
# ============================================

@app.get("/")
async def root():
    """API information"""
    return {
        "name": "AI Text API",
        "version": "1.0.0",
        "docs": "/docs",
        "pricing": {
            "generate": "1 credit per request",
            "credits": {
                "100": "$5",
                "500": "$20", 
                "1000": "$35"
            }
        }
    }


@app.get("/credits", response_model=CreditsResponse)
async def get_credits(api_key: str = Depends(verify_api_key)):
    """Get current credit balance"""
    credits = get_user_credits(api_key)
    return CreditsResponse(credits=credits, api_key=api_key[:8] + "...")


@app.post("/generate", response_model=GenerateResponse)
async def generate(
    request: GenerateRequest,
    api_key: str = Depends(verify_api_key)
):
    """
    Generate AI text (costs 1 credit per request)
    
    Headers:
        X-API-Key: Your API key
    
    Body:
        prompt: The text prompt
        max_tokens: Maximum tokens to generate (default: 500)
    """
    # Check credits
    credits = get_user_credits(api_key)
    if credits < 1:
        raise HTTPException(
            status_code=402,
            detail={
                "error": "insufficient_credits",
                "message": "Not enough credits. Please purchase more.",
                "credits_remaining": credits,
                "buy_credits_url": "/buy-credits"
            }
        )
    
    # Generate text
    result = await generate_text(request.prompt, request.max_tokens)
    
    # Deduct credit
    remaining = deduct_credits(api_key, 1)
    
    return GenerateResponse(
        result=result,
        credits_used=1,
        credits_remaining=remaining
    )


@app.post("/buy-credits", response_model=BuyCreditsResponse)
async def buy_credits(
    request: BuyCreditsRequest,
    api_key: str = Depends(verify_api_key)
):
    """
    Purchase credits with crypto via AsterPay
    
    Credit packages:
        100 credits = $5
        500 credits = $20
        1000 credits = $35
    """
    # Calculate price
    pricing = {
        100: "5.00",
        500: "20.00",
        1000: "35.00"
    }
    
    if request.amount not in pricing:
        raise HTTPException(
            status_code=400,
            detail={
                "error": "invalid_amount",
                "message": f"Invalid credit amount. Choose from: {list(pricing.keys())}",
                "available_packages": pricing
            }
        )
    
    price = pricing[request.amount]
    
    # Create AsterPay payment
    payment = await create_payment(
        amount=price,
        api_key=api_key,
        credits=request.amount
    )
    
    return BuyCreditsResponse(
        checkout_url=payment["checkout_url"],
        payment_id=payment["id"]
    )


@app.post("/webhook/asterpay")
async def asterpay_webhook(request: Request):
    """
    AsterPay webhook endpoint
    
    Handles payment confirmations and credits user accounts.
    """
    body = await request.body()
    signature = request.headers.get("X-AsterPay-Signature", "")
    
    # Verify webhook
    event = verify_webhook(body, signature)
    
    if event["type"] == "payment.completed":
        api_key = event["data"]["metadata"]["api_key"]
        credits = int(event["data"]["metadata"]["credits"])
        
        # Add credits to user
        from auth import add_credits
        new_balance = add_credits(api_key, credits)
        
        print(f"✅ Payment completed: Added {credits} credits to {api_key[:8]}...")
        print(f"   New balance: {new_balance}")
    
    return {"received": True}


@app.get("/health")
async def health():
    """Health check endpoint"""
    return {"status": "healthy"}


# ============================================
# Run
# ============================================

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)