#!/usr/bin/env python3
"""
Comprehensive test suite for Generic CADD processor.

Tests the Generic CADD processor with realistic CAD files
from the CAD revolution era (1980s-1990s), including:
- VersaCAD technical drawings
- FastCAD affordable CAD solutions
- Drafix architectural designs
- DataCAD building plans
- CadKey mechanical parts
- DesignCAD engineering drawings
- TurboCAD consumer designs
"""

import asyncio
import os
import struct
import tempfile
from pathlib import Path
from typing import Dict, List, Any

# Import the Generic CADD processor
import sys
sys.path.append(str(Path(__file__).parent.parent / "src"))

from mcp_legacy_files.processors.generic_cadd import GenericCADDProcessor

class GenericCADDTestSuite:
    """Comprehensive test suite for Generic CADD processing capabilities."""
    
    def __init__(self):
        self.processor = GenericCADDProcessor()
        self.test_files: Dict[str, str] = {}
        self.results: List[Dict[str, Any]] = []
    
    def create_test_files(self) -> bool:
        """Create realistic test Generic CADD files for processing."""
        try:
            print("📐 Creating realistic Generic CADD test files...")
            
            # Create temporary test directory
            self.temp_dir = tempfile.mkdtemp(prefix="generic_cadd_test_")
            
            # Test 1: VersaCAD technical drawing
            vcl_file_path = os.path.join(self.temp_dir, "mechanical_assembly.vcl")
            self._create_versacad_file(vcl_file_path)
            self.test_files["versacad_drawing"] = vcl_file_path
            
            # Test 2: FastCAD affordable design
            fc_file_path = os.path.join(self.temp_dir, "simple_design.fc")
            self._create_fastcad_file(fc_file_path)
            self.test_files["fastcad_design"] = fc_file_path
            
            # Test 3: Drafix architectural plan
            drx_file_path = os.path.join(self.temp_dir, "floor_plan.drx")
            self._create_drafix_file(drx_file_path)
            self.test_files["drafix_architecture"] = drx_file_path
            
            # Test 4: DataCAD building design
            dcd_file_path = os.path.join(self.temp_dir, "building_section.dcd")
            self._create_datacad_file(dcd_file_path)
            self.test_files["datacad_building"] = dcd_file_path
            
            # Test 5: CadKey mechanical part
            cdl_file_path = os.path.join(self.temp_dir, "machine_part.cdl")
            self._create_cadkey_file(cdl_file_path)
            self.test_files["cadkey_part"] = cdl_file_path
            
            # Test 6: DesignCAD engineering drawing
            dc2_file_path = os.path.join(self.temp_dir, "circuit_layout.dc2")
            self._create_designcad_file(dc2_file_path)
            self.test_files["designcad_circuit"] = dc2_file_path
            
            # Test 7: TurboCAD consumer design
            tcw_file_path = os.path.join(self.temp_dir, "home_project.tcw")
            self._create_turbocad_file(tcw_file_path)
            self.test_files["turbocad_home"] = tcw_file_path
            
            print(f"✅ Created {len(self.test_files)} test Generic CADD files")
            return True
            
        except Exception as e:
            print(f"❌ Failed to create test files: {e}")
            return False
    
    def _create_versacad_file(self, file_path: str):
        """Create realistic VersaCAD file."""
        # VersaCAD file structure
        header = bytearray(128)
        
        # VersaCAD signature
        header[0:3] = b"VCL"
        header[3] = 0x01  # Version indicator
        
        # Drawing metadata
        struct.pack_into('<L', header, 4, 1024)      # File size
        struct.pack_into('<H', header, 8, 5)         # Version 5.0
        struct.pack_into('<H', header, 10, 25)       # Layer count
        struct.pack_into('<L', header, 12, 150)      # Entity count
        
        # Drawing name (VersaCAD format)
        drawing_name = b"MECHANICAL_ASSEMBLY" + b"\x00" * 12
        header[32:64] = drawing_name[:32]
        
        # Units and scale
        header[64] = 1    # Inches
        struct.pack_into('<f', header, 65, 1.0)      # Scale 1:1
        
        # VersaCAD specific metadata
        header[80:88] = b"VERSACAD"
        header[88] = 0x05  # VersaCAD 5.0
        
        # Create sample drawing data
        drawing_data = b""
        
        # Add layer definitions
        for layer in range(25):
            layer_def = struct.pack('<HBB', layer, 1, 7)  # Layer num, visible, color
            layer_def += f"LAYER_{layer:02d}".encode('ascii')[:16].ljust(16, b'\x00')
            drawing_data += layer_def
        
        # Add sample entities (lines, arcs, text)
        for entity in range(150):
            if entity % 3 == 0:  # Line entity
                entity_data = struct.pack('<H', 2)  # Entity type: Line
                entity_data += struct.pack('<ffff', 
                    entity * 10.0, entity * 5.0,      # Start point
                    entity * 10.0 + 100, entity * 5.0 + 50  # End point
                )
            elif entity % 3 == 1:  # Arc entity
                entity_data = struct.pack('<H', 3)  # Entity type: Arc
                entity_data += struct.pack('<ffffff',
                    entity * 15.0, entity * 8.0,      # Center
                    25.0,                              # Radius
                    0.0, 3.14159,                      # Start/end angles
                    1.0                                # Arc direction
                )
            else:  # Text entity
                entity_data = struct.pack('<H', 6)  # Entity type: Text
                entity_data += struct.pack('<ff', entity * 20.0, entity * 12.0)  # Position
                entity_data += b"DRAWING_TEXT" + b"\x00" * 4
            
            drawing_data += entity_data
        
        # Write VersaCAD file
        with open(file_path, 'wb') as f:
            f.write(header)
            f.write(drawing_data[:8000])  # Truncate for test file size
    
    def _create_fastcad_file(self, file_path: str):
        """Create realistic FastCAD file."""
        # FastCAD file structure
        header = bytearray(96)
        
        # FastCAD signature
        header[0:4] = b"FCAD"
        header[4] = 0x02  # FastCAD 2.0
        
        # Drawing properties
        struct.pack_into('<L', header, 8, 512)       # File size
        struct.pack_into('<H', header, 12, 8)        # Layer count
        struct.pack_into('<H', header, 14, 45)       # Entity count
        
        # FastCAD drawing name
        drawing_name = b"SIMPLE_DESIGN" + b"\x00" * 18
        header[16:48] = drawing_name[:32]
        
        # Units (FastCAD typically inches)
        header[48] = 1  # Inches
        struct.pack_into('<f', header, 49, 1.0)      # Scale
        
        # FastCAD metadata
        header[60:68] = b"FASTCAD2"
        header[68] = 0x90  # Creation year marker (1990)
        
        # Create drawing entities
        drawing_data = b""
        
        # Simple geometric entities for FastCAD
        for i in range(45):
            if i % 2 == 0:  # Rectangle
                entity_data = struct.pack('<H', 5)  # Polyline/Rectangle
                entity_data += struct.pack('<ffff',
                    i * 25.0, i * 15.0,          # Corner 1
                    i * 25.0 + 80, i * 15.0 + 60  # Corner 2
                )
            else:  # Circle
                entity_data = struct.pack('<H', 4)  # Circle
                entity_data += struct.pack('<fff',
                    i * 30.0, i * 20.0,          # Center
                    15.0                          # Radius
                )
            
            drawing_data += entity_data
        
        with open(file_path, 'wb') as f:
            f.write(header)
            f.write(drawing_data[:3000])
    
    def _create_drafix_file(self, file_path: str):
        """Create realistic Drafix CAD file."""
        # Drafix file structure
        header = bytearray(112)
        
        # Drafix signature
        header[0:6] = b"DRAFIX"
        header[6] = 0x02  # Drafix 2.0
        
        # Architectural drawing properties
        struct.pack_into('<L', header, 8, 2048)      # File size
        struct.pack_into('<H', header, 12, 15)       # Layer count
        struct.pack_into('<H', header, 14, 85)       # Entity count
        header[16] = 1    # Architectural units (feet)
        
        # Drafix drawing name
        drawing_name = b"FLOOR_PLAN_RESIDENTIAL" + b"\x00" * 10
        header[32:64] = drawing_name[:32]
        
        # Architectural scale
        struct.pack_into('<f', header, 64, 0.25)     # 1/4" = 1' scale
        
        # Drafix specific data
        header[80:88] = b"DRAFIX20"
        header[88:92] = b"ARCH"  # Architectural mode
        
        # Create architectural entities
        drawing_data = b""
        
        # Walls, doors, windows for floor plan
        wall_layers = [b"WALLS", b"DOORS", b"WINDOWS", b"DIMENSIONS", b"TEXT"]
        for i, layer_name in enumerate(wall_layers):
            layer_def = struct.pack('<H', i) + layer_name.ljust(16, b'\x00')
            drawing_data += layer_def
        
        # Sample architectural entities
        for i in range(85):
            if i < 30:  # Walls
                entity_data = struct.pack('<H', 2)  # Line (wall)
                entity_data += struct.pack('<ffff',
                    (i % 10) * 12.0, (i // 10) * 8.0,    # Start
                    (i % 10) * 12.0 + 12.0, (i // 10) * 8.0  # End
                )
            elif i < 40:  # Doors/Windows
                entity_data = struct.pack('<H', 8)  # Block insert
                entity_data += struct.pack('<ff', i * 8.0, i * 6.0)  # Position
                entity_data += b"DOOR_30" + b"\x00" * 8
            else:  # Dimensions and text
                entity_data = struct.pack('<H', 7)  # Dimension
                entity_data += struct.pack('<ffff',
                    i * 5.0, i * 3.0, i * 5.0 + 96.0, i * 3.0  # Dimension line
                )
            
            drawing_data += entity_data
        
        with open(file_path, 'wb') as f:
            f.write(header)
            f.write(drawing_data[:6000])
    
    def _create_datacad_file(self, file_path: str):
        """Create realistic DataCAD file."""
        # DataCAD file structure
        header = bytearray(104)
        
        # DataCAD signature
        header[0:3] = b"DCD"
        header[3] = 0x31  # DataCAD version marker
        
        # Building design properties
        struct.pack_into('<L', header, 4, 1536)      # File size
        struct.pack_into('<H', header, 8, 12)        # Layer count
        struct.pack_into('<H', header, 10, 95)       # Entity count
        
        # DataCAD drawing information
        drawing_name = b"BUILDING_SECTION_DETAIL" + b"\x00" * 8
        header[16:48] = drawing_name[:32]
        
        # Architectural units (feet)
        header[48] = 2  # Feet
        struct.pack_into('<f', header, 49, 0.125)    # 1/8" = 1' scale
        
        # DataCAD metadata
        header[64:72] = b"DATACAD"
        header[72] = 0x03  # Version 3
        
        # Create building section entities
        drawing_data = b""
        
        # Building layers
        building_layers = [
            b"FOUNDATION", b"FRAMING", b"WALLS", b"ROOF", 
            b"ELECTRICAL", b"PLUMBING", b"HVAC", b"NOTES"
        ]
        
        for i, layer_name in enumerate(building_layers):
            layer_def = struct.pack('<HB', i, 1) + layer_name.ljust(16, b'\x00')
            drawing_data += layer_def
        
        # Building section entities
        for i in range(95):
            if i < 20:  # Foundation and framing
                entity_data = struct.pack('<H', 2)  # Line
                entity_data += struct.pack('<ffff',
                    0.0, i * 1.0, 40.0, i * 1.0  # Horizontal structural lines
                )
            elif i < 50:  # Walls and openings
                entity_data = struct.pack('<H', 5)  # Polyline
                entity_data += struct.pack('<BB', 4, 0)  # 4 vertices, not closed
                for j in range(4):
                    entity_data += struct.pack('<ff', 
                        j * 10.0, (i - 20) * 0.5  # Wall segment points
                    )
            else:  # Annotations and dimensions
                entity_data = struct.pack('<H', 6)  # Text
                entity_data += struct.pack('<ff', i * 0.4, i * 0.3)  # Position
                entity_data += b"BUILDING_NOTE" + b"\x00" * 3
            
            drawing_data += entity_data
        
        with open(file_path, 'wb') as f:
            f.write(header)
            f.write(drawing_data[:5000])
    
    def _create_cadkey_file(self, file_path: str):
        """Create realistic CadKey file."""
        # CadKey file structure
        header = bytearray(120)
        
        # CadKey signature
        header[0:6] = b"CADKEY"
        header[6] = 0x04  # CadKey version 4
        
        # Mechanical part properties
        struct.pack_into('<L', header, 8, 768)       # File size
        struct.pack_into('<H', header, 12, 6)        # Layer count
        struct.pack_into('<H', header, 14, 55)       # Entity count
        header[16] = 1    # 3D part file
        
        # CadKey part name
        part_name = b"MACHINE_PART_SHAFT" + b"\x00" * 14
        header[32:64] = part_name[:32]
        
        # Mechanical units (inches)
        header[64] = 1  # Inches
        struct.pack_into('<f', header, 65, 1.0)      # Full scale
        
        # CadKey 3D capabilities
        header[80:88] = b"CADKEY4"
        header[88] = 0x01  # 3D enabled
        header[89] = 0x01  # Parametric features
        
        # Create mechanical part entities
        drawing_data = b""
        
        # Mechanical layers
        mech_layers = [b"GEOMETRY", b"DIMENSIONS", b"TOLERANCES", b"NOTES"]
        for i, layer_name in enumerate(mech_layers):
            layer_def = struct.pack('<H', i) + layer_name.ljust(16, b'\x00')
            drawing_data += layer_def
        
        # 3D mechanical entities
        for i in range(55):
            if i < 20:  # 3D wireframe geometry
                entity_data = struct.pack('<H', 12)  # 3D line
                entity_data += struct.pack('<ffffff',
                    i * 2.0, i * 1.5, 0.0,          # Start point 3D
                    i * 2.0 + 5.0, i * 1.5 + 3.0, i * 0.5  # End point 3D
                )
            elif i < 35:  # Mechanical features
                entity_data = struct.pack('<H', 15)  # 3D arc/curve
                entity_data += struct.pack('<ffffff',
                    i * 1.5, i * 1.0, i * 0.25,     # Center 3D
                    2.5,                             # Radius
                    0.0, 6.28                        # Full circle
                )
            else:  # Dimensions and annotations
                entity_data = struct.pack('<H', 7)  # Dimension
                entity_data += struct.pack('<ffffff',
                    i * 1.0, i * 0.8, 0.0,          # Dim start 3D
                    i * 1.0 + 10.0, i * 0.8, 0.0    # Dim end 3D
                )
                entity_data += b"DIM" + b"\x00" * 5
            
            drawing_data += entity_data
        
        with open(file_path, 'wb') as f:
            f.write(header)
            f.write(drawing_data[:4000])
    
    def _create_designcad_file(self, file_path: str):
        """Create realistic DesignCAD file."""
        # DesignCAD file structure
        header = bytearray(88)
        
        # DesignCAD signature
        header[0:3] = b"DC2"
        header[3] = 0x02  # DesignCAD 2D
        
        # Circuit layout properties
        struct.pack_into('<L', header, 4, 640)       # File size
        struct.pack_into('<H', header, 8, 10)        # Layer count
        struct.pack_into('<H', header, 10, 75)       # Entity count
        
        # DesignCAD drawing name
        drawing_name = b"CIRCUIT_LAYOUT_PCB" + b"\x00" * 13
        header[16:48] = drawing_name[:32]
        
        # Electronic design units
        header[48] = 0  # Mils (1/1000 inch)
        struct.pack_into('<f', header, 49, 10.0)     # 10:1 scale
        
        # DesignCAD metadata
        header[64:72] = b"DSIGNCAD"
        header[72] = 0x02  # DesignCAD 2.0
        
        # Create electronic circuit entities
        drawing_data = b""
        
        # Electronic layers
        circuit_layers = [
            b"COMPONENTS", b"TRACES", b"VIAS", b"SILKSCREEN", b"PADS"
        ]
        
        for i, layer_name in enumerate(circuit_layers):
            layer_def = struct.pack('<H', i) + layer_name.ljust(16, b'\x00')
            drawing_data += layer_def
        
        # Circuit board entities
        for i in range(75):
            if i < 25:  # Component outlines
                entity_data = struct.pack('<H', 5)  # Polyline (component)
                entity_data += struct.pack('<BB', 4, 1)  # 4 vertices, closed
                for j in range(4):
                    entity_data += struct.pack('<ff',
                        (i % 5) * 100 + j * 20,      # Component X
                        (i // 5) * 80 + (j % 2) * 40 # Component Y
                    )
            elif i < 50:  # Circuit traces
                entity_data = struct.pack('<H', 2)  # Line (trace)
                entity_data += struct.pack('<ffff',
                    i * 8.0, i * 6.0,               # Trace start
                    i * 8.0 + 50, i * 6.0 + 20      # Trace end
                )
            else:  # Vias and pads
                entity_data = struct.pack('<H', 4)  # Circle (via/pad)
                entity_data += struct.pack('<fff',
                    i * 12.0, i * 9.0,              # Center
                    2.5                              # Radius (via size)
                )
            
            drawing_data += entity_data
        
        with open(file_path, 'wb') as f:
            f.write(header)
            f.write(drawing_data[:3500])
    
    def _create_turbocad_file(self, file_path: str):
        """Create realistic TurboCAD file."""
        # TurboCAD file structure
        header = bytearray(92)
        
        # TurboCAD signature
        header[0:3] = b"TCW"
        header[3] = 0x01  # TurboCAD Windows
        
        # Home project properties
        struct.pack_into('<L', header, 4, 480)       # File size
        struct.pack_into('<H', header, 8, 8)         # Layer count
        struct.pack_into('<H', header, 10, 40)       # Entity count
        
        # TurboCAD drawing name
        drawing_name = b"HOME_PROJECT_DECK" + b"\x00" * 14
        header[16:48] = drawing_name[:32]
        
        # Consumer-friendly units
        header[48] = 2  # Feet
        struct.pack_into('<f', header, 49, 0.5)      # 1/2" = 1' scale
        
        # TurboCAD metadata
        header[64:72] = b"TURBOCAD"
        header[72] = 0x01  # Version 1.0
        header[73] = 0x57  # Windows version ('W')
        
        # Create home project entities
        drawing_data = b""
        
        # Home project layers
        home_layers = [b"STRUCTURE", b"DETAILS", b"MATERIALS", b"NOTES"]
        for i, layer_name in enumerate(home_layers):
            layer_def = struct.pack('<H', i) + layer_name.ljust(16, b'\x00')
            drawing_data += layer_def
        
        # Home design entities
        for i in range(40):
            if i < 15:  # Structural elements
                entity_data = struct.pack('<H', 2)  # Line
                entity_data += struct.pack('<ffff',
                    i * 2.0, 0.0,                    # Start
                    i * 2.0, 12.0                    # End (12 foot spans)
                )
            elif i < 30:  # Details and features
                entity_data = struct.pack('<H', 5)  # Polyline
                entity_data += struct.pack('<BB', 3, 0)  # Triangle
                for j in range(3):
                    entity_data += struct.pack('<ff',
                        (i - 15) * 3.0 + j * 1.5,   # Triangle points
                        j * 2.0
                    )
            else:  # Annotations
                entity_data = struct.pack('<H', 6)  # Text
                entity_data += struct.pack('<ff', i * 1.5, i * 1.0)
                entity_data += b"DECK_NOTE" + b"\x00" * 6
            
            drawing_data += entity_data
        
        with open(file_path, 'wb') as f:
            f.write(header)
            f.write(drawing_data[:2500])
    
    async def run_processing_tests(self) -> bool:
        """Run comprehensive processing tests on all Generic CADD files."""
        try:
            print("\n📐 Running Generic CADD processing tests...")
            print("=" * 60)
            
            success_count = 0
            total_tests = len(self.test_files)
            
            for test_name, file_path in self.test_files.items():
                print(f"\n📋 Testing: {test_name}")
                print(f"   File: {os.path.basename(file_path)}")
                
                try:
                    # Test structure analysis first
                    structure_result = await self.processor.analyze_structure(file_path)
                    print(f"   Structure: {structure_result}")
                    
                    # Test processing with different methods
                    for method in ["auto", "format_parser", "geometry_analysis", "binary_analysis"]:
                        print(f"   📐 Testing method: {method}")
                        
                        result = await self.processor.process(
                            file_path=file_path,
                            method=method,
                            preserve_formatting=True
                        )
                        
                        if result and result.success:
                            print(f"   ✅ {method}: SUCCESS")
                            print(f"      Method used: {result.method_used}")
                            print(f"      Text length: {len(result.text_content or '')}")
                            print(f"      Processing time: {result.processing_time:.3f}s")
                            
                            if result.format_specific_metadata:
                                metadata = result.format_specific_metadata
                                if 'cad_format' in metadata:
                                    print(f"      CAD Format: {metadata['cad_format']}")
                                if 'creation_software' in metadata:
                                    print(f"      Software: {metadata['creation_software']}")
                            
                            success_count += 1
                            break
                        else:
                            print(f"   ⚠️ {method}: {result.error_message if result else 'No result'}")
                    
                    # Store test result
                    self.results.append({
                        "test_name": test_name,
                        "file_path": file_path,
                        "structure": structure_result,
                        "success": result and result.success if result else False,
                        "method_used": result.method_used if result else None,
                        "processing_time": result.processing_time if result else None
                    })
                    
                except Exception as e:
                    print(f"   ❌ ERROR: {str(e)}")
                    self.results.append({
                        "test_name": test_name,
                        "file_path": file_path,
                        "error": str(e),
                        "success": False
                    })
            
            success_rate = (success_count / total_tests) * 100
            print(f"\n📊 Generic CADD Test Results:")
            print(f"   Successful: {success_count}/{total_tests} ({success_rate:.1f}%)")
            
            return success_count > 0
            
        except Exception as e:
            print(f"❌ Test execution failed: {e}")
            return False
    
    async def test_cadd_specific_features(self) -> bool:
        """Test Generic CADD-specific features."""
        try:
            print("\n📐 Testing Generic CADD format features...")
            print("=" * 50)
            
            # Test format detection across different CAD formats
            format_tests = [
                ("VersaCAD", b"VCL"),
                ("FastCAD", b"FCAD"),
                ("Drafix", b"DRAFIX"),
                ("DataCAD", b"DCD"),
                ("CadKey", b"CADKEY"),
                ("DesignCAD", b"DC2"),
                ("TurboCAD", b"TCW")
            ]
            
            format_success = 0
            for format_name, signature_bytes in format_tests:
                test_path = os.path.join(self.temp_dir, f"format_test_{format_name.lower()}.test")
                
                # Create minimal test file with format signature
                with open(test_path, 'wb') as f:
                    f.write(signature_bytes + b"\x00" * 100 + b"TEST CAD DATA")
                
                structure = await self.processor.analyze_structure(test_path)
                if structure in ["intact", "intact_with_issues"]:
                    print(f"   ✅ {format_name}: Structure detected")
                    format_success += 1
                else:
                    print(f"   ⚠️ {format_name}: Structure issue ({structure})")
            
            print(f"\n   Format Detection: {format_success}/{len(format_tests)} formats")
            
            # Test CAD element recognition
            print("\n   📐 Testing CAD element recognition...")
            cad_keywords = ["LAYER", "ENTITY", "LINE", "ARC", "CIRCLE", "DIMENSION", "DRAWING", "SCALE"]
            
            if self.test_files:
                first_file = list(self.test_files.values())[0]
                result = await self.processor.process(first_file, method="binary_analysis")
                
                if result and result.success:
                    detected_elements = 0
                    for keyword in cad_keywords:
                        if keyword.lower() in result.text_content.lower():
                            detected_elements += 1
                    
                    print(f"   📊 CAD Element Recognition: {detected_elements}/{len(cad_keywords)} types detected")
                
            return format_success >= len(format_tests) // 2
            
        except Exception as e:
            print(f"❌ Feature testing failed: {e}")
            return False
    
    def print_comprehensive_report(self):
        """Print comprehensive test results and analysis."""
        print("\n" + "=" * 80)
        print("📐 MCP Legacy Files - Generic CADD Processor Test Report")
        print("=" * 80)
        
        print(f"\n📊 Test Summary:")
        print(f"   Total Tests: {len(self.results)}")
        
        successful_tests = [r for r in self.results if r.get('success')]
        success_rate = (len(successful_tests) / len(self.results)) * 100 if self.results else 0
        
        print(f"   Successful: {len(successful_tests)} ({success_rate:.1f}%)")
        
        if successful_tests:
            avg_time = sum(r.get('processing_time', 0) for r in successful_tests) / len(successful_tests)
            print(f"   Average Processing Time: {avg_time:.3f}s")
        
        print(f"\n📋 Detailed Results:")
        for result in self.results:
            status = "✅ PASS" if result.get('success') else "❌ FAIL"
            test_name = result['test_name']
            print(f"   {status} {test_name}")
            
            if result.get('success'):
                if result.get('method_used'):
                    print(f"        Method: {result['method_used']}")
                if result.get('processing_time'):
                    print(f"        Time: {result['processing_time']:.3f}s")
            else:
                if result.get('error'):
                    print(f"        Error: {result['error']}")
        
        print(f"\n🎯 Generic CADD Processing Capabilities:")
        print(f"   ✅ Format Support: VersaCAD, FastCAD, Drafix, DataCAD, CadKey, DesignCAD, TurboCAD")
        print(f"   ✅ Technical Analysis: Drawing specifications and CAD metadata")
        print(f"   ✅ Geometry Recognition: 2D/3D entity detection and analysis")
        print(f"   ✅ Structure Analysis: CAD file integrity and format validation")
        print(f"   ✅ Processing Chain: CAD conversion → Format parsers → Geometry → Binary fallback")
        
        print(f"\n💡 Recommendations:")
        if success_rate >= 80:
            print(f"   🏆 Excellent performance - ready for production CAD workflows")
        elif success_rate >= 60:
            print(f"   ✅ Good performance - suitable for most Generic CADD processing")
        else:
            print(f"   ⚠️ Needs optimization - consider additional CAD conversion tools")
        
        print(f"\n🚀 Next Steps:")
        print(f"   • Install CAD conversion utilities (dwg2dxf, cadconv)")
        print(f"   • Add format-specific parsers for enhanced metadata extraction")
        print(f"   • Test with real-world Generic CADD files from archives")
        print(f"   • Enhance 3D geometry analysis and technical documentation")
    
    async def cleanup(self):
        """Clean up test files."""
        try:
            if hasattr(self, 'temp_dir') and os.path.exists(self.temp_dir):
                import shutil
                shutil.rmtree(self.temp_dir)
                print(f"\n🧹 Cleaned up test files from {self.temp_dir}")
        except Exception as e:
            print(f"⚠️ Cleanup warning: {e}")

async def main():
    """Run the comprehensive Generic CADD processor test suite."""
    print("📐 MCP Legacy Files - Generic CADD Processor Test Suite")
    print("Testing CAD files from the CAD revolution era (1980s-1990s)")
    print("=" * 80)
    
    test_suite = GenericCADDTestSuite()
    
    try:
        # Create test files
        if not test_suite.create_test_files():
            print("❌ Failed to create test files")
            return False
        
        # Run processing tests
        processing_success = await test_suite.run_processing_tests()
        
        # Test CADD-specific features
        feature_success = await test_suite.test_cadd_specific_features()
        
        # Print comprehensive report
        test_suite.print_comprehensive_report()
        
        overall_success = processing_success and feature_success
        
        print(f"\n🏆 Overall Result: {'SUCCESS' if overall_success else 'NEEDS IMPROVEMENT'}")
        print("Generic CADD processor ready for Phase 7 CAD expansion!")
        
        return overall_success
        
    except Exception as e:
        print(f"❌ Test suite failed: {e}")
        return False
    finally:
        await test_suite.cleanup()

if __name__ == "__main__":
    success = asyncio.run(main())
    exit(0 if success else 1)