#!/usr/bin/env python3
"""
Test script for Mesh Generation functionality

This script tests the mesh generator's ability to:
1. Prepare mesh generation
2. Generate mesh with progress monitoring
3. Get mesh statistics
4. Handle errors and cancellation
"""

import sys
import os
sys.path.append(os.path.dirname(os.path.abspath(__file__)))

from backend.pymechanical.session_manager import ANSYSSessionManager
from backend.pymechanical.mesh_generator import MeshGenerator
import logging

# Configure logging
logging.basicConfig(
    level=logging.INFO,
    format='%(levelname)s:%(name)s:%(message)s'
)

def progress_callback(percentage, message):
    """Progress callback for mesh generation"""
    print(f"  Progress: {percentage:.1f}% - {message}")

def test_mesh_generation_real():
    """Test mesh generation with real ANSYS session"""
    print("CAE Mesh Generator Mesh Generation Test")
    print("=" * 70)
    print("Testing Mesh Generation...")
    
    session_manager = None
    try:
        # Initialize ANSYS session
        session_manager = ANSYSSessionManager(simulation_mode=False)
        session_manager.start_session()
        print("✓ ANSYS session started")
        
        # Import geometry
        geometry_file = "resource\\blade.step"
        print(f"1. Importing geometry from {geometry_file}...")
        if session_manager.import_geometry(geometry_file):
            print("✓ Geometry imported successfully")
        else:
            print("✗ Geometry import failed")
            return
        
        # Create named selections
        print("\n2. Creating named selections...")
        selection_result = session_manager.create_named_selections()
        if selection_result['success']:
            named_selections = selection_result['selections_created']
            print(f"✓ Named selections created: {named_selections}")
        else:
            print(f"✗ Named selection creation failed")
            named_selections = ['leading_edge', 'trailing_edge', 'blade_root', 'blade_surfaces']
        
        # Apply mesh controls
        print("\n3. Applying mesh controls...")
        mesh_result = session_manager.apply_mesh_controls(named_selections)
        if mesh_result['success']:
            print("✓ Mesh controls applied successfully")
        else:
            print("⚠ Some mesh controls failed, continuing with generation...")
        
        # Validate mesh generation setup
        print("\n4. Validating mesh generation setup...")
        validation = session_manager.validate_mesh_generation_setup()
        if validation.get('ready_for_generation', False):
            print("✓ Mesh generation setup is ready")
        else:
            print("⚠ Mesh generation setup validation issues:")
            for key, value in validation.items():
                if key != 'success' and key != 'ready_for_generation':
                    print(f"  - {key}: {value}")
        
        # Generate mesh
        print("\n5. Generating mesh...")
        generation_result = session_manager.generate_mesh(progress_callback)
        
        if generation_result['success']:
            print("✓ Mesh generation completed successfully")
            print(f"  - Elements: {generation_result['element_count']}")
            print(f"  - Nodes: {generation_result['node_count']}")
            print(f"  - Generation time: {generation_result['generation_time']:.2f} seconds")
        else:
            print(f"✗ Mesh generation failed: {generation_result.get('error_message', 'Unknown error')}")
        
        # Get mesh statistics
        print("\n6. Getting mesh statistics...")
        stats = session_manager.get_mesh_statistics()
        if stats.get('success', True):
            print("✓ Mesh statistics retrieved")
            print(f"  - Elements: {stats.get('element_count', 'N/A')}")
            print(f"  - Nodes: {stats.get('node_count', 'N/A')}")
            print(f"  - Has mesh: {stats.get('has_mesh', 'N/A')}")
        else:
            print(f"✗ Failed to get mesh statistics: {stats.get('error', 'Unknown error')}")
        
        # Test direct mesh generator functionality
        print("\n7. Testing direct mesh generator functionality...")
        mesh_generator = session_manager.mesh_generator
        if mesh_generator:
            print("✓ Mesh generator available")
            
            # Get generation summary
            summary = mesh_generator.get_generation_summary()
            print(f"  - Status: {summary.get('status', 'N/A')}")
            print(f"  - Progress: {summary.get('progress_percentage', 0):.1f}%")
            
            # Test mesh statistics
            direct_stats = mesh_generator.get_mesh_statistics()
            print(f"  - Direct stats - Elements: {direct_stats.get('element_count', 'N/A')}")
        else:
            print("✗ Mesh generator not available")
        
        print("\n✓ Mesh generation test completed successfully")
        
    except Exception as e:
        print(f"\n✗ Mesh generation test failed: {str(e)}")
        import traceback
        traceback.print_exc()
        
    finally:
        if session_manager:
            session_manager.close_session()

def test_mesh_generation_simulation():
    """Test mesh generation with simulation mode"""
    print("\n" + "=" * 60)
    print("Testing Mesh Generation (Simulation Mode)...")
    
    session_manager = None
    try:
        # Initialize simulation session
        session_manager = ANSYSSessionManager(simulation_mode=True)
        session_manager.start_session()
        print("✓ Simulation session started")
        
        # Import geometry (simulated)
        session_manager.import_geometry("resource/blade.step")
        print("✓ Geometry imported (simulated)")
        
        # Create named selections (simulated)
        selection_result = session_manager.create_named_selections()
        print(f"✓ Named selections created (simulated): {selection_result['selections_created']}")
        
        # Apply mesh controls (simulated)
        mesh_result = session_manager.apply_mesh_controls()
        print("✓ Mesh controls applied (simulated)")
        
        # Validate setup (simulated)
        validation = session_manager.validate_mesh_generation_setup()
        print(f"✓ Setup validation (simulated): ready = {validation.get('ready_for_generation', False)}")
        
        # Generate mesh (simulated)
        print("\nGenerating mesh (simulated)...")
        generation_result = session_manager.generate_mesh(progress_callback)
        
        print("✓ Mesh generation completed (simulated)")
        print(f"  - Elements: {generation_result['element_count']}")
        print(f"  - Nodes: {generation_result['node_count']}")
        print(f"  - Generation time: {generation_result['generation_time']} seconds")
        
        # Get statistics (simulated)
        stats = session_manager.get_mesh_statistics()
        print(f"✓ Mesh statistics (simulated): {stats['element_count']} elements")
        
        print("✓ Simulation mode test completed")
        
    except Exception as e:
        print(f"✗ Simulation test failed: {str(e)}")
        
    finally:
        if session_manager:
            session_manager.close_session()

def test_mesh_generator_standalone():
    """Test mesh generator as standalone component"""
    print("\n" + "=" * 60)
    print("Testing Mesh Generator (Standalone)...")
    
    try:
        # Test with None session (simulation)
        mesh_generator = MeshGenerator(None)
        print("✓ Mesh generator created")
        
        # Test progress callback
        def test_callback(progress, message):
            print(f"  Callback: {progress:.1f}% - {message}")
        
        mesh_generator.set_progress_callback(test_callback)
        print("✓ Progress callback set")
        
        # Test generation summary
        summary = mesh_generator.get_generation_summary()
        print(f"✓ Generation summary: status = {summary.get('status', 'N/A')}")
        
        print("✓ Standalone test completed")
        
    except Exception as e:
        print(f"✗ Standalone test failed: {str(e)}")

if __name__ == "__main__":
    test_mesh_generation_real()
    test_mesh_generation_simulation()
    test_mesh_generator_standalone()
    
    print("\n" + "=" * 70)
    print("✓ All mesh generation tests completed!")