import os
from fastapi import FastAPI, Depends, HTTPException, status, Security
from fastapi.security import APIKeyHeader
from pydantic import BaseModel, Field

# Import the classifier directly from prediction module
from spam_detector_ai.prediction.predict import VotingSpamDetector, SVMClassifier


app = FastAPI(title="Spam Detector API")

API_KEY_NAME = "X-API-Key"
api_key_header = APIKeyHeader(name=API_KEY_NAME, auto_error=False)

VALID_API_KEYS = {
    os.getenv("API_KEY", "your-secret-api-key-here")
}

# Initialize a specific trained classifier instance
# VotingSpamDetector combines predictions, or use SVMClassifier() / RandomForestSpamClassifier()
try:
    classifier = VotingSpamDetector()
except Exception:
    classifier = SVMClassifier()

async def verify_api_key(api_key: str = Security(api_key_header)):
    if not api_key or api_key not in VALID_API_KEYS:
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail="Invalid or missing API Key",
        )
    return api_key

class SpamCheckRequest(BaseModel):
    message: str = Field(..., min_length=1, description="Message content")

class SpamCheckResponse(BaseModel):
    status_code: int = Field(..., description="1 for spam, 0 for ham")

@app.post(
    "/api/v1/check-spam",
    response_model=SpamCheckResponse,
    dependencies=[Depends(verify_api_key)]
)
async def check_spam(request: SpamCheckRequest):
    try:
        #Sample
        #is_spam = spam_detector.is_spam(message)
        #print(f"Is spam: {is_spam}")

        # Predict using the classifier instance
        prediction = classifier.is_spam(request.message)
        
        # Convert result to 1 (spam) or 0 (ham)
        status_code = 1 if prediction in [1, "1", "spam", True] else 0
        
        return SpamCheckResponse(status_code=status_code)
        
    except Exception as e:
        raise HTTPException(
            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
            detail=f"Error running prediction: {str(e)}"
        )