"""
🧪 Testing utilities for Perplexity AI integration
Run comprehensive tests to validate your AI Dataset Studio deployment
"""

import os
import json
import time
import logging
from typing import Dict, List, Tuple, Optional
from datetime import datetime

# Configure logging for tests
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

def test_environment_setup() -> Dict[str, bool]:
    """
    🔍 Test environment setup and dependencies
    
    Returns:
        Dict with test results for each component
    """
    results = {}
    
    print("🔍 Testing Environment Setup...")
    print("=" * 50)
    
    # Test 1: Check Python version
    try:
        import sys
        python_version = sys.version_info
        if python_version >= (3, 8):
            print(f"✅ Python version: {python_version.major}.{python_version.minor}")
            results['python_version'] = True
        else:
            print(f"❌ Python version too old: {python_version.major}.{python_version.minor} (need 3.8+)")
            results['python_version'] = False
    except Exception as e:
        print(f"❌ Python version check failed: {e}")
        results['python_version'] = False
    
    # Test 2: Check required packages
    required_packages = [
        ('gradio', 'Gradio'),
        ('requests', 'Requests'),
        ('pandas', 'Pandas'),
        ('beautifulsoup4', 'BeautifulSoup'),
        ('transformers', 'Transformers'),
        ('torch', 'PyTorch'),
        ('nltk', 'NLTK')
    ]
    
    for package, name in required_packages:
        try:
            __import__(package)
            print(f"✅ {name} imported successfully")
            results[f'package_{package}'] = True
        except ImportError:
            print(f"⚠️ {name} not available (optional for some features)")
            results[f'package_{package}'] = False
    
    # Test 3: Check environment variables
    env_vars = ['PERPLEXITY_API_KEY', 'HF_TOKEN']
    for var in env_vars:
        if os.getenv(var):
            print(f"✅ {var} is set")
            results[f'env_{var.lower()}'] = True
        else:
            status = "❌" if var == 'PERPLEXITY_API_KEY' else "⚠️"
            required = "required" if var == 'PERPLEXITY_API_KEY' else "optional"
            print(f"{status} {var} not set ({required})")
            results[f'env_{var.lower()}'] = bool(os.getenv(var))
    
    # Test 4: Check file structure
    required_files = ['app.py', 'perplexity_client.py', 'config.py', 'requirements.txt']
    for file in required_files:
        if os.path.exists(file):
            print(f"✅ {file} found")
            results[f'file_{file}'] = True
        else:
            print(f"❌ {file} missing")
            results[f'file_{file}'] = False
    
    print("\n" + "=" * 50)
    return results

def test_perplexity_api() -> Dict[str, any]:
    """
    🧠 Test Perplexity API connectivity and functionality
    
    Returns:
        Dict with API test results
    """
    results = {
        'api_key_valid': False,
        'connection_successful': False,
        'response_quality': False,
        'rate_limiting': False,
        'error_handling': False
    }
    
    print("🧠 Testing Perplexity API...")
    print("=" * 50)
    
    try:
        from perplexity_client import PerplexityClient, SearchType
        
        # Test 1: API Key validation
        client = PerplexityClient()
        if client._validate_api_key():
            print("✅ API key is valid")
            results['api_key_valid'] = True
        else:
            print("❌ API key validation failed")
            return results
        
        # Test 2: Basic connection
        try:
            test_results = client.discover_sources(
                project_description="Test query for API connectivity",
                search_type=SearchType.GENERAL,
                max_sources=5
            )
            
            if test_results.sources or test_results.perplexity_response:
                print("✅ API connection successful")
                results['connection_successful'] = True
            else:
                print("⚠️ API connected but no results returned")
                results['connection_successful'] = True
        
        except Exception as e:
            print(f"❌ API connection failed: {e}")
            return results
        
        # Test 3: Response quality
        try:
            quality_test = client.discover_sources(
                project_description="Find product reviews for sentiment analysis machine learning training",
                search_type=SearchType.GENERAL,
                max_sources=10
            )
            
            if len(quality_test.sources) >= 3:
                avg_score = sum(s.relevance_score for s in quality_test.sources) / len(quality_test.sources)
                if avg_score >= 5.0:
                    print(f"✅ Response quality good (avg score: {avg_score:.1f})")
                    results['response_quality'] = True
                else:
                    print(f"⚠️ Response quality moderate (avg score: {avg_score:.1f})")
                    results['response_quality'] = True
            else:
                print("⚠️ Limited response quality (few sources found)")
        
        except Exception as e:
            print(f"⚠️ Response quality test failed: {e}")
        
        # Test 4: Rate limiting
        try:
            start_time = time.time()
            
            # Make two quick requests
            client.discover_sources("Test query 1", max_sources=3)
            time.sleep(0.1)  # Small delay
            client.discover_sources("Test query 2", max_sources=3)
            
            elapsed = time.time() - start_time
            if elapsed >= 1.0:  # Should be rate limited to ~1 second minimum
                print("✅ Rate limiting is working")
                results['rate_limiting'] = True
            else:
                print("⚠️ Rate limiting may not be active")
        
        except Exception as e:
            print(f"⚠️ Rate limiting test inconclusive: {e}")
        
        # Test 5: Error handling
        try:
            # Test with invalid/empty query
            error_test = client.discover_sources("", max_sources=1)
            print("✅ Error handling works (handled empty query)")
            results['error_handling'] = True
        
        except Exception as e:
            print(f"✅ Error handling works (caught exception: {type(e).__name__})")
            results['error_handling'] = True
    
    except ImportError:
        print("❌ Cannot import perplexity_client module")
    except Exception as e:
        print(f"❌ Unexpected error in Perplexity tests: {e}")
    
    print("\n" + "=" * 50)
    return results

def test_ai_models() -> Dict[str, bool]:
    """
    🤖 Test AI model loading and functionality
    
    Returns:
        Dict with model test results
    """
    results = {}
    
    print("🤖 Testing AI Models...")
    print("=" * 50)
    
    try:
        from transformers import pipeline
        import torch
        
        # Check GPU availability
        gpu_available = torch.cuda.is_available()
        print(f"🔧 GPU available: {gpu_available}")
        results['gpu_available'] = gpu_available
        
        # Test sentiment analysis model
        try:
            sentiment_analyzer = pipeline(
                "sentiment-analysis",
                model="cardiffnlp/twitter-roberta-base-sentiment-latest",
                return_all_scores=True
            )
            
            test_text = "This is a great product!"
            result = sentiment_analyzer(test_text)
            
            if result and len(result[0]) > 0:
                print("✅ Sentiment analysis model loaded and working")
                results['sentiment_model'] = True
            else:
                print("❌ Sentiment analysis model not working properly")
                results['sentiment_model'] = False
        
        except Exception as e:
            print(f"⚠️ Sentiment analysis model failed: {e}")
            results['sentiment_model'] = False
        
        # Test summarization model
        try:
            summarizer = pipeline(
                "summarization",
                model="facebook/bart-large-cnn",
                max_length=100,
                min_length=30
            )
            
            test_text = """
            Artificial intelligence has become increasingly important in modern technology.
            Machine learning algorithms are being used across various industries to solve
            complex problems and improve efficiency. Natural language processing, computer
            vision, and robotics are some of the key areas where AI is making significant
            contributions to society and business.
            """
            
            result = summarizer(test_text)
            
            if result and len(result[0]['summary_text']) > 10:
                print("✅ Summarization model loaded and working")
                results['summarization_model'] = True
            else:
                print("❌ Summarization model not working properly")
                results['summarization_model'] = False
        
        except Exception as e:
            print(f"⚠️ Summarization model failed: {e}")
            results['summarization_model'] = False
        
        # Test NER model
        try:
            ner_model = pipeline(
                "ner",
                model="dbmdz/bert-large-cased-finetuned-conll03-english",
                aggregation_strategy="simple"
            )
            
            test_text = "Apple Inc. was founded by Steve Jobs in California."
            result = ner_model(test_text)
            
            if result and len(result) > 0:
                print("✅ NER model loaded and working")
                results['ner_model'] = True
            else:
                print("❌ NER model not working properly")
                results['ner_model'] = False
        
        except Exception as e:
            print(f"⚠️ NER model failed: {e}")
            results['ner_model'] = False
    
    except ImportError:
        print("❌ Transformers not available - AI models cannot be tested")
        results = {'transformers_available': False}
    
    print("\n" + "=" * 50)
    return results

def test_web_scraping() -> Dict[str, bool]:
    """
    🕷️ Test web scraping functionality
    
    Returns:
        Dict with scraping test results
    """
    results = {}
    
    print("🕷️ Testing Web Scraping...")
    print("=" * 50)
    
    try:
        import requests
        from bs4 import BeautifulSoup
        
        # Test URLs (public, safe for testing)
        test_urls = [
            "https://httpbin.org/html",
            "https://example.com",
            "https://httpbin.org/json"
        ]
        
        successful_scrapes = 0
        
        for url in test_urls:
            try:
                headers = {
                    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
                }
                
                response = requests.get(url, headers=headers, timeout=10)
                
                if response.status_code == 200:
                    # Test HTML parsing
                    if 'html' in url:
                        soup = BeautifulSoup(response.content, 'html.parser')
                        text = soup.get_text()
                        if len(text) > 10:
                            successful_scrapes += 1
                            print(f"✅ Successfully scraped HTML from {url}")
                    else:
                        if len(response.text) > 10:
                            successful_scrapes += 1
                            print(f"✅ Successfully retrieved content from {url}")
                else:
                    print(f"⚠️ HTTP {response.status_code} from {url}")
            
            except Exception as e:
                print(f"❌ Failed to scrape {url}: {e}")
        
        if successful_scrapes >= 2:
            print("✅ Web scraping functionality working")
            results['scraping_works'] = True
        else:
            print("❌ Web scraping has issues")
            results['scraping_works'] = False
        
        results['successful_scrapes'] = successful_scrapes
        results['total_tests'] = len(test_urls)
    
    except ImportError as e:
        print(f"❌ Required packages not available: {e}")
        results['scraping_works'] = False
    
    print("\n" + "=" * 50)
    return results

def test_complete_workflow() -> Dict[str, any]:
    """
    🔄 Test complete dataset creation workflow
    
    Returns:
        Dict with workflow test results
    """
    results = {
        'project_creation': False,
        'source_discovery': False,
        'data_scraping': False,
        'data_processing': False,
        'data_export': False,
        'total_time': 0
    }
    
    print("🔄 Testing Complete Workflow...")
    print("=" * 50)
    
    start_time = time.time()
    
    try:
        # Import the main studio class
        from app import DatasetStudio
        
        # Test 1: Initialize studio
        studio = DatasetStudio()
        print("✅ Dataset Studio initialized")
        
        # Test 2: Create project
        project_status = studio.create_project(
            name="Test Project",
            template="sentiment_analysis",
            description="Test project for workflow validation"
        )
        
        if "✅" in project_status:
            print("✅ Project creation successful")
            results['project_creation'] = True
        else:
            print("❌ Project creation failed")
            return results
        
        # Test 3: AI source discovery (if available)
        if studio.perplexity_client:
            discovery_status, sources_json = studio.discover_sources_with_ai(
                project_description="Product reviews for sentiment analysis testing",
                max_sources=5,
                search_type="general"
            )
            
            if "✅" in discovery_status and sources_json != "[]":
                print("✅ AI source discovery successful")
                results['source_discovery'] = True
                
                # Extract URLs for scraping test
                test_urls = studio.extract_urls_from_sources(sources_json)
                if test_urls:
                    test_urls = test_urls[:2]  # Limit to 2 for testing
            else:
                print("⚠️ AI source discovery didn't find sources, using fallback")
                test_urls = ["https://httpbin.org/html"]
        else:
            print("⚠️ Perplexity not available, using test URLs")
            test_urls = ["https://httpbin.org/html"]
        
        # Test 4: Data scraping
        if test_urls:
            scrape_status, scraped_data = studio.scrape_urls('\n'.join(test_urls))
            
            if "✅" in scrape_status:
                print("✅ Data scraping successful")
                results['data_scraping'] = True
            else:
                print("❌ Data scraping failed")
                return results
        
        # Test 5: Data processing
        if studio.scraped_data:
            process_status, processed_data = studio.process_data("sentiment_analysis")
            
            if "✅" in process_status:
                print("✅ Data processing successful")
                results['data_processing'] = True
            else:
                print("⚠️ Data processing had issues but continued")
                results['data_processing'] = True  # Allow partial success
        
        # Test 6: Data export
        if studio.processed_data:
            export_status, file_path = studio.export_dataset("JSON")
            
            if "✅" in export_status and file_path:
                print("✅ Data export successful")
                results['data_export'] = True
            else:
                print("❌ Data export failed")
    
    except Exception as e:
        print(f"❌ Workflow test failed: {e}")
        logger.exception("Workflow test error")
    
    results['total_time'] = time.time() - start_time
    print(f"⏱️ Total workflow time: {results['total_time']:.1f} seconds")
    
    print("\n" + "=" * 50)
    return results

def run_performance_benchmark() -> Dict[str, float]:
    """
    ⚡ Run performance benchmarks
    
    Returns:
        Dict with performance metrics
    """
    results = {}
    
    print("⚡ Running Performance Benchmarks...")
    print("=" * 50)
    
    try:
        # Test 1: API response time
        if os.getenv('PERPLEXITY_API_KEY'):
            from perplexity_client import PerplexityClient
            
            client = PerplexityClient()
            start_time = time.time()
            
            test_result = client.discover_sources(
                "Performance test query for machine learning",
                max_sources=5
            )
            
            api_time = time.time() - start_time
            results['api_response_time'] = api_time
            print(f"🧠 Perplexity API response time: {api_time:.2f}s")
        
        # Test 2: Model loading time
        try:
            from transformers import pipeline
            
            start_time = time.time()
            sentiment_analyzer = pipeline("sentiment-analysis")
            model_load_time = time.time() - start_time
            
            results['model_load_time'] = model_load_time
            print(f"🤖 Model loading time: {model_load_time:.2f}s")
            
            # Test 3: Processing speed
            test_texts = [
                "This is a great product!",
                "I really don't like this item.",
                "This product is okay, nothing special.",
                "Amazing quality and fast delivery!",
                "Terrible experience, would not recommend."
            ]
            
            start_time = time.time()
            for text in test_texts:
                sentiment_analyzer(text)
            processing_time = time.time() - start_time
            
            results['processing_speed'] = len(test_texts) / processing_time
            print(f"🚀 Processing speed: {results['processing_speed']:.1f} items/second")
        
        except ImportError:
            print("⚠️ Cannot test model performance - transformers not available")
        
        # Test 4: Memory usage (basic estimation)
        import psutil
        import os
        
        process = psutil.Process(os.getpid())
        memory_mb = process.memory_info().rss / 1024 / 1024
        results['memory_usage_mb'] = memory_mb
        print(f"💾 Current memory usage: {memory_mb:.1f} MB")
    
    except Exception as e:
        print(f"⚠️ Performance benchmark error: {e}")
    
    print("\n" + "=" * 50)
    return results

def generate_test_report(
    env_results: Dict,
    api_results: Dict,
    model_results: Dict,
    scraping_results: Dict,
    workflow_results: Dict,
    performance_results: Dict
) -> str:
    """
    📊 Generate comprehensive test report
    
    Returns:
        Formatted test report as string
    """
    report = []
    report.append("🚀 AI Dataset Studio - Test Report")
    report.append("=" * 60)
    report.append(f"📅 Generated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
    report.append("")
    
    # Environment Summary
    report.append("🔍 ENVIRONMENT SETUP")
    report.append("-" * 30)
    
    env_score = sum(1 for v in env_results.values() if v) / len(env_results) * 100
    report.append(f"Overall Score: {env_score:.0f}%")
    
    if env_results.get('env_perplexity_api_key'):
        report.append("✅ Perplexity API configured")
    else:
        report.append("❌ Perplexity API not configured")
    
    required_packages = ['package_gradio', 'package_requests', 'package_pandas', 'package_beautifulsoup4']
    missing_required = [p for p in required_packages if not env_results.get(p)]
    
    if not missing_required:
        report.append("✅ All required packages available")
    else:
        report.append(f"❌ Missing required packages: {missing_required}")
    
    report.append("")
    
    # API Summary
    report.append("🧠 PERPLEXITY AI INTEGRATION")
    report.append("-" * 30)
    
    if api_results.get('api_key_valid'):
        report.append("✅ API key valid and working")
        
        if api_results.get('connection_successful'):
            report.append("✅ API connection successful")
        
        if api_results.get('response_quality'):
            report.append("✅ Response quality good")
        
        if api_results.get('rate_limiting'):
            report.append("✅ Rate limiting active")
    else:
        report.append("❌ API integration not working")
    
    report.append("")
    
    # Models Summary
    report.append("🤖 AI MODELS")
    report.append("-" * 30)
    
    if model_results.get('transformers_available', True):
        working_models = sum(1 for k, v in model_results.items() if k.endswith('_model') and v)
        total_models = sum(1 for k in model_results.keys() if k.endswith('_model'))
        
        report.append(f"Working Models: {working_models}/{total_models}")
        
        if model_results.get('gpu_available'):
            report.append("✅ GPU acceleration available")
        else:
            report.append("⚠️ CPU-only processing")
    else:
        report.append("❌ AI models not available")
    
    report.append("")
    
    # Workflow Summary
    report.append("🔄 COMPLETE WORKFLOW")
    report.append("-" * 30)
    
    workflow_steps = ['project_creation', 'source_discovery', 'data_scraping', 'data_processing', 'data_export']
    working_steps = sum(1 for step in workflow_steps if workflow_results.get(step))
    
    report.append(f"Working Steps: {working_steps}/{len(workflow_steps)}")
    report.append(f"Total Time: {workflow_results.get('total_time', 0):.1f} seconds")
    
    if working_steps >= 4:
        report.append("✅ Workflow fully functional")
    elif working_steps >= 2:
        report.append("⚠️ Workflow partially functional")
    else:
        report.append("❌ Workflow has major issues")
    
    report.append("")
    
    # Performance Summary
    report.append("⚡ PERFORMANCE METRICS")
    report.append("-" * 30)
    
    if 'api_response_time' in performance_results:
        api_time = performance_results['api_response_time']
        if api_time < 10:
            report.append(f"✅ API response time: {api_time:.1f}s (good)")
        elif api_time < 20:
            report.append(f"⚠️ API response time: {api_time:.1f}s (acceptable)")
        else:
            report.append(f"❌ API response time: {api_time:.1f}s (slow)")
    
    if 'processing_speed' in performance_results:
        speed = performance_results['processing_speed']
        if speed > 2:
            report.append(f"✅ Processing speed: {speed:.1f} items/sec (good)")
        elif speed > 0.5:
            report.append(f"⚠️ Processing speed: {speed:.1f} items/sec (acceptable)")
        else:
            report.append(f"❌ Processing speed: {speed:.1f} items/sec (slow)")
    
    if 'memory_usage_mb' in performance_results:
        memory = performance_results['memory_usage_mb']
        report.append(f"💾 Memory usage: {memory:.0f} MB")
    
    report.append("")
    
    # Overall Assessment
    report.append("🎯 OVERALL ASSESSMENT")
    report.append("-" * 30)
    
    total_score = 0
    max_score = 0
    
    # Calculate scores
    if env_results.get('env_perplexity_api_key') and env_results.get('package_gradio'):
        total_score += 25
    max_score += 25
    
    if api_results.get('api_key_valid') and api_results.get('connection_successful'):
        total_score += 25
    max_score += 25
    
    if working_steps >= 3:
        total_score += 25
    max_score += 25
    
    if model_results.get('sentiment_model', False) or not model_results.get('transformers_available', True):
        total_score += 25
    max_score += 25
    
    overall_score = (total_score / max_score) * 100 if max_score > 0 else 0
    
    if overall_score >= 80:
        status = "✅ EXCELLENT - Ready for production use"
    elif overall_score >= 60:
        status = "⚠️ GOOD - Minor issues to address"
    elif overall_score >= 40:
        status = "🔧 FAIR - Several issues need fixing"
    else:
        status = "❌ POOR - Major setup problems"
    
    report.append(f"Overall Score: {overall_score:.0f}%")
    report.append(f"Status: {status}")
    
    report.append("")
    report.append("🔧 NEXT STEPS")
    report.append("-" * 30)
    
    if not env_results.get('env_perplexity_api_key'):
        report.append("1. Set PERPLEXITY_API_KEY environment variable")
    
    if not api_results.get('api_key_valid'):
        report.append("2. Verify Perplexity API key is correct")
    
    if working_steps < 3:
        report.append("3. Check error logs for workflow issues")
    
    if not model_results.get('gpu_available', False) and model_results.get('transformers_available', True):
        report.append("4. Consider upgrading to GPU hardware for better performance")
    
    if overall_score >= 80:
        report.append("🎉 Your AI Dataset Studio is ready to create amazing datasets!")
    
    return "\n".join(report)

def main():
    """
    🧪 Run complete test suite
    """
    print("🧪 AI Dataset Studio - Complete Test Suite")
    print("=" * 60)
    print("This will test all components of your deployment")
    print("Please wait while tests are running...\n")
    
    # Run all tests
    env_results = test_environment_setup()
    api_results = test_perplexity_api()
    model_results = test_ai_models()
    scraping_results = test_web_scraping()
    workflow_results = test_complete_workflow()
    performance_results = run_performance_benchmark()
    
    # Generate report
    report = generate_test_report(
        env_results, api_results, model_results,
        scraping_results, workflow_results, performance_results
    )
    
    # Save report
    timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
    report_filename = f"test_report_{timestamp}.txt"
    
    try:
        with open(report_filename, 'w', encoding='utf-8') as f:
            f.write(report)
        print(f"📄 Test report saved to: {report_filename}")
    except Exception as e:
        print(f"⚠️ Could not save report to file: {e}")
    
    print("\n" + "=" * 60)
    print(report)
    print("=" * 60)
    
    return {
        'environment': env_results,
        'api': api_results,
        'models': model_results,
        'scraping': scraping_results,
        'workflow': workflow_results,
        'performance': performance_results
    }

if __name__ == "__main__":
    # Run the complete test suite
    test_results = main()