class UNet(NetworkTemplate):
    def __init__(
        self,
        layers_config: Dict = None,
        intermediary_outputs_indices: List[int] = None,
        intermediary_inputs_indices: List[int] = None,
        encoder_extra_args: Dict = dict(),
        decoder_extra_args: Dict = dict(),
    ) -> None:
        """U-Net.

        Args:
            layers_config (Dict, optional): A dictionary containing the complete configuration for the
            U-Net encoder and decoder. (Default value = None)
            intermediary_outputs_indices (List[int], optional): A list of indices for indicating the encoder outputs. (Default value = None)
            intermediary_inputs_indices (List[int], optional): A list of indices for indicating the decoder inputs. (Default value = None)
            encoder_extra_args (Dict, optional): A dictionary containing extra arguments for the encoder. (Default value = dict())
            decoder_extra_args (Dict, optional): A dictionary containing extra arguments for the decoder. (Default value = dict())

        """

        super(UNet, self).__init__()

        self.layers_config = layers_config
        self.intermediary_outputs_indices = intermediary_outputs_indices
        self.intermediary_inputs_indices = intermediary_inputs_indices

        self.layers_config_encoder = self.layers_config["encoder"]
        self.layers_config_decoder = self.layers_config["decoder"]

        self.encoder_activations = self.layers_config["encoder_activations"]
        self.decoder_activations = self.layers_config["decoder_activations"]

        self.encoder_horizontal_outputs = dict()

        # Configuring the encoder
        encoder_type = self.layers_config_encoder.get("type")
        layers_config_encoder = self.layers_config_encoder.get("architecture")

        if encoder_type == "cnn":
            self.encoder = CNNUnetEncoder(
                layers=self.layers_config_encoder["architecture"],
                activations=self.encoder_activations,
                intermediary_outputs_indices=self.intermediary_outputs_indices,
                case="2d",
                name="encoder",
                **encoder_extra_args,
            )
        else:
            raise Exception(f"Option {encoder_type} is not available.")

        # Configuring the decoder
        decoder_type = self.layers_config_decoder.get("type")
        layers_config_encoder = self.layers_config_encoder.get("architecture")

        if encoder_type == "cnn":
            self.decoder = CNNUnetDecoder(
                layers=self.layers_config_decoder["architecture"],
                activations=self.decoder_activations,
                intermediary_inputs_indices=self.intermediary_inputs_indices,
                case="2d",
                name="decoder",
                **decoder_extra_args,
            )
        else:
            raise Exception(f"Option {encoder_type} is not available.")

        self.add_module("encoder", self.encoder)
        self.add_module("decoder", self.decoder)

    @as_tensor
    def forward(
        self, input_data: Union[torch.Tensor, np.ndarray] = None
    ) -> torch.Tensor:
        """The U-Net forward method.

        Args:
            input_data (Union[torch.Tensor, np.ndarray], optional): A dataset to be inputted in the CNN U-Net encoder. (Default value = None)

        Returns:
            torch.Tensor: The U-Net output.

        """

        encoder_main_output, encoder_intermediary_outputs = self.encoder(
            input_data=input_data
        )
        output = self.decoder(
            input_data=encoder_main_output,
            intermediary_encoder_outputs=encoder_intermediary_outputs,
        )

        return output

    def summary(self):
        """It shows a general view of the architecture."""

        print(self)