#!/usr/bin/env python3
"""
Enhanced mesh generation that saves the mesh files
"""

import sys
import os
import shutil
from pathlib import Path
sys.path.append(os.path.dirname(os.path.abspath(__file__)))

from backend.pymechanical.session_manager import ANSYSSessionManager
import logging

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

def generate_and_save_mesh():
    """Generate mesh and save the files to results directory"""
    print("Generating and Saving Mesh Files")
    print("=" * 50)
    
    session_manager = None
    try:
        # Create results directory
        results_dir = Path("results/mesh_files")
        results_dir.mkdir(parents=True, exist_ok=True)
        
        # Initialize ANSYS session
        session_manager = ANSYSSessionManager(simulation_mode=False)
        session_manager.start_session()
        print("✓ ANSYS session started")
        
        # Get project directory
        project_dir_script = 'ExtAPI.DataModel.Project.ProjectDirectory'
        project_dir = session_manager.mechanical.run_python_script(project_dir_script)
        print(f"ANSYS Project Directory: {project_dir}")
        
        # Import geometry
        geometry_file = "resource\\blade.step"
        print(f"\n1. 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']:
            print(f"✓ Created {selection_result['total_selections']} named selections")
        
        # Apply mesh controls
        print("\n3. Applying mesh controls...")
        named_selections = selection_result.get('selections_created', [])
        mesh_result = session_manager.apply_mesh_controls(named_selections)
        if mesh_result['success']:
            print(f"✓ Applied {len(mesh_result['controls_applied'])} mesh controls")
        
        # Generate mesh
        print("\n4. Generating mesh...")
        generation_result = session_manager.generate_mesh()
        if generation_result['success']:
            print(f"✓ Mesh generated: {generation_result['element_count']} elements, {generation_result['node_count']} nodes")
        else:
            print(f"✗ Mesh generation failed: {generation_result.get('error_message', 'Unknown error')}")
            return
        
        # Check mesh quality
        print("\n5. Checking mesh quality...")
        quality_result = session_manager.check_mesh_quality()
        if quality_result['success']:
            print(f"✓ Quality check: {quality_result['overall_status']} (Score: {quality_result['quality_score']:.1f})")
        
        # Save project file
        print("\n6. Saving project file...")
        timestamp = __import__('datetime').datetime.now().strftime("%Y%m%d_%H%M%S")
        save_script = f'''
import os
project_dir = ExtAPI.DataModel.Project.ProjectDirectory
save_filename = "blade_mesh_{timestamp}.mechdb"
save_path = os.path.join(project_dir, save_filename)

try:
    ExtAPI.DataModel.Project.SaveAs(save_path)
    if os.path.exists(save_path):
        file_size = os.path.getsize(save_path)
        print("Project saved: " + save_filename + " (" + str(file_size) + " bytes)")
        save_filename + ":" + str(file_size)
    else:
        "save_failed"
except Exception as e:
    "error:" + str(e)
'''
        
        save_result = session_manager.mechanical.run_python_script(save_script)
        print(f"Save result: {save_result}")
        
        # Copy the saved file to our results directory
        if save_result and ":" in save_result and not save_result.startswith("error"):
            filename, size = save_result.split(":", 1)
            source_file = os.path.join(project_dir, filename)
            dest_file = results_dir / filename
            
            try:
                if os.path.exists(source_file):
                    shutil.copy2(source_file, dest_file)
                    print(f"✓ Mesh file copied to: {dest_file}")
                    print(f"  File size: {int(size):,} bytes ({int(size)/1024/1024:.1f} MB)")
                    
                    # Create a summary file
                    summary_file = results_dir / f"mesh_summary_{timestamp}.txt"
                    with open(summary_file, 'w') as f:
                        f.write(f"Blade Mesh Generation Summary\n")
                        f.write(f"Generated: {timestamp}\n")
                        f.write(f"Mesh File: {filename}\n")
                        f.write(f"File Size: {int(size):,} bytes ({int(size)/1024/1024:.1f} MB)\n")
                        f.write(f"Elements: {generation_result['element_count']}\n")
                        f.write(f"Nodes: {generation_result['node_count']}\n")
                        f.write(f"Quality Score: {quality_result.get('quality_score', 'N/A')}\n")
                        f.write(f"Quality Status: {quality_result.get('overall_status', 'N/A')}\n")
                        f.write(f"Named Selections: {len(named_selections)}\n")
                        f.write(f"Mesh Controls: {len(mesh_result.get('controls_applied', []))}\n")
                    
                    print(f"✓ Summary saved to: {summary_file}")
                    
                else:
                    print(f"✗ Source file not found: {source_file}")
            except Exception as e:
                print(f"✗ Error copying file: {e}")
        
        print(f"\n✓ Mesh generation and saving completed!")
        print(f"Check the results directory: {results_dir}")
        
    except Exception as e:
        print(f"\n✗ Mesh generation failed: {str(e)}")
        import traceback
        traceback.print_exc()
        
    finally:
        if session_manager:
            session_manager.close_session()

if __name__ == "__main__":
    generate_and_save_mesh()