"""Convenience functions to create configurations for training and inference."""

from collections.abc import Sequence
from typing import Annotated, Any, Literal, Union

from pydantic import Field, TypeAdapter

from careamics.config.algorithms import (
    CAREAlgorithm,
    MicroSplitAlgorithm,
    N2NAlgorithm,
    N2VAlgorithm,
    PN2VAlgorithm,
)
from careamics.config.architectures import LVAEConfig, UNetConfig
from careamics.config.data import DataConfig
from careamics.config.lightning.optimizer_configs import (
    LrSchedulerConfig,
    OptimizerConfig,
)
from careamics.config.lightning.training_config import TrainingConfig
from careamics.config.losses.loss_config import KLLossConfig, LVAELossConfig
from careamics.config.noise_model import GaussianMixtureNMConfig, MultiChannelNMConfig
from careamics.config.noise_model.likelihood_config import (
    GaussianLikelihoodConfig,
    NMLikelihoodConfig,
)
from careamics.config.support import (
    SupportedArchitecture,
    SupportedPixelManipulation,
    SupportedTransform,
)
from careamics.config.transformations import (
    SPATIAL_TRANSFORMS_UNION,
    N2VManipulateConfig,
    XYFlipConfig,
    XYRandomRotate90Config,
)
from careamics.lvae_training.dataset.config import MicroSplitDataConfig

from .configuration import Configuration


def algorithm_factory(
    algorithm: dict[str, Any],
) -> Union[N2VAlgorithm, N2NAlgorithm, CAREAlgorithm, PN2VAlgorithm]:
    """
    Create an algorithm model for training CAREamics.

    Parameters
    ----------
    algorithm : dict
        Algorithm dictionary.

    Returns
    -------
    N2VAlgorithm or N2NAlgorithm or CAREAlgorithm or PN2VAlgorithm
        Algorithm model for training CAREamics.
    """
    adapter: TypeAdapter = TypeAdapter(
        Annotated[
            Union[N2VAlgorithm, N2NAlgorithm, CAREAlgorithm, PN2VAlgorithm],
            Field(discriminator="algorithm"),
        ]
    )
    return adapter.validate_python(algorithm)


def _list_spatial_augmentations(
    augmentations: list[SPATIAL_TRANSFORMS_UNION] | None = None,
) -> list[SPATIAL_TRANSFORMS_UNION]:
    """
    List the augmentations to apply.

    Parameters
    ----------
    augmentations : list of transforms, optional
        List of transforms to apply, either both or one of XYFlipConfig and
        XYRandomRotate90Config.

    Returns
    -------
    list of transforms
        List of transforms to apply.

    Raises
    ------
    ValueError
        If the transforms are not XYFlipConfig or XYRandomRotate90Config.
    ValueError
        If there are duplicate transforms.
    """
    if augmentations is None:
        transform_list: list[SPATIAL_TRANSFORMS_UNION] = [
            XYFlipConfig(),
            XYRandomRotate90Config(),
        ]
    else:
        # throw error if not all transforms are pydantic models
        if not all(
            isinstance(t, XYFlipConfig) or isinstance(t, XYRandomRotate90Config)
            for t in augmentations
        ):
            raise ValueError(
                "Accepted transforms are either XYFlipConfig or "
                "XYRandomRotate90Config."
            )

        # check that there is no duplication
        aug_types = [t.__class__ for t in augmentations]
        if len(set(aug_types)) != len(aug_types):
            raise ValueError("Duplicate transforms are not allowed.")

        transform_list = augmentations

    return transform_list


def _create_unet_configuration(
    axes: str,
    n_channels_in: int,
    n_channels_out: int,
    independent_channels: bool,
    use_n2v2: bool,
    model_params: dict[str, Any] | None = None,
) -> UNetConfig:
    """
    Create a dictionary with the parameters of the UNet model.

    Parameters
    ----------
    axes : str
        Axes of the data.
    n_channels_in : int
        Number of input channels.
    n_channels_out : int
        Number of output channels.
    independent_channels : bool
        Whether to train all channels independently.
    use_n2v2 : bool
        Whether to use N2V2.
    model_params : dict
        UNetModel parameters.

    Returns
    -------
    UNetModel
        UNet model with the specified parameters.
    """
    if model_params is None:
        model_params = {}

    model_params["n2v2"] = use_n2v2
    model_params["conv_dims"] = 3 if "Z" in axes else 2
    model_params["in_channels"] = n_channels_in
    model_params["num_classes"] = n_channels_out
    model_params["independent_channels"] = independent_channels

    return UNetConfig(
        architecture=SupportedArchitecture.UNET.value,
        **model_params,
    )


def _create_algorithm_configuration(
    axes: str,
    algorithm: Literal["n2v", "care", "n2n", "pn2v"],
    loss: Literal["n2v", "mae", "mse", "pn2v"],
    independent_channels: bool,
    n_channels_in: int,
    n_channels_out: int,
    use_n2v2: bool = False,
    model_params: dict | None = None,
    optimizer: Literal["Adam", "Adamax", "SGD"] = "Adam",
    optimizer_params: dict[str, Any] | None = None,
    lr_scheduler: Literal["ReduceLROnPlateau", "StepLR"] = "ReduceLROnPlateau",
    lr_scheduler_params: dict[str, Any] | None = None,
) -> dict:
    """
    Create a dictionary with the parameters of the algorithm model.

    Parameters
    ----------
    axes : str
        Axes of the data.
    algorithm : {"n2v", "care", "n2n", "pn2v"}
        Algorithm to use.
    loss : {"n2v", "mae", "mse", "pn2v"}
        Loss function to use.
    independent_channels : bool
        Whether to train all channels independently.
    n_channels_in : int
        Number of input channels.
    n_channels_out : int
        Number of output channels.
    use_n2v2 : bool, default=false
        Whether to use N2V2.
    model_params : dict, default=None
        UNetModel parameters.
    optimizer : {"Adam", "Adamax", "SGD"}, default="Adam"
        Optimizer to use.
    optimizer_params : dict, default=None
        Parameters for the optimizer, see PyTorch documentation for more details.
    lr_scheduler : {"ReduceLROnPlateau", "StepLR"}, default="ReduceLROnPlateau"
        Learning rate scheduler to use.
    lr_scheduler_params : dict, default=None
        Parameters for the learning rate scheduler, see PyTorch documentation for more
        details.


    Returns
    -------
    dict
        Algorithm model as dictionnary with the specified parameters.
    """
    # model
    unet_model = _create_unet_configuration(
        axes=axes,
        n_channels_in=n_channels_in,
        n_channels_out=n_channels_out,
        independent_channels=independent_channels,
        use_n2v2=use_n2v2,
        model_params=model_params,
    )

    return {
        "algorithm": algorithm,
        "loss": loss,
        "model": unet_model,
        "optimizer": {
            "name": optimizer,
            "parameters": {} if optimizer_params is None else optimizer_params,
        },
        "lr_scheduler": {
            "name": lr_scheduler,
            "parameters": {} if lr_scheduler_params is None else lr_scheduler_params,
        },
    }


def _create_data_configuration(
    data_type: Literal["array", "tiff", "czi", "custom"],
    axes: str,
    patch_size: Sequence[int],
    batch_size: int,
    augmentations: Union[list[SPATIAL_TRANSFORMS_UNION]],
    train_dataloader_params: dict[str, Any] | None = None,
    val_dataloader_params: dict[str, Any] | None = None,
) -> DataConfig:
    """
    Create a dictionary with the parameters of the data model.

    Parameters
    ----------
    data_type : {"array", "tiff", "czi", "custom"}
        Type of the data.
    axes : str
        Axes of the data.
    patch_size : list of int
        Size of the patches along the spatial dimensions.
    batch_size : int
        Batch size.
    augmentations : list of transforms
        List of transforms to apply.
    train_dataloader_params : dict
        Parameters for the training dataloader, see PyTorch notes, by default None.
    val_dataloader_params : dict
        Parameters for the validation dataloader, see PyTorch notes, by default None.

    Returns
    -------
    DataConfig
        Data model with the specified parameters.
    """
    # data model
    data = {
        "data_type": data_type,
        "axes": axes,
        "patch_size": patch_size,
        "batch_size": batch_size,
        "transforms": augmentations,
    }
    # Don't override defaults set in DataConfig class
    if train_dataloader_params is not None:
        # DataConfig enforces the presence of `shuffle` key in the dataloader parameters
        if "shuffle" not in train_dataloader_params:
            train_dataloader_params["shuffle"] = True

        data["train_dataloader_params"] = train_dataloader_params

    if val_dataloader_params is not None:
        data["val_dataloader_params"] = val_dataloader_params

    return DataConfig(**data)


def _create_microsplit_data_configuration(
    data_type: Literal["array", "tiff", "custom"],
    axes: str,
    patch_size: Sequence[int],
    grid_size: int,
    multiscale_count: int,
    batch_size: int,
    augmentations: Union[list[SPATIAL_TRANSFORMS_UNION]],
    train_dataloader_params: dict[str, Any] | None = None,
    val_dataloader_params: dict[str, Any] | None = None,
) -> DataConfig:
    """
    Create a dictionary with the parameters of the data model.

    Parameters
    ----------
    data_type : {"array", "tiff", "czi", "custom"}
        Type of the data.
    axes : str
        Axes of the data.
    patch_size : list of int
        Size of the patches along the spatial dimensions.
    grid_size : int
        Size of the grid for multiscale data configuration.
    multiscale_count : int
        Number of multiscale levels.
    batch_size : int
        Batch size.
    augmentations : list of transforms
        List of transforms to apply.
    train_dataloader_params : dict
        Parameters for the training dataloader, see PyTorch notes, by default None.
    val_dataloader_params : dict
        Parameters for the validation dataloader, see PyTorch notes, by default None.

    Returns
    -------
    DataConfig
        Data model with the specified parameters.
    """
    # data model
    data = {
        "data_type": data_type,
        "axes": axes,
        "image_size": patch_size,
        "grid_size": grid_size,
        "multiscale_lowres_count": multiscale_count,
        "batch_size": batch_size,
        "transforms": augmentations,
    }
    # Don't override defaults set in DataConfig class
    if train_dataloader_params is not None:
        # DataConfig enforces the presence of `shuffle` key in the dataloader parameters
        if "shuffle" not in train_dataloader_params:
            train_dataloader_params["shuffle"] = True

        data["train_dataloader_params"] = train_dataloader_params

    if val_dataloader_params is not None:
        data["val_dataloader_params"] = val_dataloader_params

    return MicroSplitDataConfig(**data)


def _create_training_configuration(
    trainer_params: dict,
    logger: Literal["wandb", "tensorboard", "none"],
    checkpoint_params: dict[str, Any] | None = None,
) -> TrainingConfig:
    """
    Create a dictionary with the parameters of the training model.

    Parameters
    ----------
    trainer_params : dict
        Parameters for Lightning Trainer class, see PyTorch Lightning documentation.
    logger : {"wandb", "tensorboard", "none"}
        Logger to use.
    checkpoint_params : dict, default=None
        Parameters for the checkpoint callback, see PyTorch Lightning documentation
        (`ModelCheckpoint`) for the list of available parameters.

    Returns
    -------
    TrainingConfig
        Training model with the specified parameters.
    """
    return TrainingConfig(
        lightning_trainer_config=trainer_params,
        logger=None if logger == "none" else logger,
        checkpoint_callback={} if checkpoint_params is None else checkpoint_params,
    )


def update_trainer_params(
    trainer_params: dict[str, Any] | None = None,
    num_epochs: int | None = None,
    num_steps: int | None = None,
) -> dict[str, Any]:
    """
    Update trainer parameters with num_epochs and num_steps.

    Parameters
    ----------
    trainer_params : dict, optional
        Parameters for Lightning Trainer class, by default None.
    num_epochs : int, optional
        Number of epochs to train for. If provided, this will be added as max_epochs
        to trainer_params, by default None.
    num_steps : int, optional
        Number of batches in 1 epoch. If provided, this will be added as
        limit_train_batches to trainer_params, by default None.

    Returns
    -------
    dict
        Updated trainer parameters dictionary.
    """
    final_trainer_params = {} if trainer_params is None else trainer_params.copy()

    if num_epochs is not None:
        final_trainer_params["max_epochs"] = num_epochs
    if num_steps is not None:
        final_trainer_params["limit_train_batches"] = num_steps

    return final_trainer_params


# TODO reconsider naming once we officially support LVAE approaches
def _create_supervised_config_dict(
    algorithm: Literal["care", "n2n"],
    experiment_name: str,
    data_type: Literal["array", "tiff", "czi", "custom"],
    axes: str,
    patch_size: Sequence[int],
    batch_size: int,
    trainer_params: dict | None = None,
    augmentations: list[SPATIAL_TRANSFORMS_UNION] | None = None,
    independent_channels: bool = True,
    loss: Literal["mae", "mse"] = "mae",
    n_channels_in: int | None = None,
    n_channels_out: int | None = None,
    logger: Literal["wandb", "tensorboard", "none"] = "none",
    model_params: dict | None = None,
    optimizer: Literal["Adam", "Adamax", "SGD"] = "Adam",
    optimizer_params: dict[str, Any] | None = None,
    lr_scheduler: Literal["ReduceLROnPlateau", "StepLR"] = "ReduceLROnPlateau",
    lr_scheduler_params: dict[str, Any] | None = None,
    train_dataloader_params: dict[str, Any] | None = None,
    val_dataloader_params: dict[str, Any] | None = None,
    checkpoint_params: dict[str, Any] | None = None,
    num_epochs: int | None = None,
    num_steps: int | None = None,
) -> dict:
    """
    Create a configuration for training CARE or Noise2Noise.

    Parameters
    ----------
    algorithm : Literal["care", "n2n"]
        Algorithm to use.
    experiment_name : str
        Name of the experiment.
    data_type : Literal["array", "tiff", "czi", "custom"]
        Type of the data.
    axes : str
        Axes of the data (e.g. SYX).
    patch_size : List[int]
        Size of the patches along the spatial dimensions (e.g. [64, 64]).
    batch_size : int
        Batch size.
    trainer_params : dict
        Parameters for the training configuration.
    augmentations : list of transforms, default=None
        List of transforms to apply, either both or one of XYFlipConfig and
        XYRandomRotate90Config. By default, it applies both XYFlip (on X and Y)
        and XYRandomRotate90 (in XY) to the images.
    independent_channels : bool, optional
        Whether to train all channels independently, by default False.
    loss : Literal["mae", "mse"], optional
        Loss function to use, by default "mae".
    n_channels_in : int or None, default=None
        Number of channels in.
    n_channels_out : int or None, default=None
        Number of channels out.
    logger : Literal["wandb", "tensorboard", "none"], optional
        Logger to use, by default "none".
    model_params : dict, default=None
        UNetModel parameters.
    optimizer : {"Adam", "Adamax", "SGD"}, default="Adam"
        Optimizer to use.
    optimizer_params : dict, default=None
        Parameters for the optimizer, see PyTorch documentation for more details.
    lr_scheduler : {"ReduceLROnPlateau", "StepLR"}, default="ReduceLROnPlateau"
        Learning rate scheduler to use.
    lr_scheduler_params : dict, default=None
        Parameters for the learning rate scheduler, see PyTorch documentation for more
        details.
    train_dataloader_params : dict
        Parameters for the training dataloader, see PyTorch notes, by default None.
    val_dataloader_params : dict
        Parameters for the validation dataloader, see PyTorch notes, by default None.
    checkpoint_params : dict, default=None
        Parameters for the checkpoint callback, see PyTorch Lightning documentation
        (`ModelCheckpoint`) for the list of available parameters.
    num_epochs : int or None, default=None
        Number of epochs to train for. If provided, this will be added to
        trainer_params.
    num_steps : int or None, default=None
        Number of batches in 1 epoch. If provided, this will be added to trainer_params.
        Translates to `limit_train_batches` in PyTorch Lightning Trainer. See relevant
        documentation for more details.

    Returns
    -------
    Configuration
        Configuration for training CARE or Noise2Noise.

    Raises
    ------
    ValueError
        If the number of channels is not specified when using channels.
    ValueError
        If the number of channels is specified but "C" is not in the axes.
    """
    # if there are channels, we need to specify their number
    if "C" in axes and n_channels_in is None:
        raise ValueError("Number of channels in must be specified when using channels ")
    elif "C" not in axes and (n_channels_in is not None and n_channels_in > 1):
        raise ValueError(
            f"C is not present in the axes, but number of channels is specified "
            f"(got {n_channels_in} channels)."
        )

    if n_channels_in is None:
        n_channels_in = 1

    if n_channels_out is None:
        n_channels_out = n_channels_in

    # augmentations
    spatial_transform_list = _list_spatial_augmentations(augmentations)

    # algorithm
    algorithm_params = _create_algorithm_configuration(
        axes=axes,
        algorithm=algorithm,
        loss=loss,
        independent_channels=independent_channels,
        n_channels_in=n_channels_in,
        n_channels_out=n_channels_out,
        model_params=model_params,
        optimizer=optimizer,
        optimizer_params=optimizer_params,
        lr_scheduler=lr_scheduler,
        lr_scheduler_params=lr_scheduler_params,
    )

    # data
    data_params = _create_data_configuration(
        data_type=data_type,
        axes=axes,
        patch_size=patch_size,
        batch_size=batch_size,
        augmentations=spatial_transform_list,
        train_dataloader_params=train_dataloader_params,
        val_dataloader_params=val_dataloader_params,
    )

    # training
    final_trainer_params = update_trainer_params(
        trainer_params=trainer_params,
        num_epochs=num_epochs,
        num_steps=num_steps,
    )
    training_params = _create_training_configuration(
        trainer_params=final_trainer_params,
        logger=logger,
        checkpoint_params=checkpoint_params,
    )

    return {
        "experiment_name": experiment_name,
        "algorithm_config": algorithm_params,
        "data_config": data_params,
        "training_config": training_params,
    }


def create_care_configuration(
    experiment_name: str,
    data_type: Literal["array", "tiff", "czi", "custom"],
    axes: str,
    patch_size: Sequence[int],
    batch_size: int,
    num_epochs: int = 100,
    num_steps: int | None = None,
    augmentations: list[Union[XYFlipConfig, XYRandomRotate90Config]] | None = None,
    independent_channels: bool = True,
    loss: Literal["mae", "mse"] = "mae",
    n_channels_in: int | None = None,
    n_channels_out: int | None = None,
    logger: Literal["wandb", "tensorboard", "none"] = "none",
    trainer_params: dict | None = None,
    model_params: dict | None = None,
    optimizer: Literal["Adam", "Adamax", "SGD"] = "Adam",
    optimizer_params: dict[str, Any] | None = None,
    lr_scheduler: Literal["ReduceLROnPlateau", "StepLR"] = "ReduceLROnPlateau",
    lr_scheduler_params: dict[str, Any] | None = None,
    train_dataloader_params: dict[str, Any] | None = None,
    val_dataloader_params: dict[str, Any] | None = None,
    checkpoint_params: dict[str, Any] | None = None,
) -> Configuration:
    """
    Create a configuration for training CARE.

    If "Z" is present in `axes`, then `patch_size` must be a list of length 3, otherwise
    2.

    If "C" is present in `axes`, then you need to set `n_channels_in` to the number of
    channels. Likewise, if you set the number of channels, then "C" must be present in
    `axes`.

    To set the number of output channels, use the `n_channels_out` parameter. If it is
    not specified, it will be assumed to be equal to `n_channels_in`.

    By default, all channels are trained together. To train all channels independently,
    set `independent_channels` to True.

    By setting `augmentations` to `None`, the default transformations (flip in X and Y,
    rotations by 90 degrees in the XY plane) are applied. Rather than the default
    transforms, a list of transforms can be passed to the `augmentations` parameter. To
    disable the transforms, simply pass an empty list.

    Parameters
    ----------
    experiment_name : str
        Name of the experiment.
    data_type : Literal["array", "tiff", "czi", "custom"]
        Type of the data.
    axes : str
        Axes of the data (e.g. SYX).
    patch_size : List[int]
        Size of the patches along the spatial dimensions (e.g. [64, 64]).
    batch_size : int
        Batch size.
    num_epochs : int, default=100
        Number of epochs to train for. If provided, this will be added to
        trainer_params.
    num_steps : int, optional
        Number of batches in 1 epoch. If provided, this will be added to trainer_params.
        Translates to `limit_train_batches` in PyTorch Lightning Trainer. See relevant
        documentation for more details.
    augmentations : list of transforms, default=None
        List of transforms to apply, either both or one of XYFlipConfig and
        XYRandomRotate90Config. By default, it applies both XYFlip (on X and Y)
        and XYRandomRotate90 (in XY) to the images.
    independent_channels : bool, optional
        Whether to train all channels independently, by default False.
    loss : Literal["mae", "mse"], default="mae"
        Loss function to use.
    n_channels_in : int or None, default=None
        Number of channels in.
    n_channels_out : int or None, default=None
        Number of channels out.
    logger : Literal["wandb", "tensorboard", "none"], default="none"
        Logger to use.
    trainer_params : dict, optional
        Parameters for the trainer class, see PyTorch Lightning documentation.
    model_params : dict, default=None
        UNetModel parameters.
    optimizer : Literal["Adam", "Adamax", "SGD"], default="Adam"
        Optimizer to use.
    optimizer_params : dict, default=None
        Parameters for the optimizer, see PyTorch documentation for more details.
    lr_scheduler : Literal["ReduceLROnPlateau", "StepLR"], default="ReduceLROnPlateau"
        Learning rate scheduler to use.
    lr_scheduler_params : dict, default=None
        Parameters for the learning rate scheduler, see PyTorch documentation for more
        details.
    train_dataloader_params : dict, optional
        Parameters for the training dataloader, see the PyTorch docs for `DataLoader`.
        If left as `None`, the dict `{"shuffle": True}` will be used, this is set in
        the `GeneralDataConfig`.
    val_dataloader_params : dict, optional
        Parameters for the validation dataloader, see PyTorch the docs for `DataLoader`.
        If left as `None`, the empty dict `{}` will be used, this is set in the
        `GeneralDataConfig`.
    checkpoint_params : dict, default=None
        Parameters for the checkpoint callback, see PyTorch Lightning documentation
        (`ModelCheckpoint`) for the list of available parameters.

    Returns
    -------
    Configuration
        Configuration for training CARE.

    Examples
    --------
    Minimum example:
    >>> config = create_care_configuration(
    ...     experiment_name="care_experiment",
    ...     data_type="array",
    ...     axes="YX",
    ...     patch_size=[64, 64],
    ...     batch_size=32,
    ...     num_epochs=100
    ... )

    You can also limit the number of batches per epoch:
    >>> config = create_care_configuration(
    ...     experiment_name="care_experiment",
    ...     data_type="array",
    ...     axes="YX",
    ...     patch_size=[64, 64],
    ...     batch_size=32,
    ...     num_steps=100  # limit to 100 batches per epoch
    ... )

    To disable transforms, simply set `augmentations` to an empty list:
    >>> config = create_care_configuration(
    ...     experiment_name="care_experiment",
    ...     data_type="array",
    ...     axes="YX",
    ...     patch_size=[64, 64],
    ...     batch_size=32,
    ...     num_epochs=100,
    ...     augmentations=[]
    ... )

    A list of transforms can be passed to the `augmentations` parameter to replace the
    default augmentations:
    >>> from careamics.config.transformations import XYFlipConfig
    >>> config = create_care_configuration(
    ...     experiment_name="care_experiment",
    ...     data_type="array",
    ...     axes="YX",
    ...     patch_size=[64, 64],
    ...     batch_size=32,
    ...     num_epochs=100,
    ...     augmentations=[
    ...         # No rotation and only Y flipping
    ...         XYFlipConfig(flip_x = False, flip_y = True)
    ...     ]
    ... )

    If you are training multiple channels they will be trained independently by default,
    you simply need to specify the number of channels input (and optionally, the number
    of channels output):
    >>> config = create_care_configuration(
    ...     experiment_name="care_experiment",
    ...     data_type="array",
    ...     axes="YXC", # channels must be in the axes
    ...     patch_size=[64, 64],
    ...     batch_size=32,
    ...     num_epochs=100,
    ...     n_channels_in=3, # number of input channels
    ...     n_channels_out=1 # if applicable
    ... )

    If instead you want to train multiple channels together, you need to turn off the
    `independent_channels` parameter:
    >>> config = create_care_configuration(
    ...     experiment_name="care_experiment",
    ...     data_type="array",
    ...     axes="YXC", # channels must be in the axes
    ...     patch_size=[64, 64],
    ...     batch_size=32,
    ...     num_epochs=100,
    ...     independent_channels=False,
    ...     n_channels_in=3,
    ...     n_channels_out=1 # if applicable
    ... )

    If you would like to train on CZI files, use `"czi"` as `data_type` and `"SCYX"` as
    `axes` for 2-D or `"SCZYX"` for 3-D denoising. Note that `"SCYX"` can also be used
    for 3-D data but spatial context along the Z dimension will then not be taken into
    account.
    >>> config_2d = create_care_configuration(
    ...     experiment_name="care_experiment",
    ...     data_type="czi",
    ...     axes="SCYX",
    ...     patch_size=[64, 64],
    ...     batch_size=32,
    ...     num_epochs=100,
    ...     n_channels_in=1,
    ... )
    >>> config_3d = create_care_configuration(
    ...     experiment_name="care_experiment",
    ...     data_type="czi",
    ...     axes="SCZYX",
    ...     patch_size=[16, 64, 64],
    ...     batch_size=16,
    ...     num_epochs=100,
    ...     n_channels_in=1,
    ... )
    """
    return Configuration(
        **_create_supervised_config_dict(
            algorithm="care",
            experiment_name=experiment_name,
            data_type=data_type,
            axes=axes,
            patch_size=patch_size,
            batch_size=batch_size,
            augmentations=augmentations,
            independent_channels=independent_channels,
            loss=loss,
            n_channels_in=n_channels_in,
            n_channels_out=n_channels_out,
            logger=logger,
            trainer_params=trainer_params,
            model_params=model_params,
            optimizer=optimizer,
            optimizer_params=optimizer_params,
            lr_scheduler=lr_scheduler,
            lr_scheduler_params=lr_scheduler_params,
            train_dataloader_params=train_dataloader_params,
            val_dataloader_params=val_dataloader_params,
            checkpoint_params=checkpoint_params,
            num_epochs=num_epochs,
            num_steps=num_steps,
        )
    )


def create_n2n_configuration(
    experiment_name: str,
    data_type: Literal["array", "tiff", "czi", "custom"],
    axes: str,
    patch_size: Sequence[int],
    batch_size: int,
    num_epochs: int = 100,
    num_steps: int | None = None,
    augmentations: list[Union[XYFlipConfig, XYRandomRotate90Config]] | None = None,
    independent_channels: bool = True,
    loss: Literal["mae", "mse"] = "mae",
    n_channels_in: int | None = None,
    n_channels_out: int | None = None,
    logger: Literal["wandb", "tensorboard", "none"] = "none",
    trainer_params: dict | None = None,
    model_params: dict | None = None,
    optimizer: Literal["Adam", "Adamax", "SGD"] = "Adam",
    optimizer_params: dict[str, Any] | None = None,
    lr_scheduler: Literal["ReduceLROnPlateau", "StepLR"] = "ReduceLROnPlateau",
    lr_scheduler_params: dict[str, Any] | None = None,
    train_dataloader_params: dict[str, Any] | None = None,
    val_dataloader_params: dict[str, Any] | None = None,
    checkpoint_params: dict[str, Any] | None = None,
) -> Configuration:
    """
    Create a configuration for training Noise2Noise.

    If "Z" is present in `axes`, then `patch_size` must be a list of length 3, otherwise
    2.

    If "C" is present in `axes`, then you need to set `n_channels_in` to the number of
    channels. Likewise, if you set the number of channels, then "C" must be present in
    `axes`.

    To set the number of output channels, use the `n_channels_out` parameter. If it is
    not specified, it will be assumed to be equal to `n_channels_in`.

    By default, all channels are trained together. To train all channels independently,
    set `independent_channels` to True.

    By setting `augmentations` to `None`, the default transformations (flip in X and Y,
    rotations by 90 degrees in the XY plane) are applied. Rather than the default
    transforms, a list of transforms can be passed to the `augmentations` parameter. To
    disable the transforms, simply pass an empty list.

    Parameters
    ----------
    experiment_name : str
        Name of the experiment.
    data_type : Literal["array", "tiff", "czi", "custom"]
        Type of the data.
    axes : str
        Axes of the data (e.g. SYX).
    patch_size : List[int]
        Size of the patches along the spatial dimensions (e.g. [64, 64]).
    batch_size : int
        Batch size.
    num_epochs : int, default=100
        Number of epochs to train for. If provided, this will be added to
        trainer_params.
    num_steps : int, optional
        Number of batches in 1 epoch. If provided, this will be added to trainer_params.
        Translates to `limit_train_batches` in PyTorch Lightning Trainer. See relevant
        documentation for more details.
    augmentations : list of transforms, default=None
        List of transforms to apply, either both or one of XYFlipConfig and
        XYRandomRotate90Config. By default, it applies both XYFlip (on X and Y)
        and XYRandomRotate90 (in XY) to the images.
    independent_channels : bool, optional
        Whether to train all channels independently, by default False.
    loss : Literal["mae", "mse"], optional
        Loss function to use, by default "mae".
    n_channels_in : int or None, default=None
        Number of channels in.
    n_channels_out : int or None, default=None
        Number of channels out.
    logger : Literal["wandb", "tensorboard", "none"], optional
        Logger to use, by default "none".
    trainer_params : dict, optional
        Parameters for the trainer class, see PyTorch Lightning documentation.
    model_params : dict, default=None
        UNetModel parameters.
    optimizer : Literal["Adam", "Adamax", "SGD"], default="Adam"
        Optimizer to use.
    optimizer_params : dict, default=None
        Parameters for the optimizer, see PyTorch documentation for more details.
    lr_scheduler : Literal["ReduceLROnPlateau", "StepLR"], default="ReduceLROnPlateau"
        Learning rate scheduler to use.
    lr_scheduler_params : dict, default=None
        Parameters for the learning rate scheduler, see PyTorch documentation for more
        details.
    train_dataloader_params : dict, optional
        Parameters for the training dataloader, see the PyTorch docs for `DataLoader`.
        If left as `None`, the dict `{"shuffle": True}` will be used, this is set in
        the `GeneralDataConfig`.
    val_dataloader_params : dict, optional
        Parameters for the validation dataloader, see PyTorch the docs for `DataLoader`.
        If left as `None`, the empty dict `{}` will be used, this is set in the
        `GeneralDataConfig`.
    checkpoint_params : dict, default=None
        Parameters for the checkpoint callback, see PyTorch Lightning documentation
        (`ModelCheckpoint`) for the list of available parameters.

    Returns
    -------
    Configuration
        Configuration for training Noise2Noise.

    Examples
    --------
    Minimum example:
    >>> config = create_n2n_configuration(
    ...     experiment_name="n2n_experiment",
    ...     data_type="array",
    ...     axes="YX",
    ...     patch_size=[64, 64],
    ...     batch_size=32,
    ...     num_epochs=100
    ... )

    You can also limit the number of batches per epoch:
    >>> config = create_n2n_configuration(
    ...     experiment_name="n2n_experiment",
    ...     data_type="array",
    ...     axes="YX",
    ...     patch_size=[64, 64],
    ...     batch_size=32,
    ...     num_steps=100  # limit to 100 batches per epoch
    ... )

    To disable transforms, simply set `augmentations` to an empty list:
    >>> config = create_n2n_configuration(
    ...     experiment_name="n2n_experiment",
    ...     data_type="array",
    ...     axes="YX",
    ...     patch_size=[64, 64],
    ...     batch_size=32,
    ...     num_epochs=100,
    ...     augmentations=[]
    ... )

    A list of transforms can be passed to the `augmentations` parameter:
    >>> from careamics.config.transformations import XYFlipConfig
    >>> config = create_n2n_configuration(
    ...     experiment_name="n2n_experiment",
    ...     data_type="array",
    ...     axes="YX",
    ...     patch_size=[64, 64],
    ...     batch_size=32,
    ...     num_epochs=100,
    ...     augmentations=[
    ...         # No rotation and only Y flipping
    ...         XYFlipConfig(flip_x = False, flip_y = True)
    ...     ]
    ... )

    If you are training multiple channels they will be trained independently by default,
    you simply need to specify the number of channels input (and optionally, the number
    of channels output):
    >>> config = create_n2n_configuration(
    ...     experiment_name="n2n_experiment",
    ...     data_type="array",
    ...     axes="YXC", # channels must be in the axes
    ...     patch_size=[64, 64],
    ...     batch_size=32,
    ...     num_epochs=100,
    ...     n_channels_in=3, # number of input channels
    ...     n_channels_out=1 # if applicable
    ... )

    If instead you want to train multiple channels together, you need to turn off the
    `independent_channels` parameter:
    >>> config = create_n2n_configuration(
    ...     experiment_name="n2n_experiment",
    ...     data_type="array",
    ...     axes="YXC", # channels must be in the axes
    ...     patch_size=[64, 64],
    ...     batch_size=32,
    ...     num_epochs=100,
    ...     independent_channels=False,
    ...     n_channels_in=3,
    ...     n_channels_out=1 # if applicable
    ... )

    If you would like to train on CZI files, use `"czi"` as `data_type` and `"SCYX"` as
    `axes` for 2-D or `"SCZYX"` for 3-D denoising. Note that `"SCYX"` can also be used
    for 3-D data but spatial context along the Z dimension will then not be taken into
    account.
    >>> config_2d = create_n2n_configuration(
    ...     experiment_name="n2n_experiment",
    ...     data_type="czi",
    ...     axes="SCYX",
    ...     patch_size=[64, 64],
    ...     batch_size=32,
    ...     num_epochs=100,
    ...     n_channels_in=1,
    ... )
    >>> config_3d = create_n2n_configuration(
    ...     experiment_name="n2n_experiment",
    ...     data_type="czi",
    ...     axes="SCZYX",
    ...     patch_size=[16, 64, 64],
    ...     batch_size=16,
    ...     num_epochs=100,
    ...     n_channels_in=1,
    ... )
    """
    return Configuration(
        **_create_supervised_config_dict(
            algorithm="n2n",
            experiment_name=experiment_name,
            data_type=data_type,
            axes=axes,
            patch_size=patch_size,
            batch_size=batch_size,
            trainer_params=trainer_params,
            augmentations=augmentations,
            independent_channels=independent_channels,
            loss=loss,
            n_channels_in=n_channels_in,
            n_channels_out=n_channels_out,
            logger=logger,
            model_params=model_params,
            optimizer=optimizer,
            optimizer_params=optimizer_params,
            lr_scheduler=lr_scheduler,
            lr_scheduler_params=lr_scheduler_params,
            train_dataloader_params=train_dataloader_params,
            val_dataloader_params=val_dataloader_params,
            checkpoint_params=checkpoint_params,
            num_epochs=num_epochs,
            num_steps=num_steps,
        )
    )


def create_n2v_configuration(
    experiment_name: str,
    data_type: Literal["array", "tiff", "czi", "custom"],
    axes: str,
    patch_size: Sequence[int],
    batch_size: int,
    num_epochs: int = 100,
    num_steps: int | None = None,
    augmentations: list[Union[XYFlipConfig, XYRandomRotate90Config]] | None = None,
    independent_channels: bool = True,
    use_n2v2: bool = False,
    n_channels: int | None = None,
    roi_size: int = 11,
    masked_pixel_percentage: float = 0.2,
    struct_n2v_axis: Literal["horizontal", "vertical", "none"] = "none",
    struct_n2v_span: int = 5,
    trainer_params: dict | None = None,
    logger: Literal["wandb", "tensorboard", "none"] = "none",
    model_params: dict | None = None,
    optimizer: Literal["Adam", "Adamax", "SGD"] = "Adam",
    optimizer_params: dict[str, Any] | None = None,
    lr_scheduler: Literal["ReduceLROnPlateau", "StepLR"] = "ReduceLROnPlateau",
    lr_scheduler_params: dict[str, Any] | None = None,
    train_dataloader_params: dict[str, Any] | None = None,
    val_dataloader_params: dict[str, Any] | None = None,
    checkpoint_params: dict[str, Any] | None = None,
) -> Configuration:
    """
    Create a configuration for training Noise2Void.

    N2V uses a UNet model to denoise images in a self-supervised manner. To use its
    variants structN2V and N2V2, set the `struct_n2v_axis` and `struct_n2v_span`
    (structN2V) parameters, or set `use_n2v2` to True (N2V2).

    N2V2 modifies the UNet architecture by adding blur pool layers and removes the skip
    connections, thus removing checkboard artefacts. StructN2V is used when vertical
    or horizontal correlations are present in the noise; it applies an additional mask
    to the manipulated pixel neighbors.

    If "Z" is present in `axes`, then `patch_size` must be a list of length 3, otherwise
    2.

    If "C" is present in `axes`, then you need to set `n_channels` to the number of
    channels.

    By default, all channels are trained independently. To train all channels together,
    set `independent_channels` to False.

    By default, the transformations applied are a random flip along X or Y, and a random
    90 degrees rotation in the XY plane. Normalization is always applied, as well as the
    N2V manipulation.

    By setting `augmentations` to `None`, the default transformations (flip in X and Y,
    rotations by 90 degrees in the XY plane) are applied. Rather than the default
    transforms, a list of transforms can be passed to the `augmentations` parameter. To
    disable the transforms, simply pass an empty list.

    The `roi_size` parameter specifies the size of the area around each pixel that will
    be manipulated by N2V. The `masked_pixel_percentage` parameter specifies how many
    pixels per patch will be manipulated.

    The parameters of the UNet can be specified in the `model_params` (passed as a
    parameter-value dictionary). Note that `use_n2v2` and 'n_channels' override the
    corresponding parameters passed in `model_params`.

    If you pass "horizontal" or "vertical" to `struct_n2v_axis`, then structN2V mask
    will be applied to each manipulated pixel.

    Parameters
    ----------
    experiment_name : str
        Name of the experiment.
    data_type : Literal["array", "tiff", "czi", "custom"]
        Type of the data.
    axes : str
        Axes of the data (e.g. SYX).
    patch_size : List[int]
        Size of the patches along the spatial dimensions (e.g. [64, 64]).
    batch_size : int
        Batch size.
    num_epochs : int, default=100
        Number of epochs to train for. If provided, this will be added to
        trainer_params.
    num_steps : int, optional
        Number of batches in 1 epoch. If provided, this will be added to trainer_params.
        Translates to `limit_train_batches` in PyTorch Lightning Trainer. See relevant
        documentation for more details.
    augmentations : list of transforms, default=None
        List of transforms to apply, either both or one of XYFlipConfig and
        XYRandomRotate90Config. By default, it applies both XYFlip (on X and Y)
        and XYRandomRotate90 (in XY) to the images.
    independent_channels : bool, optional
        Whether to train all channels together, by default True.
    use_n2v2 : bool, optional
        Whether to use N2V2, by default False.
    n_channels : int or None, default=None
        Number of channels (in and out).
    roi_size : int, optional
        N2V pixel manipulation area, by default 11.
    masked_pixel_percentage : float, optional
        Percentage of pixels masked in each patch, by default 0.2.
    struct_n2v_axis : Literal["horizontal", "vertical", "none"], optional
        Axis along which to apply structN2V mask, by default "none".
    struct_n2v_span : int, optional
        Span of the structN2V mask, by default 5.
    trainer_params : dict, optional
        Parameters for the trainer, see the relevant documentation.
    logger : Literal["wandb", "tensorboard", "none"], optional
        Logger to use, by default "none".
    model_params : dict, default=None
        UNetModel parameters.
    optimizer : Literal["Adam", "Adamax", "SGD"], default="Adam"
        Optimizer to use.
    optimizer_params : dict, default=None
        Parameters for the optimizer, see PyTorch documentation for more details.
    lr_scheduler : Literal["ReduceLROnPlateau", "StepLR"], default="ReduceLROnPlateau"
        Learning rate scheduler to use.
    lr_scheduler_params : dict, default=None
        Parameters for the learning rate scheduler, see PyTorch documentation for more
        details.
    train_dataloader_params : dict, optional
        Parameters for the training dataloader, see the PyTorch docs for `DataLoader`.
        If left as `None`, the dict `{"shuffle": True}` will be used, this is set in
        the `GeneralDataConfig`.
    val_dataloader_params : dict, optional
        Parameters for the validation dataloader, see PyTorch the docs for `DataLoader`.
        If left as `None`, the empty dict `{}` will be used, this is set in the
        `GeneralDataConfig`.
    checkpoint_params : dict, default=None
        Parameters for the checkpoint callback, see PyTorch Lightning documentation
        (`ModelCheckpoint`) for the list of available parameters.

    Returns
    -------
    Configuration
        Configuration for training N2V.

    Examples
    --------
    Minimum example:
    >>> config = create_n2v_configuration(
    ...     experiment_name="n2v_experiment",
    ...     data_type="array",
    ...     axes="YX",
    ...     patch_size=[64, 64],
    ...     batch_size=32,
    ...     num_epochs=100
    ... )

    You can also limit the number of batches per epoch:
    >>> config = create_n2v_configuration(
    ...     experiment_name="n2v_experiment",
    ...     data_type="array",
    ...     axes="YX",
    ...     patch_size=[64, 64],
    ...     batch_size=32,
    ...     num_steps=100  # limit to 100 batches per epoch
    ... )

    To disable transforms, simply set `augmentations` to an empty list:
    >>> config = create_n2v_configuration(
    ...     experiment_name="n2v_experiment",
    ...     data_type="array",
    ...     axes="YX",
    ...     patch_size=[64, 64],
    ...     batch_size=32,
    ...     num_epochs=100,
    ...     augmentations=[]
    ... )

    A list of transforms can be passed to the `augmentations` parameter:
    >>> from careamics.config.transformations import XYFlipConfig
    >>> config = create_n2v_configuration(
    ...     experiment_name="n2v_experiment",
    ...     data_type="array",
    ...     axes="YX",
    ...     patch_size=[64, 64],
    ...     batch_size=32,
    ...     num_epochs=100,
    ...     augmentations=[
    ...         # No rotation and only Y flipping
    ...         XYFlipConfig(flip_x = False, flip_y = True)
    ...     ]
    ... )

    To use N2V2, simply pass the `use_n2v2` parameter:
    >>> config = create_n2v_configuration(
    ...     experiment_name="n2v2_experiment",
    ...     data_type="tiff",
    ...     axes="YX",
    ...     patch_size=[64, 64],
    ...     batch_size=32,
    ...     num_epochs=100,
    ...     use_n2v2=True
    ... )

    For structN2V, there are two parameters to set, `struct_n2v_axis` and
    `struct_n2v_span`:
    >>> config = create_n2v_configuration(
    ...     experiment_name="structn2v_experiment",
    ...     data_type="tiff",
    ...     axes="YX",
    ...     patch_size=[64, 64],
    ...     batch_size=32,
    ...     num_epochs=100,
    ...     struct_n2v_axis="horizontal",
    ...     struct_n2v_span=7
    ... )

    If you are training multiple channels they will be trained independently by default,
    you simply need to specify the number of channels:
    >>> config = create_n2v_configuration(
    ...     experiment_name="n2v_experiment",
    ...     data_type="array",
    ...     axes="YXC",
    ...     patch_size=[64, 64],
    ...     batch_size=32,
    ...     num_epochs=100,
    ...     n_channels=3
    ... )

    If instead you want to train multiple channels together, you need to turn off the
    `independent_channels` parameter:
    >>> config = create_n2v_configuration(
    ...     experiment_name="n2v_experiment",
    ...     data_type="array",
    ...     axes="YXC",
    ...     patch_size=[64, 64],
    ...     batch_size=32,
    ...     num_epochs=100,
    ...     independent_channels=False,
    ...     n_channels=3
    ... )

    If you would like to train on CZI files, use `"czi"` as `data_type` and `"SCYX"` as
    `axes` for 2-D or `"SCZYX"` for 3-D denoising. Note that `"SCYX"` can also be used
    for 3-D data but spatial context along the Z dimension will then not be taken into
    account.
    >>> config_2d = create_n2v_configuration(
    ...     experiment_name="n2v_experiment",
    ...     data_type="czi",
    ...     axes="SCYX",
    ...     patch_size=[64, 64],
    ...     batch_size=32,
    ...     num_epochs=100,
    ...     n_channels=1,
    ... )
    >>> config_3d = create_n2v_configuration(
    ...     experiment_name="n2v_experiment",
    ...     data_type="czi",
    ...     axes="SCZYX",
    ...     patch_size=[16, 64, 64],
    ...     batch_size=16,
    ...     num_epochs=100,
    ...     n_channels=1,
    ... )
    """
    # if there are channels, we need to specify their number
    if "C" in axes and n_channels is None:
        raise ValueError("Number of channels must be specified when using channels.")
    elif "C" not in axes and (n_channels is not None and n_channels > 1):
        raise ValueError(
            f"C is not present in the axes, but number of channels is specified "
            f"(got {n_channels} channel)."
        )

    if n_channels is None:
        n_channels = 1

    # augmentations
    spatial_transforms = _list_spatial_augmentations(augmentations)

    # create the N2VManipulate transform using the supplied parameters
    n2v_transform = N2VManipulateConfig(
        name=SupportedTransform.N2V_MANIPULATE.value,
        strategy=(
            SupportedPixelManipulation.MEDIAN.value
            if use_n2v2
            else SupportedPixelManipulation.UNIFORM.value
        ),
        roi_size=roi_size,
        masked_pixel_percentage=masked_pixel_percentage,
        struct_mask_axis=struct_n2v_axis,
        struct_mask_span=struct_n2v_span,
    )

    # algorithm
    algorithm_params = _create_algorithm_configuration(
        axes=axes,
        algorithm="n2v",
        loss="n2v",
        independent_channels=independent_channels,
        n_channels_in=n_channels,
        n_channels_out=n_channels,
        use_n2v2=use_n2v2,
        model_params=model_params,
        optimizer=optimizer,
        optimizer_params=optimizer_params,
        lr_scheduler=lr_scheduler,
        lr_scheduler_params=lr_scheduler_params,
    )
    algorithm_params["n2v_config"] = n2v_transform

    # data
    data_params = _create_data_configuration(
        data_type=data_type,
        axes=axes,
        patch_size=patch_size,
        batch_size=batch_size,
        augmentations=spatial_transforms,
        train_dataloader_params=train_dataloader_params,
        val_dataloader_params=val_dataloader_params,
    )

    # training
    final_trainer_params = update_trainer_params(
        trainer_params=trainer_params,
        num_epochs=num_epochs,
        num_steps=num_steps,
    )
    training_params = _create_training_configuration(
        trainer_params=final_trainer_params,
        logger=logger,
        checkpoint_params=checkpoint_params,
    )

    return Configuration(
        experiment_name=experiment_name,
        algorithm_config=algorithm_params,
        data_config=data_params,
        training_config=training_params,
    )


def _create_vae_configuration(
    input_shape: Sequence[int],
    encoder_conv_strides: tuple[int, ...],
    decoder_conv_strides: tuple[int, ...],
    multiscale_count: int,
    z_dims: tuple[int, ...],
    output_channels: int,
    encoder_n_filters: int,
    decoder_n_filters: int,
    encoder_dropout: float,
    decoder_dropout: float,
    nonlinearity: Literal[
        "None", "Sigmoid", "Softmax", "Tanh", "ReLU", "LeakyReLU", "ELU"
    ],
    predict_logvar: Literal[None, "pixelwise"],
    analytical_kl: bool,
) -> LVAEConfig:
    """Create a dictionary with the parameters of the vae based algorithm model.

    Parameters
    ----------
    input_shape : tuple[int, ...]
        Shape of the input patch (Z, Y, X) or (Y, X) if the data is 2D.
    encoder_conv_strides : tuple[int, ...]
        Strides of the encoder convolutional layers, length also defines 2D or 3D.
    decoder_conv_strides : tuple[int, ...]
        Strides of the decoder convolutional layers, length also defines 2D or 3D.
    multiscale_count : int
        Number of lateral context layers, specific to MicroSplit.
    z_dims : tuple[int, ...]
        Number of hierarchies in the LVAE model.
    output_channels : int
        Number of output channels.
    encoder_n_filters : int
        Number of filters in the convolutional layers of the encoder.
    decoder_n_filters : int
        Number of filters in the convolutional layers of the decoder.
    encoder_dropout : float
        Dropout rate for the encoder.
    decoder_dropout : float
        Dropout rate for the decoder.
    nonlinearity : Literal
        Type of nonlinearity function to use.
    predict_logvar : Literal # TODO needs review
        _description_.
    analytical_kl : bool # TODO needs clarification
        _description_.

    Returns
    -------
    LVAEModel
        LVAE model with the specified parameters.
    """
    return LVAEConfig(
        architecture=SupportedArchitecture.LVAE.value,
        input_shape=input_shape,
        encoder_conv_strides=encoder_conv_strides,
        decoder_conv_strides=decoder_conv_strides,
        multiscale_count=multiscale_count,
        z_dims=z_dims,
        output_channels=output_channels,
        encoder_n_filters=encoder_n_filters,
        decoder_n_filters=decoder_n_filters,
        encoder_dropout=encoder_dropout,
        decoder_dropout=decoder_dropout,
        nonlinearity=nonlinearity,
        predict_logvar=predict_logvar,
        analytical_kl=analytical_kl,
    )


def _create_vae_based_algorithm(
    algorithm: Literal["hdn", "microsplit"],
    loss: LVAELossConfig,
    input_shape: Sequence[int],
    encoder_conv_strides: tuple[int, ...],
    decoder_conv_strides: tuple[int, ...],
    multiscale_count: int,
    z_dims: tuple[int, ...],
    output_channels: int,
    encoder_n_filters: int,
    decoder_n_filters: int,
    encoder_dropout: float,
    decoder_dropout: float,
    nonlinearity: Literal[
        "None", "Sigmoid", "Softmax", "Tanh", "ReLU", "LeakyReLU", "ELU"
    ],
    predict_logvar: Literal[None, "pixelwise"],
    analytical_kl: bool,
    gaussian_likelihood: GaussianLikelihoodConfig | None = None,
    nm_likelihood: NMLikelihoodConfig | None = None,
) -> dict:
    """
    Create a dictionary with the parameters of the VAE-based algorithm model.

    Parameters
    ----------
    algorithm : Literal["hdn"]
        The algorithm type.
    loss : Literal["hdn"]
        The loss function type.
    input_shape : tuple[int, ...]
        The shape of the input data.
    encoder_conv_strides : list[int]
        The strides of the encoder convolutional layers.
    decoder_conv_strides : list[int]
        The strides of the decoder convolutional layers.
    multiscale_count : int
        The number of multiscale layers.
    z_dims : list[int]
        The dimensions of the latent space.
    output_channels : int
        The number of output channels.
    encoder_n_filters : int
        The number of filters in the encoder.
    decoder_n_filters : int
        The number of filters in the decoder.
    encoder_dropout : float
        The dropout rate for the encoder.
    decoder_dropout : float
        The dropout rate for the decoder.
    nonlinearity : Literal
        The nonlinearity function to use.
    predict_logvar : Literal[None, "pixelwise"]
        The type of log variance prediction.
    analytical_kl : bool
        Whether to use analytical KL divergence.
    gaussian_likelihood : Optional[GaussianLikelihoodConfig], optional
        The Gaussian likelihood model, by default None.
    nm_likelihood : Optional[NMLikelihoodConfig], optional
        The noise model likelihood model, by default None.

    Returns
    -------
    dict
        A dictionary with the parameters of the VAE-based algorithm model.
    """
    network_model = _create_vae_configuration(
        input_shape=input_shape,
        encoder_conv_strides=encoder_conv_strides,
        decoder_conv_strides=decoder_conv_strides,
        multiscale_count=multiscale_count,
        z_dims=z_dims,
        output_channels=output_channels,
        encoder_n_filters=encoder_n_filters,
        decoder_n_filters=decoder_n_filters,
        encoder_dropout=encoder_dropout,
        decoder_dropout=decoder_dropout,
        nonlinearity=nonlinearity,
        predict_logvar=predict_logvar,
        analytical_kl=analytical_kl,
    )
    assert gaussian_likelihood or nm_likelihood, "Likelihood model must be specified"
    return {
        "algorithm": algorithm,
        "loss": loss,
        "model": network_model,
        "gaussian_likelihood": gaussian_likelihood,
        "noise_model_likelihood": nm_likelihood,
    }


def get_likelihood_config(
    loss_type: Literal["musplit", "denoisplit", "denoisplit_musplit"],
    # TODO remove different microsplit loss types, refac
    predict_logvar: Literal["pixelwise"] | None = None,
    logvar_lowerbound: float | None = -5.0,
    nm_paths: list[str] | None = None,
    data_stats: tuple[float, float] | None = None,
) -> tuple[
    GaussianLikelihoodConfig | None,
    MultiChannelNMConfig | None,
    NMLikelihoodConfig | None,
]:
    """Get the likelihood configuration for split models.

    Returns a tuple containing the following optional entries:
        - GaussianLikelihoodConfig: Gaussian likelihood configuration for musplit losses
        - MultiChannelNMConfig: Multi-channel noise model configuration for denoisplit
        losses
        - NMLikelihoodConfig: Noise model likelihood configuration for denoisplit losses

    Parameters
    ----------
    loss_type : Literal["musplit", "denoisplit", "denoisplit_musplit"]
        The type of loss function to use.
    predict_logvar : Literal["pixelwise"] | None, optional
        Type of log variance prediction, by default None.
        Required when loss_type is "musplit" or "denoisplit_musplit".
    logvar_lowerbound : float | None, optional
        Lower bound for the log variance, by default -5.0.
        Used when loss_type is "musplit" or "denoisplit_musplit".
    nm_paths : list[str] | None, optional
        Paths to the noise model files, by default None.
        Required when loss_type is "denoisplit" or "denoisplit_musplit".
    data_stats : tuple[float, float] | None, optional
        Data statistics (mean, std), by default None.
        Required when loss_type is "denoisplit" or "denoisplit_musplit".

    Returns
    -------
    gaussian_lik_config : GaussianLikelihoodConfig | None
        Gaussian likelihood configuration for musplit losses, or None.
    nm_config : MultiChannelNMConfig | None
        Multi-channel noise model configuration for denoisplit losses, or None.
    nm_lik_config : NMLikelihoodConfig | None
        Noise model likelihood configuration for denoisplit losses, or None.

    Raises
    ------
    ValueError
        If required parameters are missing for the specified loss_type.
    """
    # gaussian likelihood
    if loss_type in ["musplit", "denoisplit_musplit"]:
        # if predict_logvar is None:
        #     raise ValueError(f"predict_logvar is required for '{loss_type}'")
        # TODO validators should be in pydantic models
        gaussian_lik_config = GaussianLikelihoodConfig(
            predict_logvar=predict_logvar,
            logvar_lowerbound=logvar_lowerbound,
        )
    else:
        gaussian_lik_config = None

    # noise model likelihood
    if loss_type in ["denoisplit", "denoisplit_musplit"]:
        # if nm_paths is None:
        #     raise ValueError(f"nm_paths is required for loss_type '{loss_type}'")
        # if data_stats is None:
        #     raise ValueError(f"data_stats is required for loss_type '{loss_type}'")
        # TODO validators should be in pydantic models
        gmm_list = []
        if nm_paths is not None:
            for NM_path in nm_paths:
                gmm_list.append(
                    GaussianMixtureNMConfig(
                        model_type="GaussianMixtureNoiseModel",
                        path=NM_path,
                    )
                )
        noise_model_config = MultiChannelNMConfig(noise_models=gmm_list)
        nm_lik_config = NMLikelihoodConfig()  # TODO this config isn't needed probably
    else:
        noise_model_config = None
        nm_lik_config = None

    return gaussian_lik_config, noise_model_config, nm_lik_config


# TODO wrap parameters into model, loss etc
# TODO refac likelihood configs to make it 1. Can it be done ?
def create_hdn_configuration(
    experiment_name: str,
    data_type: Literal["array", "tiff", "custom"],
    axes: str,
    patch_size: Sequence[int],
    batch_size: int,
    num_epochs: int = 100,
    num_steps: int | None = None,
    encoder_conv_strides: tuple[int, ...] = (2, 2),
    decoder_conv_strides: tuple[int, ...] = (2, 2),
    multiscale_count: int = 1,
    z_dims: tuple[int, ...] = (128, 128),
    output_channels: int = 1,
    encoder_n_filters: int = 32,
    decoder_n_filters: int = 32,
    encoder_dropout: float = 0.0,
    decoder_dropout: float = 0.0,
    nonlinearity: Literal[
        "None", "Sigmoid", "Softmax", "Tanh", "ReLU", "LeakyReLU", "ELU"
    ] = "ReLU",
    analytical_kl: bool = False,
    predict_logvar: Literal["pixelwise"] | None = None,
    logvar_lowerbound: Union[float, None] = None,
    logger: Literal["wandb", "tensorboard", "none"] = "none",
    trainer_params: dict | None = None,
    augmentations: list[Union[XYFlipConfig, XYRandomRotate90Config]] | None = None,
    train_dataloader_params: dict[str, Any] | None = None,
    val_dataloader_params: dict[str, Any] | None = None,
) -> Configuration:
    """
    Create a configuration for training HDN.

    If "Z" is present in `axes`, then `patch_size` must be a list of length 3, otherwise
    2.

    If "C" is present in `axes`, then you need to set `n_channels_in` to the number of
    channels. Likewise, if you set the number of channels, then "C" must be present in
    `axes`.

    To set the number of output channels, use the `n_channels_out` parameter. If it is
    not specified, it will be assumed to be equal to `n_channels_in`.

    By default, all channels are trained independently. To train all channels together,
    set `independent_channels` to False.

    By setting `augmentations` to `None`, the default transformations (flip in X and Y,
    rotations by 90 degrees in the XY plane) are applied. Rather than the default
    transforms, a list of transforms can be passed to the `augmentations` parameter. To
    disable the transforms, simply pass an empty list.

    # TODO revisit the necessity of model_params

    Parameters
    ----------
    experiment_name : str
        Name of the experiment.
    data_type : Literal["array", "tiff", "custom"]
        Type of the data.
    axes : str
        Axes of the data (e.g. SYX).
    patch_size : List[int]
        Size of the patches along the spatial dimensions (e.g. [64, 64]).
    batch_size : int
        Batch size.
    num_epochs : int, default=100
        Number of epochs to train for. If provided, this will be added to
        trainer_params.
    num_steps : int, optional
        Number of batches in 1 epoch. If provided, this will be added to trainer_params.
        Translates to `limit_train_batches` in PyTorch Lightning Trainer. See relevant
        documentation for more details.
    encoder_conv_strides : tuple[int, ...], optional
        Strides for the encoder convolutional layers, by default (2, 2).
    decoder_conv_strides : tuple[int, ...], optional
        Strides for the decoder convolutional layers, by default (2, 2).
    multiscale_count : int, optional
        Number of scales in the multiscale architecture, by default 1.
    z_dims : tuple[int, ...], optional
        Dimensions of the latent space, by default (128, 128).
    output_channels : int, optional
        Number of output channels, by default 1.
    encoder_n_filters : int, optional
        Number of filters in the encoder, by default 32.
    decoder_n_filters : int, optional
        Number of filters in the decoder, by default 32.
    encoder_dropout : float, optional
        Dropout rate for the encoder, by default 0.0.
    decoder_dropout : float, optional
        Dropout rate for the decoder, by default 0.0.
    nonlinearity : Literal, optional
        Nonlinearity function to use, by default "ReLU".
    analytical_kl : bool, optional
        Whether to use analytical KL divergence, by default False.
    predict_logvar : Literal[None, "pixelwise"], optional
        Type of log variance prediction, by default None.
    logvar_lowerbound : Union[float, None], optional
        Lower bound for the log variance, by default None.
    logger : Literal["wandb", "tensorboard", "none"], optional
        Logger to use for training, by default "none".
    trainer_params : dict, optional
        Parameters for the trainer class, see PyTorch Lightning documentation.
    augmentations : list[XYFlipConfig | XYRandomRotate90Config] | None, optional
        List of augmentations to apply, by default None.
    train_dataloader_params : Optional[dict[str, Any]], optional
        Parameters for the training dataloader, by default None.
    val_dataloader_params : Optional[dict[str, Any]], optional
        Parameters for the validation dataloader, by default None.

    Returns
    -------
    Configuration
        The configuration object for training HDN.

    Examples
    --------
    Minimum example:
    >>> config = create_hdn_configuration(
    ...     experiment_name="hdn_experiment",
    ...     data_type="array",
    ...     axes="YX",
    ...     patch_size=[64, 64],
    ...     batch_size=32,
    ...     num_epochs=100
    ... )

    You can also limit the number of batches per epoch:
    >>> config = create_hdn_configuration(
    ...     experiment_name="hdn_experiment",
    ...     data_type="array",
    ...     axes="YX",
    ...     patch_size=[64, 64],
    ...     batch_size=32,
    ...     num_steps=100  # limit to 100 batches per epoch
    ... )
    """
    transform_list = _list_spatial_augmentations(augmentations)

    loss_config = LVAELossConfig(
        loss_type="hdn", denoisplit_weight=1, musplit_weight=0
    )  # TODO what are the correct defaults for HDN?

    gaussian_likelihood = GaussianLikelihoodConfig(
        predict_logvar=predict_logvar, logvar_lowerbound=logvar_lowerbound
    )

    # algorithm & model
    algorithm_params = _create_vae_based_algorithm(
        algorithm="hdn",
        loss=loss_config,
        input_shape=patch_size,
        encoder_conv_strides=encoder_conv_strides,
        decoder_conv_strides=decoder_conv_strides,
        multiscale_count=multiscale_count,
        z_dims=z_dims,
        output_channels=output_channels,
        encoder_n_filters=encoder_n_filters,
        decoder_n_filters=decoder_n_filters,
        encoder_dropout=encoder_dropout,
        decoder_dropout=decoder_dropout,
        nonlinearity=nonlinearity,
        predict_logvar=predict_logvar,
        analytical_kl=analytical_kl,
        gaussian_likelihood=gaussian_likelihood,
        nm_likelihood=None,
    )

    # data
    data_params = _create_data_configuration(
        data_type=data_type,
        axes=axes,
        patch_size=patch_size,
        batch_size=batch_size,
        augmentations=transform_list,
        train_dataloader_params=train_dataloader_params,
        val_dataloader_params=val_dataloader_params,
    )

    # training
    final_trainer_params = update_trainer_params(
        trainer_params=trainer_params,
        num_epochs=num_epochs,
        num_steps=num_steps,
    )
    training_params = _create_training_configuration(
        trainer_params=final_trainer_params,
        logger=logger,
    )

    return Configuration(
        experiment_name=experiment_name,
        algorithm_config=algorithm_params,
        data_config=data_params,
        training_config=training_params,
    )


def create_microsplit_configuration(
    experiment_name: str,
    data_type: Literal[
        "array", "tiff", "custom"
    ],  # TODO not used yet, but should be after refactoring
    axes: str,  # TODO not used yet, but should be after refactoring
    patch_size: Sequence[int],
    batch_size: int,
    lr: float = 1e-3,
    num_epochs: int = 100,
    num_steps: int | None = None,
    # Model and algo parameters
    encoder_conv_strides: tuple[int, ...] = (2, 2),
    decoder_conv_strides: tuple[int, ...] = (2, 2),
    encoder_n_filters: int = 32,
    decoder_n_filters: int = 32,
    multiscale_count: int = 3,
    grid_size: int = 32,
    z_dims: tuple[int, ...] = (128, 128),
    output_channels: int = 1,
    encoder_dropout: float = 0.1,
    decoder_dropout: float = 0.1,
    nonlinearity: Literal[
        "None", "Sigmoid", "Softmax", "Tanh", "ReLU", "LeakyReLU", "ELU"
    ] = "ELU",
    analytical_kl: bool = False,
    predict_logvar: Literal["pixelwise"] = "pixelwise",
    logvar_lowerbound: float | None = -5.0,
    loss_type: Literal[
        "musplit", "denoisplit", "denoisplit_musplit"
    ] = "denoisplit_musplit",
    kl_type: Literal["kl", "kl_restricted"] = "kl_restricted",
    reconstruction_weight: float = 1.0,
    kl_weight: float = 1.0,
    musplit_weight: float = 0.1,
    denoisplit_weight: float = 0.9,
    mmse_count: int = 10,
    # Training parameters
    optimizer: Literal["Adam", "SGD", "Adamax"] = "Adamax",
    lr_scheduler_patience: int = 30,
    logger: Literal["wandb", "tensorboard", "none"] = "none",
    trainer_params: dict | None = None,
    augmentations: list[Union[XYFlipConfig, XYRandomRotate90Config]] | None = None,
    nm_paths: list[str] | None = None,
    data_stats: tuple[float, float] | None = None,
    train_dataloader_params: dict[str, Any] | None = None,
    val_dataloader_params: dict[str, Any] | None = None,
) -> Configuration:
    """
    Create a configuration for training MicroSplit.

    Parameters
    ----------
    experiment_name : str
        Name of the experiment.
    data_type : Literal["array", "tiff", "custom"]
        Type of the data.
    axes : str
        Axes of the data (e.g. SYX).
    patch_size : Sequence[int]
        Size of the patches along the spatial dimensions (e.g. [64, 64]).
    batch_size : int
        Batch size.
    lr : float, optional
        Learning rate, by default 1e-3.
    num_epochs : int, default=100
        Number of epochs to train for. If provided, this will be added to
        trainer_params.
    num_steps : int, optional
        Number of batches in 1 epoch. If provided, this will be added to trainer_params.
        Translates to `limit_train_batches` in PyTorch Lightning Trainer. See relevant
        documentation for more details.
    encoder_conv_strides : tuple[int, ...], optional
        Strides for the encoder convolutional layers, by default (2, 2).
    decoder_conv_strides : tuple[int, ...], optional
        Strides for the decoder convolutional layers, by default (2, 2).
    encoder_n_filters : int, optional
        Number of filters in the encoder, by default 32.
    decoder_n_filters : int, optional
        Number of filters in the decoder, by default 32.
    multiscale_count : int, optional
        Number of multiscale levels, by default 3.
    grid_size : int, optional
        Size of the grid for multiscale training, by default 32.
    z_dims : tuple[int, ...], optional
        List of latent dims for each hierarchy level in the LVAE, default (128, 128).
    output_channels : int, optional
        Number of output channels for the model, by default 1.
    encoder_dropout : float, optional
        Dropout rate for the encoder, by default 0.0.
    decoder_dropout : float, optional
        Dropout rate for the decoder, by default 0.0.
    nonlinearity : Literal, optional
        Nonlinearity to use in the model, by default "ELU".
    analytical_kl : bool, optional
        Whether to use analytical KL divergence, by default False.
    predict_logvar : Literal["pixelwise"], optional
        Type of log-variance prediction, by default "pixelwise".
    logvar_lowerbound : float | None, optional
        Lower bound for the log variance, by default -5.0.
    loss_type : Literal["musplit", "denoisplit", "denoisplit_musplit"], optional
        Type of loss function, by default "denoisplit_musplit".
    kl_type : Literal["kl", "kl_restricted"], optional
        Type of KL divergence, by default "kl_restricted".
    reconstruction_weight : float, optional
        Weight for reconstruction loss, by default 1.0.
    kl_weight : float, optional
        Weight for KL loss, by default 1.0.
    musplit_weight : float, optional
        Weight for muSplit loss, by default 0.1.
    denoisplit_weight : float, optional
        Weight for denoiSplit loss, by default 0.9.
    mmse_count : int, optional
        Number of MMSE samples to use, by default 10.
    optimizer : Literal["Adam", "SGD", "Adamax"], optional
        Optimizer to use, by default "Adamax".
    lr_scheduler_patience : int, optional
        Patience for learning rate scheduler, by default 30.
    logger : Literal["wandb", "tensorboard", "none"], optional
        Logger to use for training, by default "none".
    trainer_params : dict, optional
        Parameters for the trainer class, see PyTorch Lightning documentation.
    augmentations : list[Union[XYFlipConfig, XYRandomRotate90Config]] | None, optional
        List of augmentations to apply, by default None.
    nm_paths : list[str] | None, optional
        Paths to the noise model files, by default None.
    data_stats : tuple[float, float] | None, optional
        Data statistics (mean, std), by default None.
    train_dataloader_params : dict[str, Any] | None, optional
        Parameters for the training dataloader, by default None.
    val_dataloader_params : dict[str, Any] | None, optional
        Parameters for the validation dataloader, by default None.

    Returns
    -------
    Configuration
        A configuration object for the microsplit algorithm.

    Examples
    --------
    Minimum example:
    # >>> config = create_microsplit_configuration(
    # ...     experiment_name="microsplit_experiment",
    # ...     data_type="array",
    # ...     axes="YX",
    # ...     patch_size=[64, 64],
    # ...     batch_size=32,
    # ...     num_epochs=100

    # ... )

    # You can also limit the number of batches per epoch:
    # >>> config = create_microsplit_configuration(
    # ...     experiment_name="microsplit_experiment",
    # ...     data_type="array",
    # ...     axes="YX",
    # ...     patch_size=[64, 64],
    # ...     batch_size=32,
    # ...     num_steps=100  # limit to 100 batches per epoch
    # ... )
    """
    transform_list = _list_spatial_augmentations(augmentations)

    loss_config = LVAELossConfig(
        loss_type=loss_type,
        reconstruction_weight=reconstruction_weight,
        kl_weight=kl_weight,
        musplit_weight=musplit_weight,
        denoisplit_weight=denoisplit_weight,
        kl_params=KLLossConfig(loss_type=kl_type),
    )

    gaussian_likelihood_config, noise_model_config, nm_likelihood_config = (
        get_likelihood_config(
            loss_type=loss_type,
            predict_logvar=predict_logvar,
            logvar_lowerbound=logvar_lowerbound,
            nm_paths=nm_paths,
            data_stats=data_stats,
        )
    )

    # Create the LVAE model
    network_model = _create_vae_configuration(
        input_shape=patch_size,
        encoder_conv_strides=encoder_conv_strides,
        decoder_conv_strides=decoder_conv_strides,
        multiscale_count=multiscale_count,
        z_dims=z_dims,
        output_channels=output_channels,
        encoder_n_filters=encoder_n_filters,
        decoder_n_filters=decoder_n_filters,
        encoder_dropout=encoder_dropout,
        decoder_dropout=decoder_dropout,
        nonlinearity=nonlinearity,
        predict_logvar=predict_logvar,
        analytical_kl=analytical_kl,
    )

    optimizer_config = OptimizerConfig(
        name=optimizer,
        parameters={"lr": lr, "weight_decay": 0},
    )

    lr_scheduler_config = LrSchedulerConfig(
        name="ReduceLROnPlateau",
        parameters={
            "mode": "min",
            "factor": 0.5,
            "patience": lr_scheduler_patience,
            "verbose": True,
            "min_lr": 1e-12,
        },
    )

    algorithm_params = {
        "algorithm": "microsplit",
        "loss": loss_config,
        "model": network_model,
        "gaussian_likelihood": gaussian_likelihood_config,
        "noise_model": noise_model_config,
        "noise_model_likelihood": nm_likelihood_config,
        "optimizer": optimizer_config,
        "lr_scheduler": lr_scheduler_config,
        "mmse_count": mmse_count,
    }

    algorithm_config = MicroSplitAlgorithm(**algorithm_params)

    # data
    data_params = _create_microsplit_data_configuration(
        data_type=data_type,
        axes=axes,
        patch_size=patch_size,
        grid_size=grid_size,
        multiscale_count=multiscale_count,
        batch_size=batch_size,
        augmentations=transform_list,
        train_dataloader_params=train_dataloader_params,
        val_dataloader_params=val_dataloader_params,
    )

    # training
    final_trainer_params = update_trainer_params(
        trainer_params=trainer_params,
        num_epochs=num_epochs,
        num_steps=num_steps,
    )
    training_params = _create_training_configuration(
        trainer_params=final_trainer_params,
        logger=logger,
    )

    return Configuration(
        experiment_name=experiment_name,
        algorithm_config=algorithm_config,
        data_config=data_params,
        training_config=training_params,
    )


def create_pn2v_configuration(
    experiment_name: str,
    data_type: Literal["array", "tiff", "czi", "custom"],
    axes: str,
    patch_size: Sequence[int],
    batch_size: int,
    nm_path: str,
    num_epochs: int = 100,
    num_steps: int | None = None,
    augmentations: list[Union[XYFlipConfig, XYRandomRotate90Config]] | None = None,
    independent_channels: bool = True,
    use_n2v2: bool = False,
    num_in_channels: int = 1,
    num_out_channels: int = 100,
    roi_size: int = 11,
    masked_pixel_percentage: float = 0.2,
    struct_n2v_axis: Literal["horizontal", "vertical", "none"] = "none",
    struct_n2v_span: int = 5,
    trainer_params: dict | None = None,
    logger: Literal["wandb", "tensorboard", "none"] = "none",
    model_params: dict | None = None,
    optimizer: Literal["Adam", "Adamax", "SGD"] = "Adam",
    optimizer_params: dict[str, Any] | None = None,
    lr_scheduler: Literal["ReduceLROnPlateau", "StepLR"] = "ReduceLROnPlateau",
    lr_scheduler_params: dict[str, Any] | None = None,
    train_dataloader_params: dict[str, Any] | None = None,
    val_dataloader_params: dict[str, Any] | None = None,
    checkpoint_params: dict[str, Any] | None = None,
) -> Configuration:
    """
    Create a configuration for training Probabilistic Noise2Void (PN2V).

    PN2V extends N2V by incorporating a probabilistic noise model to estimate the
    posterior distibution of each pixel more precisely.

    If "Z" is present in `axes`, then `path_size` must be a list of length 3, otherwise
    2.

    If "C" is present in `axes`, then you need to set `num_in_channels` to the number of
    channels.

    By default, all channels are trained independently. To train all channels together,
    set `independent_channels` to False. When training independently, each input channel
    will have `num_out_channels` outputs (default 400). When training together, all
    input channels will share `num_out_channels` outputs.

    By default, the transformations applied are a random flip along X or Y, and a random
    90 degrees rotation in the XY plane. Normalization is always applied, as well as the
    N2V manipulation.

    By setting `augmentations` to `None`, the default transformations (flip in X and Y,
    rotations by 90 degrees in the XY plane) are applied. Rather than the default
    transforms, a list of transforms can be passed to the `augmentations` parameter. To
    disable the transforms, simply pass an empty list.

    The `roi_size` parameter specifies the size of the area around each pixel that will
    be manipulated by N2V. The `masked_pixel_percentage` parameter specifies how many
    pixels per patch will be manipulated.

    The parameters of the UNet can be specified in the `model_params` (passed as a
    parameter-value dictionary). Note that `use_n2v2`, `num_in_channels`, and
    `num_out_channels` override the corresponding parameters passed in `model_params`.

    If you pass "horizontal" or "vertical" to `struct_n2v_axis`, then structN2V mask
    will be applied to each manipulated pixel.

    Parameters
    ----------
    experiment_name : str
        Name of the experiment.
    data_type : Literal["array", "tiff", "czi", "custom"]
        Type of the data.
    axes : str
        Axes of the data (e.g. SYX).
    patch_size : List[int]
        Size of the patches along the spatial dimensions (e.g. [64, 64]).
    batch_size : int
        Batch size.
    nm_path : str
        Path to the noise model file.
    num_epochs : int, default=100
        Number of epochs to train for. If provided, this will be added to
        trainer_params.
    num_steps : int, optional
        Number of batches in 1 epoch. If provided, this will be added to trainer_params.
        Translates to `limit_train_batches` in PyTorch Lightning Trainer. See relevant
        documentation for more details.
    augmentations : list of transforms, default=None
        List of transforms to apply, either both or one of XYFlipModel and
        XYRandomRotate90Model. By default, it applies both XYFlip (on X and Y)
        and XYRandomRotate90 (in XY) to the images.
    independent_channels : bool, optional
        Whether to train all channels independently, by default True. If True, each
        input channel will correspond to num_out_channels output channels (e.g., 3
        input channels with num_out_channels=400 results in 1200 total output
        channels).
    use_n2v2 : bool, optional
        Whether to use N2V2, by default False.
    num_in_channels : int, default=1
        Number of input channels.
    num_out_channels : int, default=400
        Number of output channels per input channel when independent_channels is True,
        or total number of output channels when independent_channels is False.
    roi_size : int, optional
        N2V pixel manipulation area, by default 11.
    masked_pixel_percentage : float, optional
        Percentage of pixels masked in each patch, by default 0.2.
    struct_n2v_axis : Literal["horizontal", "vertical", "none"], optional
        Axis along which to apply structN2V mask, by default "none".
    struct_n2v_span : int, optional
        Span of the structN2V mask, by default 5.
    trainer_params : dict, optional
        Parameters for the trainer, see the relevant documentation.
    logger : Literal["wandb", "tensorboard", "none"], optional
        Logger to use, by default "none".
    model_params : dict, default=None
        UNetModel parameters.
    optimizer : Literal["Adam", "Adamax", "SGD"], default="Adam"
        Optimizer to use.
    optimizer_params : dict, default=None
        Parameters for the optimizer, see PyTorch documentation for more details.
    lr_scheduler : Literal["ReduceLROnPlateau", "StepLR"], default="ReduceLROnPlateau"
        Learning rate scheduler to use.
    lr_scheduler_params : dict, default=None
        Parameters for the learning rate scheduler, see PyTorch documentation for more
        details.
    train_dataloader_params : dict, optional
        Parameters for the training dataloader, see the PyTorch docs for `DataLoader`.
        If left as `None`, the dict `{"shuffle": True}` will be used, this is set in
        the `GeneralDataConfig`.
    val_dataloader_params : dict, optional
        Parameters for the validation dataloader, see PyTorch the docs for `DataLoader`.
        If left as `None`, the empty dict `{}` will be used, this is set in the
        `GeneralDataConfig`.
    checkpoint_params : dict, default=None
        Parameters for the checkpoint callback, see PyTorch Lightning documentation
        (`ModelCheckpoint`) for the list of available parameters.

    Returns
    -------
    Configuration
        Configuration for training PN2V.

    Examples
    --------
    Minimum example:
    # >>> config = create_pn2v_configuration(
    # ...     experiment_name="pn2v_experiment",
    # ...     data_type="array",
    # ...     axes="YX",
    # ...     patch_size=[64, 64],
    # ...     batch_size=32,
    # ...     nm_path="path/to/noise_model.npz",
    # ...     num_epochs=100
    # ... )

    # You can also limit the number of batches per epoch:
    # >>> config = create_pn2v_configuration(
    # ...     experiment_name="pn2v_experiment",
    # ...     data_type="array",
    # ...     axes="YX",
    # ...     patch_size=[64, 64],
    # ...     batch_size=32,
    # ...     nm_path="path/to/noise_model.npz",
    # ...     num_steps=100  # limit to 100 batches per epoch
    # ... )

    # To disable transforms, simply set `augmentations` to an empty list:
    # >>> config = create_pn2v_configuration(
    # ...     experiment_name="pn2v_experiment",
    # ...     data_type="array",
    # ...     axes="YX",
    # ...     patch_size=[64, 64],
    # ...     batch_size=32,
    # ...     nm_path="path/to/noise_model.npz",
    # ...     num_epochs=100,
    # ...     augmentations=[]
    # ... )

    # A list of transforms can be passed to the `augmentations` parameter:
    # >>> from careamics.config.transformations import XYFlipModel
    # >>> config = create_pn2v_configuration(
    # ...     experiment_name="pn2v_experiment",
    # ...     data_type="array",
    # ...     axes="YX",
    # ...     patch_size=[64, 64],
    # ...     batch_size=32,
    # ...     nm_path="path/to/noise_model.npz",
    # ...     num_epochs=100,
    # ...     augmentations=[
    # ...         # No rotation and only Y flipping
    # ...         XYFlipModel(flip_x = False, flip_y = True)
    # ...     ]
    # ... )

    # To use N2V2, simply pass the `use_n2v2` parameter:
    # >>> config = create_pn2v_configuration(
    # ...     experiment_name="pn2v2_experiment",
    # ...     data_type="tiff",
    # ...     axes="YX",
    # ...     patch_size=[64, 64],
    # ...     batch_size=32,
    # ...     nm_path="path/to/noise_model.npz",
    # ...     num_epochs=100,
    # ...     use_n2v2=True
    # ... )

    # For structN2V, there are two parameters to set, `struct_n2v_axis` and
    # `struct_n2v_span`:
    # >>> config = create_pn2v_configuration(
    # ...     experiment_name="structpn2v_experiment",
    # ...     data_type="tiff",
    # ...     axes="YX",
    # ...     patch_size=[64, 64],
    # ...     batch_size=32,
    # ...     nm_path="path/to/noise_model.npz",
    # ...     num_epochs=100,
    # ...     struct_n2v_axis="horizontal",
    # ...     struct_n2v_span=7
    # ... )

    # If you are training multiple channels they will be trained independently by
    # default, you simply need to specify the number of input channels. Each input
    # channel will correspond to num_out_channels outputs (1200 total for 3
    # channels with default num_out_channels=400):
    # >>> config = create_pn2v_configuration(
    # ...     experiment_name="pn2v_experiment",
    # ...     data_type="array",
    # ...     axes="YXC",
    # ...     patch_size=[64, 64],
    # ...     batch_size=32,
    # ...     nm_path="path/to/noise_model.npz",
    # ...     num_epochs=100,
    # ...     num_in_channels=3
    # ... )

    # If instead you want to train multiple channels together, you need to turn
    # off the `independent_channels` parameter (resulting in 400 total output
    # channels regardless of the number of input channels):
    # >>> config = create_pn2v_configuration(
    # ...     experiment_name="pn2v_experiment",
    # ...     data_type="array",
    # ...     axes="YXC",
    # ...     patch_size=[64, 64],
    # ...     batch_size=32,
    # ...     nm_path="path/to/noise_model.npz",
    # ...     num_epochs=100,
    # ...     independent_channels=False,
    # ...     num_in_channels=3
    # ... )

    # >>> config_2d = create_pn2v_configuration(
    # ...     experiment_name="pn2v_experiment",
    # ...     data_type="czi",
    # ...     axes="SCYX",
    # ...     patch_size=[64, 64],
    # ...     batch_size=32,
    # ...     nm_path="path/to/noise_model.npz",
    # ...     num_epochs=100,
    # ...     num_in_channels=1,
    # ... )
    # >>> config_3d = create_pn2v_configuration(
    # ...     experiment_name="pn2v_experiment",
    # ...     data_type="czi",
    # ...     axes="SCZYX",
    # ...     patch_size=[16, 64, 64],
    # ...     batch_size=16,
    # ...     nm_path="path/to/noise_model.npz",
    # ...     num_epochs=100,
    # ...     num_in_channels=1,
    # ... )
    """
    # Validate channel configuration
    if "C" in axes and num_in_channels < 1:
        raise ValueError("num_in_channels must be at least 1 when using channels.")
    elif "C" not in axes and num_in_channels > 1:
        raise ValueError(
            f"C is not present in the axes, but num_in_channels is specified "
            f"(got {num_in_channels} channels)."
        )

    # Calculate total output channels based on independent_channels setting
    if independent_channels:
        total_out_channels = num_in_channels * num_out_channels
    else:
        total_out_channels = num_out_channels

    # augmentations
    spatial_transforms = _list_spatial_augmentations(augmentations)

    # create the N2VManipulate transform using the supplied parameters
    n2v_transform = N2VManipulateConfig(
        name=SupportedTransform.N2V_MANIPULATE.value,
        strategy=(
            SupportedPixelManipulation.MEDIAN.value
            if use_n2v2
            else SupportedPixelManipulation.UNIFORM.value
        ),
        roi_size=roi_size,
        masked_pixel_percentage=masked_pixel_percentage,
        struct_mask_axis=struct_n2v_axis,
        struct_mask_span=struct_n2v_span,
    )

    # Create noise model configuration
    noise_model_config = GaussianMixtureNMConfig(path=nm_path)

    # algorithm
    algorithm_params = _create_algorithm_configuration(
        axes=axes,
        algorithm="pn2v",
        loss="pn2v",
        independent_channels=independent_channels,
        n_channels_in=num_in_channels,
        n_channels_out=total_out_channels,
        use_n2v2=use_n2v2,
        model_params=model_params,
        optimizer=optimizer,
        optimizer_params=optimizer_params,
        lr_scheduler=lr_scheduler,
        lr_scheduler_params=lr_scheduler_params,
    )
    algorithm_params["n2v_config"] = n2v_transform
    algorithm_params["noise_model"] = noise_model_config

    # Convert to PN2VAlgorithm instance
    algorithm_config = PN2VAlgorithm(**algorithm_params)

    # data
    data_params = _create_data_configuration(
        data_type=data_type,
        axes=axes,
        patch_size=patch_size,
        batch_size=batch_size,
        augmentations=spatial_transforms,
        train_dataloader_params=train_dataloader_params,
        val_dataloader_params=val_dataloader_params,
    )

    # training
    final_trainer_params = update_trainer_params(
        trainer_params=trainer_params,
        num_epochs=num_epochs,
        num_steps=num_steps,
    )
    training_params = _create_training_configuration(
        trainer_params=final_trainer_params,
        logger=logger,
        checkpoint_params=checkpoint_params,
    )

    return Configuration(
        experiment_name=experiment_name,
        algorithm_config=algorithm_config,
        data_config=data_params,
        training_config=training_params,
    )
