validation_ui.py

"""
Validation UI - wxPython integration for CLI validator.

Functions for displaying validation results in the dialog UI.
"""

import wx

# Handle both package and standalone import
try:
    from .cli_validator import CLIValidator, ValidationLevel, ValidationResult
except ImportError:
    from cli_validator import CLIValidator, ValidationLevel, ValidationResult

from typing import Dict, List


def validate_and_log(dialog, params: dict, template_type: str = "") -> bool:
    """
    Validate CLI parameters and log results with colors to dialog.
    
    Args:
        dialog: The RenderDialog instance (must have log/log_error/log_warning methods)
        params: Dictionary of CLI parameters to validate
        template_type: Optional template type for context
        
    Returns:
        True if validation passed (no errors), False if errors found
    """
    validator = CLIValidator()
    results = validator.validate(params)
    
    if not results:
        # No issues - log success in green
        if hasattr(dialog, 'log_success'):
            dialog.log_success("✓ CLI parameters validated successfully")
        else:
            dialog.log("✓ CLI parameters validated successfully")
        return True
    
    # Log each result with appropriate color
    has_errors = False
    
    dialog.log("-" * 40)
    dialog.log(f"CLI Validation Results ({template_type or 'params'}):")
    
    for result in results:
        if result.level == ValidationLevel.ERROR:
            has_errors = True
            msg = f"❌ ERROR: {result.message}"
            if result.param:
                msg += f" [{result.param}]"
            if hasattr(dialog, 'log_error'):
                dialog.log_error(msg)
            else:
                dialog.log(msg)
            if result.suggestion:
                if hasattr(dialog, 'log_error'):
                    dialog.log_error(f"   → {result.suggestion}")
                else:
                    dialog.log(f"   → {result.suggestion}")
                    
        elif result.level == ValidationLevel.WARNING:
            msg = f"⚠️ WARNING: {result.message}"
            if result.param:
                msg += f" [{result.param}]"
            if hasattr(dialog, 'log_warning'):
                dialog.log_warning(msg)
            else:
                dialog.log(msg)
            if result.suggestion:
                if hasattr(dialog, 'log_warning'):
                    dialog.log_warning(f"   → {result.suggestion}")
                else:
                    dialog.log(f"   → {result.suggestion}")
                    
        else:  # INFO
            msg = f"ℹ️ INFO: {result.message}"
            dialog.log(msg)
    
    dialog.log("-" * 40)
    
    return not has_errors


def validate_before_render(dialog, params: dict, template_type: str = "") -> bool:
    """
    Validate parameters before starting a render.
    Shows error dialog if validation fails.
    
    Args:
        dialog: The RenderDialog instance  
        params: Dictionary of CLI parameters
        template_type: Template type for context
        
    Returns:
        True if OK to proceed, False if should abort
    """
    is_valid = validate_and_log(dialog, params, template_type)
    
    if not is_valid:
        # Show error dialog
        wx.MessageBox(
            "CLI parameter validation failed.\n\n"
            "Check the log for details (errors shown in red).\n\n"
            "Fix the errors and try again.",
            "Validation Error",
            wx.OK | wx.ICON_ERROR
        )
        return False
    
    return True


def update_validation_status(dialog, params: dict, template_type: str):
    """
    Run validation and update the status indicator in the UI.
    This is called when parameters change to provide immediate feedback.
    
    Args:
        dialog: The RenderDialog instance
        params: Dictionary of CLI parameters
        template_type: Template type (spinrender/static/pinout)
    """
    validator = CLIValidator()
    results = validator.validate(params)
    
    # Get the validation status control for this template type
    status_ctrl_map = {
        "spinrender": "anim_validation_status",
        "static": "static_validation_status",
        "pinout": "pinout_validation_status"
    }
    status_ctrl = getattr(dialog, status_ctrl_map.get(template_type, ""), None)
    
    if status_ctrl:
        if not results:
            status_ctrl.SetLabel("✓")
            status_ctrl.SetForegroundColour(wx.Colour(0, 140, 0))
            status_ctrl.SetToolTip("All CLI parameters are valid")
        elif validator.has_errors(results):
            error_count = len(validator.get_errors(results))
            status_ctrl.SetLabel(f"❌ {error_count}")
            status_ctrl.SetForegroundColour(wx.Colour(200, 0, 0))
            # Build tooltip with errors
            error_msgs = [r.message for r in validator.get_errors(results)]
            status_ctrl.SetToolTip("ERRORS:\n" + "\n".join(f"• {m}" for m in error_msgs[:5]))
        else:
            warning_count = len(validator.get_warnings(results))
            status_ctrl.SetLabel(f"⚠️ {warning_count}")
            status_ctrl.SetForegroundColour(wx.Colour(200, 120, 0))
            # Build tooltip with warnings
            warn_msgs = [r.message for r in validator.get_warnings(results)]
            status_ctrl.SetToolTip("WARNINGS:\n" + "\n".join(f"• {m}" for m in warn_msgs[:5]))
        
        # Refresh the parent layout
        parent = status_ctrl.GetParent()
        if parent:
            parent.Layout()
    
    # Store validation results for later use
    setattr(dialog, f'_{template_type}_validation_results', results)


def format_validation_results(results: List[ValidationResult]) -> str:
    """
    Format validation results as a human-readable string.
    
    Args:
        results: List of ValidationResult objects
    
    Returns:
        Formatted string
    """
    if not results:
        return "✓ All parameters valid"
    
    lines = []
    for r in results:
        prefix = {
            ValidationLevel.ERROR: "❌ ERROR",
            ValidationLevel.WARNING: "⚠️ WARNING", 
            ValidationLevel.INFO: "ℹ️ INFO"
        }.get(r.level, "?")
        
        line = f"{prefix}: {r.message}"
        if r.param:
            line += f" (param: {r.param})"
        if r.suggestion:
            line += f"\n   → {r.suggestion}"
        lines.append(line)
    
    return "\n".join(lines)