"""
Test 5: Multi-file Structure and Module Imports
Purpose: Test modular code organization for Spark POC development
"""

import streamlit as st
import sys
import os

# Page configuration
st.set_page_config(
    page_title="Spark POC - Modular Test",
    page_icon="🏗️",
    layout="wide"
)

st.title("🏗️ Modular Structure Test")
st.write("Testing multi-file app structure and module imports for organized development")

# Test 5.1: Import Test
st.header("Test 5.1: Module Import Test")

def test_imports():
    """Test importing our custom modules"""
    import_results = {}
    
    # Test database utilities
    try:
        from utils import database
        import_results['database'] = {
            'success': True,
            'functions': [f for f in dir(database) if not f.startswith('_')],
            'error': None
        }
    except Exception as e:
        import_results['database'] = {
            'success': False,
            'functions': [],
            'error': str(e)
        }
    
    # Test API client utilities
    try:
        from utils import api_client
        import_results['api_client'] = {
            'success': True, 
            'functions': [f for f in dir(api_client) if not f.startswith('_')],
            'error': None
        }
    except Exception as e:
        import_results['api_client'] = {
            'success': False,
            'functions': [],
            'error': str(e)
        }
    
    # Test data processing utilities
    try:
        from utils import data_processor
        import_results['data_processor'] = {
            'success': True,
            'functions': [f for f in dir(data_processor) if not f.startswith('_')],
            'error': None
        }
    except Exception as e:
        import_results['data_processor'] = {
            'success': False,
            'functions': [],
            'error': str(e)
        }
    
    return import_results

# Run import test
import_results = test_imports()

for module, result in import_results.items():
    if result['success']:
        st.write(f"✅ **{module}**: Import successful")
        if result['functions']:
            st.write(f"   Available functions: {', '.join(result['functions'])}")
    else:
        st.write(f"❌ **{module}**: Import failed - {result['error']}")

# Test 5.2: Function Execution Test
st.header("Test 5.2: Module Function Test")

col1, col2 = st.columns(2)

with col1:
    st.subheader("Database Module Test")
    
    if st.button("Test Database Functions"):
        if import_results['database']['success']:
            try:
                from utils.database import test_connection, get_sample_songs, format_tiktok_url
                
                # Test connection function
                conn_result = test_connection()
                st.write(f"**Connection test**: {conn_result}")
                
                # Test sample data function
                sample_songs = get_sample_songs()
                st.write(f"**Sample songs**: {len(sample_songs)} songs loaded")
                st.dataframe(sample_songs)
                
                # Test URL formatting
                if not sample_songs.empty:
                    test_track_id = sample_songs.iloc[0]['tiktok_track_id']
                    test_title = sample_songs.iloc[0]['track']
                    formatted_url = format_tiktok_url(test_title, test_track_id)
                    st.write(f"**URL formatting test**: {formatted_url}")
                
            except Exception as e:
                st.error(f"Database function test failed: {str(e)}")
        else:
            st.warning("Database module not available for testing")

with col2:
    st.subheader("API Client Module Test")
    
    if st.button("Test API Functions"):
        if import_results['api_client']['success']:
            try:
                from utils.api_client import test_http_request, simulate_apify_call, validate_response
                
                # Test HTTP request
                http_result = test_http_request()
                st.write(f"**HTTP test**: {http_result['status']}")
                
                # Test Apify simulation
                apify_result = simulate_apify_call("test-track-id")
                st.write(f"**Apify simulation**: {apify_result['message']}")
                st.json(apify_result['mock_data'])
                
                # Test response validation
                validation_result = validate_response(apify_result['mock_data'])
                st.write(f"**Response validation**: {validation_result}")
                
            except Exception as e:
                st.error(f"API function test failed: {str(e)}")
        else:
            st.warning("API client module not available for testing")

# Test 5.3: Data Processing Test
st.header("Test 5.3: Data Processing Module")

if st.button("Test Data Processing Functions"):
    if import_results['data_processor']['success']:
        try:
            from utils.data_processor import process_video_data, calculate_analytics, format_top_performers
            
            # Create sample data
            sample_data = [
                {'video_id': '123', 'creator': 'user1', 'views': 1000, 'likes': 100},
                {'video_id': '456', 'creator': 'user2', 'views': 2000, 'likes': 250},
                {'video_id': '789', 'creator': 'user1', 'views': 1500, 'likes': 180},
            ]
            
            # Test data processing
            processed = process_video_data(sample_data)
            st.write(f"**Processed data**: {len(processed)} records")
            st.dataframe(processed)
            
            # Test analytics calculation
            analytics = calculate_analytics(processed)
            st.write("**Analytics results**:")
            st.json(analytics)
            
            # Test top performers formatting
            top_videos = format_top_performers(processed, 'views', limit=2)
            st.write("**Top performers**:")
            st.dataframe(top_videos)
            
        except Exception as e:
            st.error(f"Data processing test failed: {str(e)}")
    else:
        st.warning("Data processor module not available for testing")

# Test 5.4: File Structure Analysis
st.header("Test 5.4: File Structure")

def analyze_file_structure():
    """Analyze the current file structure"""
    try:
        current_dir = os.path.dirname(__file__)
        structure = {}
        
        # Get main directory contents
        structure['main'] = os.listdir(current_dir)
        
        # Get utils directory contents if it exists
        utils_dir = os.path.join(current_dir, 'utils')
        if os.path.exists(utils_dir):
            structure['utils'] = os.listdir(utils_dir)
        else:
            structure['utils'] = ['Directory not found']
        
        return structure
        
    except Exception as e:
        return {'error': str(e)}

file_structure = analyze_file_structure()

st.subheader("Current File Structure")
if 'error' not in file_structure:
    st.write("**Main directory:**")
    for file in file_structure['main']:
        st.write(f"- {file}")
    
    st.write("**Utils directory:**")
    for file in file_structure['utils']:
        st.write(f"- {file}")
else:
    st.error(f"File structure analysis failed: {file_structure['error']}")

# Test 5.5: Configuration Management
st.header("Test 5.5: Configuration Test")

if import_results['database']['success']:
    try:
        from utils.database import get_config
        config = get_config()
        
        st.subheader("Configuration Values")
        for key, value in config.items():
            # Mask sensitive values
            display_value = "***" if 'password' in key.lower() or 'token' in key.lower() else value
            st.write(f"**{key}**: {display_value}")
            
    except Exception as e:
        st.warning(f"Configuration test failed: {str(e)}")

# Test Results Summary
st.header("🔍 Modular Structure Results")

total_modules = len(import_results)
successful_imports = sum(1 for r in import_results.values() if r['success'])

test_results = {
    "Module Imports": f"{successful_imports}/{total_modules} successful",
    "File Structure": "✅ Organized" if 'error' not in file_structure else "❌ Issues found",
    "Function Execution": "✅ Working" if successful_imports > 0 else "❌ No modules available",
    "Code Organization": "✅ Modular" if successful_imports >= total_modules * 0.8 else "⚠️ Partial"
}

for test, status in test_results.items():
    st.write(f"**{test}**: {status}")

# Recommendations
st.header("💡 Development Recommendations")

if successful_imports == total_modules:
    st.success("🎉 **Excellent modular structure support!**")
    st.write("""
    **Recommendations for Spark POC:**
    - Use separate modules for database, API, and processing logic
    - Organize utility functions in dedicated files
    - Implement proper configuration management
    - Use consistent import patterns across the application
    """)
elif successful_imports >= total_modules * 0.7:
    st.warning("⚠️ **Good modular support with minor issues**")
    st.write("Some modules had import issues - check file paths and dependencies")
else:
    st.error("❌ **Modular structure needs work**")
    st.write("Significant issues with module imports - may need to adjust file organization")

# Best Practices
st.header("📋 Modular Development Best Practices")

st.write("""
**For Spark POC development:**

1. **File Organization**:
   ```
   spark_app/
   ├── app.py                 # Main Streamlit app
   ├── config.py             # Configuration management  
   ├── utils/
   │   ├── __init__.py       # Package initialization
   │   ├── database.py       # Database operations
   │   ├── api_client.py     # API integration
   │   └── data_processor.py # Data processing
   └── requirements.txt      # Dependencies
   ```

2. **Import Best Practices**:
   - Use relative imports within the project
   - Handle import errors gracefully
   - Keep module dependencies minimal

3. **Configuration Management**:
   - Store sensitive data in environment variables
   - Use configuration files for app settings
   - Implement proper error handling

4. **Code Separation**:
   - Database logic in separate module
   - API calls in dedicated client
   - Data processing in utility functions
   - UI logic only in main app file
""")

# Notes section
st.text_area(
    "Modular structure observations:",
    placeholder="Import issues, file organization problems, deployment considerations...",
    height=100
)