#!/usr/bin/env python3
"""
MCM Pattern Assignment Utilities
================================

Shared utilities for determining parent module assignments based on 
device name patterns from generator configuration files.

This allows flexible assignment of devices to different MCM parent modules
based on configurable patterns, supporting both simple contains matching
and advanced regex patterns.
"""

import json
import os
import re
from typing import Optional


def determine_parent_module_from_config(device_name: str, config_file_path: str = None, 
                                        is_network_module: bool = False, 
                                        has_ip_address: bool = None) -> tuple[str, bool, str, str]:
    """Determine parent module based on MCM device assignment patterns from config.
    
    Args:
        device_name: Name of the device/module to assign
        config_file_path: Path to the generator config JSON file. If None, looks for 
                         common config files in the project root.
        is_network_module: Whether this is a network module (deprecated, use has_ip_address)
        has_ip_address: Whether the module has an IP address (more accurate than is_network_module)
    
    Returns:
        Tuple of (parent_module_name, should_auto_create_parent, slot_number, ip_address)
    """
    # Default fallback
    default_parent = "SLOT2_EN4TR"
    default_auto_create = False
    default_slot = "2"
    default_ip = "11.200.1.10"
    
    # Determine if this is a network module
    module_has_ip = has_ip_address if has_ip_address is not None else is_network_module
    
    # Try to find config file if not provided
    if config_file_path is None:
        config_file_path = _find_generator_config()
    
    if not config_file_path or not os.path.exists(config_file_path):
        print(f"        No MCM config found for pattern matching, using default parent: {default_parent}")
        return default_parent, default_auto_create, default_slot, default_ip
    
    try:
        with open(config_file_path, 'r') as f:
            config = json.load(f)
        
        assignment_config = config.get('mcm_device_assignment', {})
        if not assignment_config:
            return default_parent, default_auto_create, default_slot, default_ip
            
        pattern_rules = assignment_config.get('pattern_rules', [])
        fallback_parent = assignment_config.get('fallback_parent', default_parent)
        fallback_auto_create = assignment_config.get('auto_create_fallback_parent', default_auto_create)
        fallback_slot = assignment_config.get('fallback_slot', default_slot)
        fallback_ip = assignment_config.get('fallback_ip', default_ip)
        
        # Get EN4TR slot configuration
        en4tr_config = assignment_config.get('en4tr_slot_config', {})
        base_ip = en4tr_config.get('base_ip_pattern', '11.200.1.')
        ip_offset = en4tr_config.get('ip_start_offset', 10)
        
        # Process rules in order (first match wins)
        for rule in pattern_rules:
            if not rule.get('enabled', True):
                continue
            
            # Check if rule is for network modules only
            network_only = rule.get('network_modules_only', False)
            if network_only and not module_has_ip:
                continue  # Skip this rule for non-network modules
                
            device_patterns = rule.get('device_contains_pattern', [])
            parent_tag = rule.get('parent_tag', default_parent)
            auto_create = rule.get('auto_create_parent', default_auto_create)
            slot_number = rule.get('parent_slot', _extract_slot_from_parent_tag(parent_tag))
            parent_ip = rule.get('parent_ip', f"{base_ip}{ip_offset + int(slot_number)}")
            match_mode = rule.get('match_mode', 'contains')
            
            # Check if device name matches any patterns
            if match_mode == 'regex':
                regex_pattern = rule.get('regex_pattern', '')
                if regex_pattern and re.search(regex_pattern, device_name, re.IGNORECASE):
                    network_suffix = " (network module)" if network_only else ""
                    print(f"        Device '{device_name}'{network_suffix} matched regex pattern '{regex_pattern}', assigned to: {parent_tag} (Slot {slot_number}, IP {parent_ip})")
                    return parent_tag, auto_create, slot_number, parent_ip
            else:
                # Default contains matching
                for pattern in device_patterns:
                    if pattern.upper() in device_name.upper():
                        network_suffix = " (network module)" if network_only else ""
                        print(f"        Device '{device_name}'{network_suffix} matched pattern '{pattern}', assigned to: {parent_tag} (Slot {slot_number}, IP {parent_ip})")
                        return parent_tag, auto_create, slot_number, parent_ip
        
        # No patterns matched, use fallback
        print(f"        Device '{device_name}' matched no patterns, using fallback parent: {fallback_parent} (Slot {fallback_slot}, IP {fallback_ip})")
        return fallback_parent, fallback_auto_create, fallback_slot, fallback_ip
        
    except Exception as e:
        print(f"        Error reading MCM config from {config_file_path}: {e}")
        return default_parent, default_auto_create, default_slot, default_ip


def _extract_slot_from_parent_tag(parent_tag: str) -> str:
    """Extract slot number from parent tag name like SLOT3_EN4TR."""
    import re
    match = re.search(r'SLOT(\d+)_EN4TR', parent_tag, re.IGNORECASE)
    return match.group(1) if match else "2"


def _find_generator_config() -> Optional[str]:
    """Find generator config file by searching common locations and names."""
    # Look for common config files in parent directories
    # Prioritize SAT9 config first since it's the current project
    possible_configs = [
        "SAT9_generator_config.json",
        "CNO8_generator_config.json",
        "MTN6_generator_config.json", 
        "generator_config.json"
    ]
    
    # Check current directory and parent directories
    current_dir = os.getcwd()
    for i in range(3):  # Check up to 3 levels up
        for config_name in possible_configs:
            potential_path = os.path.join(current_dir, config_name)
            if os.path.exists(potential_path):
                return potential_path
        current_dir = os.path.dirname(current_dir)
    
    return None


def determine_parent_with_fallback(device_name: str, default_parent: str = "SLOT2_EN4TR", 
                                  config_file_path: str = None, has_ip_address: bool = None) -> tuple[str, bool]:
    """Determine parent module with custom default fallback.
    
    Args:
        device_name: Name of the device/module to assign
        default_parent: Custom default parent if no patterns match
        config_file_path: Path to the generator config JSON file
        has_ip_address: Whether the module has an IP address
    
    Returns:
        Tuple of (parent_module_name, should_auto_create_parent)
    """
    parent, auto_create, _, _ = determine_parent_module_from_config(
        device_name, 
        config_file_path, 
        is_network_module=has_ip_address or False, 
        has_ip_address=has_ip_address
    )
    return parent, auto_create


def determine_parent_with_slot_info(device_name: str, default_parent: str = "SLOT2_EN4TR", 
                                   config_file_path: str = None, has_ip_address: bool = None) -> tuple[str, bool, str, str]:
    """Determine parent module with full slot and IP information.
    
    Args:
        device_name: Name of the device/module to assign
        default_parent: Custom default parent if no patterns match
        config_file_path: Path to the generator config JSON file
        has_ip_address: Whether the module has an IP address
    
    Returns:
        Tuple of (parent_module_name, should_auto_create_parent, slot_number, ip_address)
    """
    return determine_parent_module_from_config(
        device_name, 
        config_file_path, 
        is_network_module=has_ip_address or False, 
        has_ip_address=has_ip_address
    )


# Convenience functions for common module types
def get_parent_for_m12dr(device_name: str, has_ip_address: bool = None) -> str:
    """Get parent module for M12DR modules with appropriate default."""
    parent, _ = determine_parent_with_fallback(device_name, "SLOT2_EN4TR", has_ip_address=has_ip_address)
    return parent


def get_parent_for_vfd(device_name: str, has_ip_address: bool = None) -> str:
    """Get parent module for VFD modules with appropriate default.""" 
    parent, _ = determine_parent_with_fallback(device_name, "SLOT2_EN4TR", has_ip_address=has_ip_address)
    return parent


def get_parent_for_extendo(device_name: str, has_ip_address: bool = None) -> str:
    """Get parent module for Extendo modules with appropriate default."""
    parent, _ = determine_parent_with_fallback(device_name, "SLOT2_EN4TR", has_ip_address=has_ip_address)
    return parent


def get_parent_for_apf(device_name: str, has_ip_address: bool = None) -> str:
    """Get parent module for APF modules with appropriate default."""
    parent, _ = determine_parent_with_fallback(device_name, "SLOT2_EN4TR", has_ip_address=has_ip_address)
    return parent


def get_parent_for_zmx(device_name: str, has_ip_address: bool = None) -> str:
    """Get parent module for ZMX modules with appropriate default."""
    parent, _ = determine_parent_with_fallback(device_name, "SLOT2_EN4TR", has_ip_address=has_ip_address)
    return parent


def get_parent_for_turck_hub(device_name: str, has_ip_address: bool = None) -> str:
    """Get parent module for Turck Hub modules with appropriate default."""
    parent, _ = determine_parent_with_fallback(device_name, "SLOT2_EN4TR", has_ip_address=has_ip_address)
    return parent


def get_parent_for_dpm(device_name: str, has_ip_address: bool = None) -> str:
    """Get parent module for DPM modules with appropriate default."""
    parent, _ = determine_parent_with_fallback(device_name, "SLOT2_EN4TR", has_ip_address=has_ip_address)
    return parent


def get_parent_for_sio(device_name: str, has_ip_address: bool = None) -> str:
    """Get parent module for SIO modules with appropriate default."""
    parent, _ = determine_parent_with_fallback(device_name, "SLOT2_EN4TR", has_ip_address=has_ip_address)
    return parent


def get_parent_for_pmm(device_name: str, has_ip_address: bool = None) -> str:
    """Get parent module for PMM modules with appropriate default."""
    parent, _ = determine_parent_with_fallback(device_name, "SLOT2_EN4TR", has_ip_address=has_ip_address)
    return parent


def get_parent_for_lpe(device_name: str, has_ip_address: bool = None) -> str:
    """Get parent module for LPE modules with appropriate default."""
    parent, _ = determine_parent_with_fallback(device_name, "SLOT2_EN4TR", has_ip_address=has_ip_address)
    return parent


def get_parent_for_beacon(device_name: str, has_ip_address: bool = None) -> str:
    """Get parent module for Beacon modules with appropriate default."""
    parent, _ = determine_parent_with_fallback(device_name, "SLOT2_EN4TR", has_ip_address=has_ip_address)
    return parent


def get_parent_for_solenoid(device_name: str, has_ip_address: bool = None) -> str:
    """Get parent module for Solenoid modules with appropriate default."""
    parent, _ = determine_parent_with_fallback(device_name, "SLOT2_EN4TR", has_ip_address=has_ip_address)
    return parent


# Enhanced functions that return both parent and auto-create flag
def get_parent_and_create_flag_for_m12dr(device_name: str, has_ip_address: bool = None) -> tuple[str, bool]:
    """Get parent module and auto-create flag for M12DR modules."""
    return determine_parent_with_fallback(device_name, "SLOT2_EN4TR", has_ip_address=has_ip_address)


def get_parent_and_create_flag(device_name: str, has_ip_address: bool = None) -> tuple[str, bool]:
    """Get parent module and auto-create flag for any module type."""
    return determine_parent_with_fallback(device_name, "SLOT2_EN4TR", has_ip_address=has_ip_address)


# Registry for tracking EN4TR modules that need to be created
_required_en4tr_modules = {}  # Now stores {module_name: (slot, ip)}


def register_required_en4tr(parent_module_name: str, slot_number: str = None, ip_address: str = None):
    """Register an EN4TR module that needs to be created."""
    global _required_en4tr_modules
    if parent_module_name and parent_module_name.endswith("_EN4TR"):
        _required_en4tr_modules[parent_module_name] = (slot_number, ip_address)
        print(f"        Registered EN4TR module for auto-creation: {parent_module_name} (Slot {slot_number}, IP {ip_address})")


def get_required_en4tr_modules() -> dict:
    """Get the dictionary of EN4TR modules that need to be created."""
    global _required_en4tr_modules
    return _required_en4tr_modules.copy()


def clear_required_en4tr_modules():
    """Clear the registry of required EN4TR modules."""
    global _required_en4tr_modules
    _required_en4tr_modules.clear()


def check_and_register_en4tr_for_device(device_name: str, has_ip_address: bool = None):
    """Check pattern matching for a device and register EN4TR if needed."""
    parent, should_auto_create, slot_number, ip_address = determine_parent_with_slot_info(device_name, has_ip_address=has_ip_address)
    if should_auto_create and parent:
        register_required_en4tr(parent, slot_number, ip_address)
    return parent


def create_en4tr_modules_from_registry(ethernet_base_ip: str = "11.200.1.") -> dict:
    """Create EN4TR module configs for all registered modules.
    
    Args:
        ethernet_base_ip: Base IP address pattern (e.g., "11.200.1.") - used as fallback only
        
    Returns:
        Dictionary mapping module names to EN4TRModuleConfig objects
    """
    from .en4tr_boilerplate_model import create_en4tr_for_slot, extract_slot_from_name
    
    global _required_en4tr_modules
    created_configs = {}
    
    ip_counter = 10  # Fallback IP counter
    
    for en4tr_name, (slot_number, ip_address) in _required_en4tr_modules.items():
        # Use config-specified slot and IP if available, otherwise extract/generate
        slot = slot_number if slot_number else extract_slot_from_name(en4tr_name)
        ip = ip_address if ip_address else f"{ethernet_base_ip}{ip_counter}"
        
        config = create_en4tr_for_slot(
            slot_number=slot,
            ethernet_address=ip,
            name=en4tr_name
        )
        
        created_configs[en4tr_name] = config
        print(f"        Created EN4TR config: {en4tr_name} (Slot {slot}) -> {ip}")
        
        # Only increment counter if we used fallback IP
        if not ip_address:
            ip_counter += 1
    
    return created_configs


# Example usage
if __name__ == "__main__":
    # Test pattern matching with sample device names for slot specification
    test_devices = [
        "VS01C_FIOM18",  # Should go to SLOT3_EN4TR (slot 3, IP 11.200.1.12)
        "VS01B_FIOM1",   # Should go to SLOT2_EN4TR (slot 2, IP 11.200.1.11)
        "OTHER_MODULE"   # Should use fallback
    ]
    
    print("Testing slot-based pattern matching:")
    for device in test_devices:
        parent, auto_create, slot, ip = determine_parent_module_from_config(device, has_ip_address=True)
        print(f"Device: {device} -> Parent: {parent}, Slot: {slot}, IP: {ip}, Auto-create: {auto_create}")
        
        if auto_create:
            register_required_en4tr(parent, slot, ip)
    
    print("\nRegistered EN4TR modules:")
    required_modules = get_required_en4tr_modules()
    for module_name, (slot, ip) in required_modules.items():
        print(f"  {module_name}: Slot {slot}, IP {ip}")
    
    print("\nCreating EN4TR configs from registry:")
    configs = create_en4tr_modules_from_registry()
    for name, config in configs.items():
        print(f"  {name}: Slot {config.slot_number}, IP {config.ethernet_address}")