"""
Model Factory Functions
"""

from .architectures.hybrid import HybridLatentODEModel
from .architectures.vanilla_ode import VanillaODEModel
from .architectures.event_ode import EventODEModel
from .architectures.augmented_ode import AugmentedODEModel
from .architectures.autoregressive import AutoregressiveModel

def create_model(model_type, config, device):
    """
    Factory function to create different types of models
    
    Args:
        model_type: 'hybrid', 'vanilla_ode', 'event_ode', 'augmented_ode', 'autoregressive'
        config: Configuration dictionary
        device: PyTorch device
    
    Returns:
        model: Instance of BaseModel subclass
    """
    if model_type == 'hybrid':
        from .architectures.hybrid import HybridLatentODEModel
        return HybridLatentODEModel(config, device)
    elif model_type == 'vanilla_ode':
        from .architectures.vanilla_ode import VanillaODEModel
        return VanillaODEModel(config, device)
    elif model_type == 'event_ode':
        from .architectures.event_ode import EventODEModel
        return EventODEModel(config, device)
    elif model_type == 'augmented_ode':
        from .architectures.augmented_ode import AugmentedODEModel
        return AugmentedODEModel(config, device)
    elif model_type == 'autoregressive':
        from .architectures.autoregressive import AutoregressiveModel
        return AutoregressiveModel(config, device)
    else:
        raise ValueError(f"Unknown model type: {model_type}")


# Deprecated functions for backward compatibility
def create_hybrid_models(config, device):
    """Deprecated: Use create_model('hybrid', config, device) instead"""
    model = HybridLatentODEModel(config, device)
    models = {
        'encoder': model.encoder,
        'vector_field': model.vector_field,
        'decoder': model.decoder
    }
    optimizers = model.optimizers
    return models, optimizers


def create_neural_ode_models(config, device):
    """Deprecated: Use create_model('vanilla_ode', config, device) instead"""
    model = VanillaODEModel(config, device)
    models = {'vector_field': model.vector_field}
    optimizers = {'optimizer': model.optimizers['vector_field']}
    return models, optimizers


def create_event_ode_models(config, device):
    """Deprecated: Use create_model('event_ode', config, device) instead"""
    model = EventODEModel(config, device)
    models = {
        'vector_field': model.vector_field,
        'event_function': model.event_function,
        'state_reset': model.state_reset
    }
    optimizers = {'optimizer': model.optimizers['combined']}
    return models, optimizers