"""
Core data models for CAE Mesh Generator
"""
from datetime import datetime
from dataclasses import dataclass
from typing import Optional, Dict, List, Any


@dataclass
class UploadedFile:
    """Model for uploaded CAD files"""
    id: str
    filename: str
    file_path: str
    upload_time: datetime
    status: str  # UPLOADED, PROCESSING, COMPLETED, ERROR
    
    def to_dict(self):
        return {
            'id': self.id,
            'filename': self.filename,
            'file_path': self.file_path,
            'upload_time': self.upload_time.isoformat(),
            'status': self.status
        }


@dataclass
class ProcessingStatus:
    """Model for tracking processing status"""
    status: str  # IDLE, PROCESSING, COMPLETED, ERROR
    message: str
    start_time: Optional[datetime] = None
    end_time: Optional[datetime] = None
    error_message: Optional[str] = None
    progress_percentage: float = 0.0
    current_operation: Optional[str] = None
    last_updated: Optional[datetime] = None
    completed_at: Optional[datetime] = None
    # Enhanced progress tracking fields
    current_stage: Optional[str] = None
    estimated_remaining_time: float = 0.0
    operation_velocity: float = 0.0
    confidence_level: float = 0.0
    detailed_info: Optional[Dict[str, Any]] = None
    
    def to_dict(self):
        return {
            'status': self.status,
            'message': self.message,
            'start_time': self.start_time.isoformat() if self.start_time else None,
            'end_time': self.end_time.isoformat() if self.end_time else None,
            'error_message': self.error_message,
            'progress_percentage': self.progress_percentage,
            'current_operation': self.current_operation,
            'last_updated': self.last_updated.isoformat() if self.last_updated else None,
            'completed_at': self.completed_at.isoformat() if self.completed_at else None,
            # Enhanced progress tracking fields
            'current_stage': self.current_stage,
            'estimated_remaining_time': self.estimated_remaining_time,
            'operation_velocity': self.operation_velocity,
            'confidence_level': self.confidence_level,
            'detailed_info': self.detailed_info or {}
        }


@dataclass
class MeshResult:
    """Model for mesh generation results"""
    element_count: int
    node_count: int
    generation_time: float
    quality_score: float = 0.0
    quality_status: str = "UNKNOWN"
    mesh_file_path: Optional[str] = None
    created_at: Optional[datetime] = None
    min_element_quality: float = 0.0  # Backward compatibility
    processing_time: float = 0.0      # Backward compatibility
    mesh_image_path: str = ""         # Backward compatibility
    # New mesh file export fields
    exported_files: Dict[str, str] = None  # format -> file_path
    export_success: bool = False
    export_errors: List[str] = None
    
    def to_dict(self):
        return {
            'element_count': self.element_count,
            'node_count': self.node_count,
            'generation_time': self.generation_time,
            'quality_score': self.quality_score,
            'quality_status': self.quality_status,
            'mesh_file_path': self.mesh_file_path,
            'created_at': self.created_at.isoformat() if self.created_at else None,
            # Backward compatibility fields
            'min_element_quality': self.min_element_quality,
            'processing_time': self.processing_time or self.generation_time,
            'mesh_image_path': self.mesh_image_path,
            # New mesh file export fields
            'exported_files': self.exported_files or {},
            'export_success': self.export_success,
            'export_errors': self.export_errors or []
        }