#!/usr/bin/env python3
"""
Basic test script to verify ChatCal Voice structure.
Run this to check if all imports work and basic functionality is available.
"""

import os
import sys
import asyncio
from datetime import datetime

# Add current directory to path for imports
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))

def test_imports():
    """Test that all core modules import correctly."""
    print("🔍 Testing imports...")
    
    try:
        from core.config import config
        print("✅ Config imported successfully")
        
        from core.session import SessionData
        print("✅ SessionData imported successfully")
        
        from core.session_manager import SessionManager
        print("✅ SessionManager imported successfully")
        
        from core.llm_provider import get_llm
        print("✅ LLM Provider imported successfully")
        
        from core.chat_agent import ChatCalAgent
        print("✅ ChatCalAgent imported successfully")
        
        from core.calendar_service import CalendarService
        print("✅ CalendarService imported successfully")
        
        from core.audio_handler import AudioHandler
        print("✅ AudioHandler imported successfully")
        
        print("🎉 All imports successful!")
        return True
        
    except Exception as e:
        print(f"❌ Import error: {e}")
        return False

def test_basic_functionality():
    """Test basic functionality of core components."""
    print("\n🧪 Testing basic functionality...")
    
    try:
        # Test config
        from core.config import config
        print(f"📋 App Name: {config.app_name}")
        print(f"📋 Default Voice: {config.default_voice}")
        
        # Test session creation
        from core.session import SessionData
        session = SessionData(session_id="test_session")
        session.add_message("user", "Hello test")
        print(f"💬 Session created with {len(session.conversation_history)} messages")
        
        # Test LLM provider
        from core.llm_provider import get_llm
        llm = get_llm()
        print(f"🤖 LLM initialized: {type(llm).__name__}")
        
        # Test calendar service
        from core.calendar_service import CalendarService
        calendar = CalendarService()
        print(f"📅 Calendar service initialized (demo_mode: {calendar.demo_mode})")
        
        # Test audio handler
        from core.audio_handler import AudioHandler
        audio = AudioHandler()
        status = audio.get_audio_status()
        print(f"🎵 Audio handler initialized (demo_mode: {status['demo_mode']})")
        
        print("🎉 Basic functionality tests passed!")
        return True
        
    except Exception as e:
        print(f"❌ Functionality test error: {e}")
        return False

async def test_chat_agent():
    """Test the chat agent with a simple message."""
    print("\n💬 Testing chat agent...")
    
    try:
        from core.chat_agent import ChatCalAgent
        from core.session import SessionData
        
        agent = ChatCalAgent()
        session = SessionData(session_id="test_chat")
        
        # Test message processing
        response = await agent.process_message("Hello, I'm John", session)
        print(f"🤖 Agent response: {response[:100]}...")
        
        print(f"👤 User info extracted: {session.user_info}")
        print("🎉 Chat agent test passed!")
        return True
        
    except Exception as e:
        print(f"❌ Chat agent test error: {e}")
        return False

def test_gradio_compatibility():
    """Test Gradio compatibility."""
    print("\n🎨 Testing Gradio compatibility...")
    
    try:
        import gradio as gr
        print(f"✅ Gradio version: {gr.__version__}")
        
        # Test basic Gradio components
        with gr.Blocks() as demo:
            gr.Markdown("# Test Interface")
            chatbot = gr.Chatbot()
            msg = gr.Textbox(label="Message")
            
        print("✅ Gradio interface creation successful")
        print("🎉 Gradio compatibility test passed!")
        return True
        
    except Exception as e:
        print(f"❌ Gradio compatibility error: {e}")
        return False

async def main():
    """Run all tests."""
    print("🚀 ChatCal Voice - Basic Structure Test")
    print("=" * 50)
    
    # Set minimal environment for testing
    os.environ.setdefault("GROQ_API_KEY", "test_key")
    os.environ.setdefault("MY_PHONE_NUMBER", "+1-555-123-4567")
    os.environ.setdefault("MY_EMAIL_ADDRESS", "test@example.com")
    os.environ.setdefault("SECRET_KEY", "test_secret")
    
    tests = [
        ("Imports", test_imports),
        ("Basic Functionality", test_basic_functionality),
        ("Chat Agent", test_chat_agent),
        ("Gradio Compatibility", test_gradio_compatibility)
    ]
    
    passed = 0
    total = len(tests)
    
    for test_name, test_func in tests:
        print(f"\n{'='*20} {test_name} {'='*20}")
        try:
            if asyncio.iscoroutinefunction(test_func):
                result = await test_func()
            else:
                result = test_func()
            
            if result:
                passed += 1
        except Exception as e:
            print(f"❌ {test_name} failed with exception: {e}")
    
    print(f"\n{'='*50}")
    print(f"🏁 Test Results: {passed}/{total} tests passed")
    
    if passed == total:
        print("🎉 All tests passed! ChatCal Voice structure is ready.")
        print("\n🚀 Next steps:")
        print("1. Update STT_SERVICE_URL and TTS_SERVICE_URL in .env")
        print("2. Add your actual API keys")
        print("3. Deploy to Hugging Face Spaces")
    else:
        print("❌ Some tests failed. Check the errors above.")
        return False
    
    return True

if __name__ == "__main__":
    asyncio.run(main())