#!/usr/bin/env python3
"""
API Testing Script for SEO Article Generator
Tests OpenAI and Gemini API endpoints without deploying the full app
"""

import os
import requests
import json
from dotenv import load_dotenv
import time
from typing import Dict, Any

# Load environment variables
load_dotenv()

class APITester:
    def __init__(self):
        self.openai_api_key = os.getenv("OPENAI_API_KEY")
        self.gemini_api_key = os.getenv("GEMINI_API_KEY")
        
        # Test prompt
        self.test_prompt = "Write a short 100-word article about AI in marketing."
        
        # Models to test
        self.models = {
            "gpt-4.1": "openai",
            "o3": "openai", 
            "gemini-2.5-pro": "gemini"
        }
    
    def test_openai_api(self, model: str) -> Dict[str, Any]:
        """Test OpenAI API endpoint"""
        print(f"\n🔄 Testing OpenAI model: {model}")
        
        if not self.openai_api_key:
            return {"success": False, "error": "OpenAI API key not found"}
        
        try:
            response = requests.post(
                "https://api.openai.com/v1/chat/completions",
                headers={
                    "Authorization": f"Bearer {self.openai_api_key}",
                    "Content-Type": "application/json"
                },
                json={
                    "model": model,
                    "messages": [
                        {"role": "user", "content": self.test_prompt}
                    ],
                    "temperature": 0.7,
                    "max_tokens": 200
                },
                timeout=30
            )
            
            if response.status_code == 200:
                result = response.json()
                content = result['choices'][0]['message']['content'].strip()
                return {
                    "success": True,
                    "content": content,
                    "tokens_used": result.get('usage', {}).get('total_tokens', 'N/A'),
                    "model": model
                }
            else:
                return {
                    "success": False,
                    "error": f"HTTP {response.status_code}: {response.text}",
                    "model": model
                }
                
        except requests.exceptions.Timeout:
            return {"success": False, "error": "Request timeout (30s)", "model": model}
        except Exception as e:
            return {"success": False, "error": str(e), "model": model}
    
    def test_gemini_api(self, model: str) -> Dict[str, Any]:
        """Test Gemini API endpoint"""
        print(f"\n🔄 Testing Gemini model: {model}")
        
        if not self.gemini_api_key:
            return {"success": False, "error": "Gemini API key not found"}
        
        try:
            response = requests.post(
                f"https://generativelanguage.googleapis.com/v1beta/models/{model}:generateContent",
                headers={
                    "Content-Type": "application/json",
                    "x-goog-api-key": self.gemini_api_key
                },
                json={
                    "contents": [{
                        "parts": [{
                            "text": self.test_prompt
                        }]
                    }]
                },
                timeout=30
            )
            
            if response.status_code == 200:
                result = response.json()
                content = result['candidates'][0]['content']['parts'][0]['text'].strip()
                return {
                    "success": True,
                    "content": content,
                    "model": model
                }
            else:
                return {
                    "success": False,
                    "error": f"HTTP {response.status_code}: {response.text}",
                    "model": model
                }
                
        except requests.exceptions.Timeout:
            return {"success": False, "error": "Request timeout (30s)", "model": model}
        except Exception as e:
            return {"success": False, "error": str(e), "model": model}
    
    def test_all_models(self):
        """Test all models and provide comprehensive report"""
        print("🚀 Starting API Testing for SEO Article Generator")
        print("=" * 60)
        
        results = {}
        
        for model, provider in self.models.items():
            start_time = time.time()
            
            if provider == "openai":
                result = self.test_openai_api(model)
            elif provider == "gemini":
                result = self.test_gemini_api(model)
            
            end_time = time.time()
            result["response_time"] = round(end_time - start_time, 2)
            results[model] = result
            
            # Print immediate result
            if result["success"]:
                print(f"✅ {model}: SUCCESS ({result['response_time']}s)")
                print(f"   Content preview: {result['content'][:100]}...")
                if 'tokens_used' in result:
                    print(f"   Tokens used: {result['tokens_used']}")
            else:
                print(f"❌ {model}: FAILED ({result['response_time']}s)")
                print(f"   Error: {result['error']}")
        
        # Summary report
        print("\n" + "=" * 60)
        print("📊 TESTING SUMMARY")
        print("=" * 60)
        
        successful = [m for m, r in results.items() if r["success"]]
        failed = [m for m, r in results.items() if not r["success"]]
        
        print(f"✅ Successful: {len(successful)}/{len(self.models)} models")
        print(f"❌ Failed: {len(failed)}/{len(self.models)} models")
        
        if successful:
            print(f"\n🎉 Working models: {', '.join(successful)}")
            avg_time = sum(results[m]["response_time"] for m in successful) / len(successful)
            print(f"⚡ Average response time: {avg_time:.2f}s")
        
        if failed:
            print(f"\n⚠️ Failed models: {', '.join(failed)}")
            print("\nError details:")
            for model in failed:
                print(f"  • {model}: {results[model]['error']}")
        
        return results

def main():
    """Main testing function"""
    tester = APITester()
    results = tester.test_all_models()
    
    # Save results to file for later reference
    with open("api_test_results.json", "w") as f:
        json.dump(results, f, indent=2)
    
    print(f"\n💾 Detailed results saved to: api_test_results.json")

if __name__ == "__main__":
    main()