#!/usr/bin/env python3
"""
Test script for Gemini MCP Server
Tests both stdio and HTTP modes
"""

import argparse
import asyncio
import json
import os
import sys

import requests


def test_http_server(verbose=False):
    """Test HTTP server endpoints"""
    host = os.environ.get("GEMINI_MCP_HOST", "127.0.0.1")
    port = int(os.environ.get("GEMINI_MCP_PORT", "8006"))
    base_url = f"http://{host}:{port}"
    
    print(f"🧪 Testing HTTP server at {base_url}")
    print("=" * 50)
    
    # Test 1: Health check
    print("\n1. Testing health endpoint...")
    try:
        response = requests.get(f"{base_url}/health", timeout=5)
        if response.status_code == 200:
            print("✅ Health check passed")
            if verbose:
                print(f"   Response: {response.json()}")
        else:
            print(f"❌ Health check failed: {response.status_code}")
            return False
    except Exception as e:
        print(f"❌ Cannot connect to server: {e}")
        print("\nMake sure the HTTP server is running:")
        print("  python3 gemini_mcp_server.py --port 8006")
        return False
    
    # Test 2: Root endpoint
    print("\n2. Testing root endpoint...")
    try:
        response = requests.get(base_url)
        if response.status_code == 200:
            print("✅ Root endpoint accessible")
            if verbose:
                print(f"   Endpoints: {json.dumps(response.json()['endpoints'], indent=2)}")
        else:
            print(f"❌ Root endpoint failed: {response.status_code}")
    except Exception as e:
        print(f"❌ Root endpoint error: {e}")
    
    # Test 3: List tools
    print("\n3. Testing tools listing...")
    try:
        response = requests.get(f"{base_url}/mcp/tools")
        if response.status_code == 200:
            tools = response.json()["tools"]
            print(f"✅ Found {len(tools)} tools:")
            for tool in tools:
                print(f"   - {tool['name']}: {tool['description']}")
        else:
            print(f"❌ Tools listing failed: {response.status_code}")
    except Exception as e:
        print(f"❌ Tools listing error: {e}")
    
    # Test 4: Gemini status
    print("\n4. Testing Gemini status...")
    try:
        response = requests.get(f"{base_url}/mcp/tools/gemini_status")
        if response.status_code == 200:
            status = response.json()
            print("✅ Status endpoint working")
            print(f"   Gemini enabled: {status['configuration']['enabled']}")
            print(f"   Auto-consult: {status['configuration']['auto_consult']}")
            print(f"   CLI available: {status.get('cli_available', 'Unknown')}")
            if not status.get('cli_available') and verbose:
                print(f"   CLI error: {status.get('cli_error', 'Unknown')}")
        else:
            print(f"❌ Status check failed: {response.status_code}")
    except Exception as e:
        print(f"❌ Status check error: {e}")
    
    # Test 5: Simple consultation (if Gemini is available)
    print("\n5. Testing Gemini consultation...")
    try:
        payload = {
            "query": "What is 2+2?",
            "context": "This is a test query",
            "comparison_mode": False
        }
        response = requests.post(
            f"{base_url}/mcp/tools/consult_gemini",
            json=payload,
            timeout=30
        )
        if response.status_code == 200:
            result = response.json()
            if result["status"] == "success":
                print("✅ Consultation successful")
                if verbose:
                    print(f"   Response preview: {result['response'][:100]}...")
                    print(f"   Execution time: {result.get('execution_time', 0):.2f}s")
            else:
                print(f"⚠️  Consultation returned status: {result['status']}")
                if result.get("error"):
                    print(f"   Error: {result['error']}")
        else:
            print(f"❌ Consultation failed: {response.status_code}")
            if verbose:
                print(f"   Response: {response.text}")
    except Exception as e:
        print(f"❌ Consultation error: {e}")
    
    print("\n" + "=" * 50)
    print("✅ HTTP server tests completed")
    return True


async def test_stdio_server(verbose=False):
    """Test stdio server basic connectivity"""
    print("🧪 Testing stdio server")
    print("=" * 50)
    
    print("\n1. Testing basic MCP protocol...")
    print("   Note: Full stdio testing requires MCP client setup")
    
    # Try to import and initialize the server
    try:
        from gemini_mcp_server import MCPServer
        server = MCPServer()
        print("✅ Server initialization successful")
        
        # Test configuration loading
        print("\n2. Testing configuration...")
        print(f"   Gemini enabled: {server.gemini.enabled}")
        print(f"   Auto-consult: {server.gemini.auto_consult}")
        print(f"   CLI command: {server.gemini.cli_command}")
        
        # Test uncertainty detection
        print("\n3. Testing uncertainty detection...")
        test_phrases = [
            "I'm not sure about this approach",
            "This is definitely the right way",
            "We should consider multiple options"
        ]
        for phrase in test_phrases:
            has_uncertainty, patterns = server.detect_response_uncertainty(phrase)
            status = "✅ Uncertain" if has_uncertainty else "❌ Certain"
            print(f"   '{phrase[:30]}...' -> {status}")
            if verbose and has_uncertainty:
                print(f"     Patterns: {', '.join(patterns)}")
        
        print("\n" + "=" * 50)
        print("✅ stdio server tests completed")
        print("\nFor full stdio testing, configure Claude Code with:")
        print('  python3 gemini_mcp_server.py --project-root .')
        
    except ImportError as e:
        print(f"❌ Cannot import server: {e}")
        print("\nMake sure you're in the correct directory with:")
        print("  - gemini_mcp_server.py")
        print("  - gemini_integration.py")
        return False
    except Exception as e:
        print(f"❌ Server initialization error: {e}")
        return False
    
    return True


def main():
    parser = argparse.ArgumentParser(description="Test Gemini MCP Server")
    parser.add_argument(
        "--mode",
        choices=["http", "stdio"],
        default="stdio",
        help="Server mode to test (default: stdio)"
    )
    parser.add_argument(
        "--verbose",
        "-v",
        action="store_true",
        help="Show detailed output"
    )
    
    args = parser.parse_args()
    
    print("🤖 Gemini MCP Server Test Suite")
    print("==============================")
    print(f"Testing mode: {args.mode}")
    print("")
    
    if args.mode == "http":
        success = test_http_server(args.verbose)
    else:
        success = asyncio.run(test_stdio_server(args.verbose))
    
    sys.exit(0 if success else 1)


if __name__ == "__main__":
    main()