class App(OTBObject):
    """Wrapper around otb.Application to handle settings and execution.

    Base class that gathers common operations for any OTB application lifetime (settings, exec, export, etc.)
    Any app parameter may be passed either using a dict of parameters or keyword argument.

    The first argument can be:
        - filepath or OTBObject, the main input parameter name is automatically used
        - list of inputs, useful when the user wants to specify the input list `il`
        - dictionary of parameters, useful when a key is python-reserved (e.g. `in`, `map`)
    Any key except "in" or "map" can also be passed via kwargs, replace "." with "_" e.g `map_epsg_code=4326`

    Args:
        appname: name of the OTB application to initialize, e.g. 'BandMath'
        *args: can be a filepath, OTB object or a dict or parameters, several dicts will be merged in **kwargs
        frozen: freeze OTB app in order avoid blocking during __init___
        quiet: whether to print logs of the OTB app and the default progress bar
        name: custom name that will show up in logs, appname will be used if not provided
        **kwargs: any OTB application parameter key is accepted except "in" or "map"

    """

    INPUT_IMAGE_TYPES = [
        otb.ParameterType_InputImage,
        otb.ParameterType_InputImageList,
    ]
    INPUT_PARAM_TYPES = INPUT_IMAGE_TYPES + [
        otb.ParameterType_InputVectorData,
        otb.ParameterType_InputVectorDataList,
        otb.ParameterType_InputFilename,
        otb.ParameterType_InputFilenameList,
    ]
    OUTPUT_IMAGE_TYPES = [otb.ParameterType_OutputImage]
    OUTPUT_PARAM_TYPES = OUTPUT_IMAGE_TYPES + [
        otb.ParameterType_OutputVectorData,
        otb.ParameterType_OutputFilename,
    ]
    INPUT_IMAGES_LIST_TYPES = [
        otb.ParameterType_InputImageList,
        otb.ParameterType_InputFilenameList,
    ]
    INPUT_LIST_TYPES = INPUT_IMAGES_LIST_TYPES + [
        otb.ParameterType_StringList,
        otb.ParameterType_ListView,
        otb.ParameterType_InputVectorDataList,
        otb.ParameterType_Band,
    ]

    def __init__(
        self,
        appname: str,
        *args,
        frozen: bool = False,
        quiet: bool = False,
        name: str = "",
        **kwargs,
    ):
        """Common constructor for OTB applications, automatically handles in-memory connections."""
        # Attributes and data structures used by properties
        create = (
            otb.Registry.CreateApplicationWithoutLogger
            if quiet
            else otb.Registry.CreateApplication
        )
        self._app = create(appname)
        self._name = name or appname
        self._exports_dic = {}
        self._settings, self._auto_parameters = {}, {}
        self._time_start, self._time_end = 0.0, 0.0
        self.data = {}
        self.quiet, self.frozen = quiet, frozen

        # Param keys and types
        self.parameters_keys = tuple(self.app.GetParametersKeys())
        self._all_param_types = {
            key: self.app.GetParameterType(key) for key in self.parameters_keys
        }
        self._out_param_types = {
            key: val
            for key, val in self._all_param_types.items()
            if val in self.OUTPUT_PARAM_TYPES
        }
        self._key_choices = {
            key: [f"{key}.{choice}" for choice in self.app.GetChoiceKeys(key)]
            for key in self.parameters_keys
            if self.app.GetParameterType(key) == otb.ParameterType_Choice
        }
        self._out_image_keys = get_out_images_param_keys(self._app)

        # Init, execute and write (auto flush only when output param was provided)
        if args or kwargs:
            self.set_parameters(*args, **kwargs)

        if not self.frozen:
            self.execute()
            if any(key in self._settings for key in self._out_param_types):
                self.flush()
        else:
            self.__sync_parameters()  # since not called during execute()

    @property
    def name(self) -> str:
        """Returns appname by default, or a custom name if passed during App init."""
        return self._name

    @property
    def app(self) -> otb.Application:
        """Reference to this app otb.Application instance."""
        return self._app

    @property
    def parameters(self):
        """Return used application parameters: automatic values or set by user."""
        return {**self._auto_parameters, **self._settings}

    @property
    def exports_dic(self) -> dict[str, dict]:
        """Reference to an internal dict object that contains numpy array exports."""
        return self._exports_dic

    def __is_one_of_types(self, key: str, param_types: list[int]) -> bool:
        """Helper to check the type of a parameter."""
        if key not in self._all_param_types:
            raise KeyError(f"key {key} not found in the application parameters types")
        return self._all_param_types[key] in param_types

    def __is_multi_output(self):
        """Check if app has multiple image outputs to ensure re-execution in write()."""
        return len(self._out_image_keys) > 1

    def is_input(self, key: str) -> bool:
        """Returns True if the parameter key is an input."""
        return self.__is_one_of_types(key=key, param_types=self.INPUT_PARAM_TYPES)

    def is_output(self, key: str) -> bool:
        """Returns True if the parameter key is an output."""
        return self.__is_one_of_types(key=key, param_types=self.OUTPUT_PARAM_TYPES)

    def is_key_list(self, key: str) -> bool:
        """Check if a parameter key is an input parameter list."""
        return self.app.GetParameterType(key) in self.INPUT_LIST_TYPES

    def is_key_images_list(self, key: str) -> bool:
        """Check if a parameter key is an input parameter image list."""
        return self.app.GetParameterType(key) in self.INPUT_IMAGES_LIST_TYPES

    def get_first_key(self, param_types: list[int]) -> str:
        """Get the first param key for specific file types, try each list in args."""
        for param_type in param_types:
            # Return the first key where type matches param_type.
            for key, value in self._all_param_types.items():
                if value == param_type:
                    return key
        raise TypeError(
            f"{self.name}: could not find any key matching the provided types"
        )

    @property
    def input_key(self) -> str:
        """Get the name of first input parameter, raster > vector > file."""
        return self.get_first_key(self.INPUT_PARAM_TYPES)

    @property
    def input_image_key(self) -> str:
        """Name of the first input image parameter."""
        return self.get_first_key(self.INPUT_IMAGE_TYPES)

    @property
    def output_key(self) -> str:
        """Name of the first output parameter, raster > vector > file."""
        return self.get_first_key(self.OUTPUT_PARAM_TYPES)

    @property
    def output_image_key(self) -> str:
        """Get the name of first output image parameter."""
        return self.get_first_key(self.OUTPUT_IMAGE_TYPES)

    @property
    def elapsed_time(self) -> float:
        """Get elapsed time between app init and end of exec or file writing."""
        return self._time_end - self._time_start

    def set_parameters(self, *args, **kwargs):
        """Set parameters, using the right OTB API function depending on the key and type.

        Parameters with dots may be passed as keyword arguments using "_", e.g. map_epsg_code=4326.
        Additional checks are done for input and output (in-memory objects, remote filepaths, etc.).
        When useful, e.g. for images list, this function appends the parameters
        instead of overwriting them. Handles any parameters, i.e. in-memory & filepaths

        Args:
            *args: any input OTBObject, filepath or images list, or a dict of parameters
            **kwargs: app parameters, with "_" instead of dots e.g. io_in="image.tif"

        Raises:
            KeyError: when the parameter name wasn't recognized
            RuntimeError: failed to set parameter value

        """
        parameters = kwargs
        parameters.update(self.__parse_args(args))
        # Going through all arguments
        for key, obj in parameters.items():
            if "_" in key:
                key = key.replace("_", ".")
            if key not in self.parameters_keys:
                raise KeyError(
                    f"{self.name}: parameter '{key}' was not recognized."
                    f" Available keys are {self.parameters_keys}"
                )
            # When the parameter expects a list, if needed, change the value to list
            if self.is_key_list(key) and not isinstance(obj, (list, tuple)):
                obj = [obj]
                logger.info(
                    '%s: argument for parameter "%s" was converted to list',
                    self.name,
                    key,
                )
            try:
                if self.is_input(key):
                    obj = self.__check_input_param(obj)
                elif self.is_output(key):
                    obj = self.__check_output_param(obj)
                self.__set_param(key, obj)
            except (RuntimeError, TypeError, ValueError, KeyError) as e:
                raise RuntimeError(
                    f"{self.name}: error before execution,"
                    f" while setting '{key}' to '{obj}': {e})"
                ) from e
            # Save / update setting value
            self._settings[key] = obj
            if key in self._auto_parameters:
                del self._auto_parameters[key]

    def propagate_dtype(self, target_key: str = None, dtype: int = None):
        """Propagate a pixel type from main input to every outputs, or to a target output key only.

        With multiple inputs (if dtype is not provided), the type of the first input is considered.
        With multiple outputs (if target_key is not provided), all outputs will be converted to the same pixel type.

        Args:
            target_key: output param key to change pixel type
            dtype: data type to use

        """
        if dtype is None:
            param = self._settings.get(self.input_image_key)
            if not param:
                logger.warning(
                    "%s: could not propagate pixel type from inputs to output",
                    self.name,
                )
                return
            if isinstance(param, (list, tuple)):
                param = param[0]  # first image in "il"
            try:
                dtype = get_pixel_type(param)
            except (TypeError, RuntimeError):
                logger.warning(
                    '%s: unable to identify pixel type of key "%s"', self.name, param
                )
                return
        if target_key:
            keys = [target_key]
        else:
            keys = [
                k
                for k, v in self._out_param_types.items()
                if v == otb.ParameterType_OutputImage
            ]
        for key in keys:
            self.app.SetParameterOutputImagePixelType(key, dtype)

    def execute(self):
        """Execute and write to disk if any output parameter has been set during init."""
        logger.debug("%s: run execute() with parameters=%s", self.name, self.parameters)
        self._time_start = perf_counter()
        try:
            self.app.Execute()
        except (RuntimeError, FileNotFoundError) as e:
            raise RuntimeError(
                f"{self.name}: error during during app execution ({e}"
            ) from e
        self.frozen = False
        self._time_end = perf_counter()
        logger.debug("%s: execution ended", self.name)
        self.__sync_parameters()

    def flush(self):
        """Flush data to disk, this is when WriteOutput is actually called."""
        logger.debug("%s: flushing data to disk", self.name)
        self.app.WriteOutput()
        self._time_end = perf_counter()

    def write(
        self,
        path: str | Path | dict[str, str] = None,
        pixel_type: dict[str, str] | str = None,
        preserve_dtype: bool = False,
        ext_fname: dict[str, str] | str = None,
        **kwargs,
    ) -> bool:
        """Set output pixel type and write the output raster files.

        The first argument is expected to be:
            - filepath, useful when there is only one output, e.g. 'output.tif'
            - dictionary containing output filepath
            - None if output file was passed during App init

        In case of multiple outputs, pixel_type may also be a dictionary with parameter names as keys.
        Accepted pixel types : uint8, uint16, uint32, int16, int32, float, double, cint16, cint32, cfloat, cdouble

        Args:
            path: output filepath or dict of filepath with param keys
            pixel_type: pixel type string representation
            preserve_dtype: propagate main input pixel type to outputs, in case pixel_type is None
            ext_fname: an OTB extended filename, will be applied to every output (but won't overwrite existing keys in output filepath)
            **kwargs: keyword arguments e.g. out='output.tif' or io_out='output.tif'

        Returns:
            True if all files are found on disk

        """
        # Gather all input arguments in kwargs dict
        if isinstance(path, dict):
            kwargs.update(path)
        elif isinstance(path, str) and kwargs:
            logger.warning(
                '%s: keyword arguments specified, ignoring argument "%s"',
                self.name,
                path,
            )
        elif isinstance(path, (str, Path)) and self.output_key:
            kwargs[self.output_key] = str(path)
        elif not path and self.output_key in self.parameters:
            kwargs[self.output_key] = self.parameters[self.output_key]
        elif path is not None:
            raise TypeError(f"{self.name}: unsupported filepath type ({type(path)})")
        if not (kwargs or any(k in self._settings for k in self._out_param_types)):
            raise KeyError(
                f"{self.name}: at least one filepath is required, if not provided during App init"
            )
        parameters = kwargs.copy()

        # Append filename extension to filenames
        if ext_fname:
            if not isinstance(ext_fname, (dict, str)):
                raise ValueError("Extended filename must be a str or a dict")

            def _str2dict(ext_str):
                """Function that converts str to dict."""
                splits = [pair.split("=") for pair in ext_str.split("&")]
                return dict(split for split in splits if len(split) == 2)

            if isinstance(ext_fname, str):
                ext_fname = _str2dict(ext_fname)
            logger.debug("%s: extended filename for all outputs:", self.name)
            for key, ext in ext_fname.items():
                logger.debug("%s: %s", key, ext)

            for key, filepath in kwargs.items():
                if self._out_param_types[key] == otb.ParameterType_OutputImage:
                    new_ext_fname = ext_fname.copy()
                    # Grab already set extended filename key/values
                    if "?&" in filepath:
                        filepath, already_set_ext = filepath.split("?&", 1)
                        # Extensions in filepath prevail over `new_ext_fname`
                        new_ext_fname.update(_str2dict(already_set_ext))
                    # tyransform dict to str
                    ext_fname_str = "&".join(
                        [f"{key}={value}" for key, value in new_ext_fname.items()]
                    )
                    parameters[key] = f"{filepath}?&{ext_fname_str}"

        # Manage output pixel types
        data_types = {}
        if pixel_type:
            if isinstance(pixel_type, str):
                dtype = parse_pixel_type(pixel_type)
                type_name = self.app.ConvertPixelTypeToNumpy(dtype)
                logger.debug(
                    '%s: output(s) will be written with type "%s"', self.name, type_name
                )
                for key in parameters:
                    if self._out_param_types[key] == otb.ParameterType_OutputImage:
                        data_types[key] = dtype
            elif isinstance(pixel_type, dict):
                data_types = {
                    key: parse_pixel_type(dtype) for key, dtype in pixel_type.items()
                }
        elif preserve_dtype:
            self.propagate_dtype()

        # Set parameters and flush to disk
        for key, filepath in parameters.items():
            if Path(filepath.split("?")[0]).exists():
                logger.warning("%s: overwriting file %s", self.name, filepath)
            if key in data_types:
                self.propagate_dtype(key, data_types[key])
            self.set_parameters({key: filepath})
        # TODO: drop multioutput special case when fixed on the OTB side. See discussion in MR !102
        if self.frozen or self.__is_multi_output():
            self.execute()
        self.flush()
        if not parameters:
            return True

        # Search and log missing files
        files, missing = [], []
        for key, filepath in parameters.items():
            if not filepath.startswith("/vsi"):
                filepath = Path(filepath.split("?")[0])
                dest = files if filepath.exists() else missing
                dest.append(str(filepath.absolute()))
        for filename in missing:
            logger.error(
                "%s: execution seems to have failed, %s does not exist",
                self.name,
                filename,
            )
        return bool(files) and not missing

    def __parse_args(self, args: list[str | OTBObject | dict | list]) -> dict[str, Any]:
        """Gather all input arguments in kwargs dict.

        Args:
            args: the list of arguments passed to set_parameters (__init__ *args)

        Returns:
            a dictionary with the right keyword depending on the object

        """
        kwargs = {}
        for arg in args:
            if isinstance(arg, dict):
                kwargs.update(arg)
            elif (
                isinstance(arg, (str, OTBObject))
                or isinstance(arg, list)
                and self.is_key_list(self.input_key)
            ):
                kwargs.update({self.input_key: arg})
        return kwargs

    def __check_input_param(
        self, obj: list | tuple | OTBObject | str | Path
    ) -> list | OTBObject | str:
        """Check the type and value of an input parameter, add vsi prefixes if needed."""
        if isinstance(obj, (list, tuple)):
            return [self.__check_input_param(o) for o in obj]
        if isinstance(obj, OTBObject):
            return obj
        if isinstance(obj, Path):
            obj = str(obj)
        if isinstance(obj, str):
            if not obj.startswith("/vsi"):
                # Remote file. TODO: add support for S3 / GS / AZ
                if obj.startswith(("https://", "http://", "ftp://")):
                    obj = "/vsicurl/" + obj
                prefixes = {
                    ".tar": "vsitar",
                    ".tar.gz": "vsitar",
                    ".tgz": "vsitar",
                    ".gz": "vsigzip",
                    ".7z": "vsi7z",
                    ".zip": "vsizip",
                    ".rar": "vsirar",
                }
                expr = r"(.*?)(\.7z|\.zip|\.rar|\.tar\.gz|\.tgz|\.tar|\.gz)(.*)"
                parts = re.match(expr, obj)
                if parts:
                    file, ext = parts.group(1), parts.group(2)
                    if not Path(file + ext).is_dir():
                        obj = f"/{prefixes[ext]}/{obj}"
            return obj
        raise TypeError(f"{self.name}: wrong input parameter type ({type(obj)})")

    def __check_output_param(self, obj: list | tuple | str | Path) -> list | str:
        """Check the type and value of an output parameter."""
        if isinstance(obj, (list, tuple)):
            return [self.__check_output_param(o) for o in obj]
        if isinstance(obj, Path):
            obj = str(obj)
        if isinstance(obj, str):
            return obj
        raise TypeError(f"{self.name}: wrong output parameter type ({type(obj)})")

    def __set_param(
        self, key: str, obj: str | float | list | tuple | OTBObject | otb.Application
    ):
        """Set one parameter, decide which otb.Application method to use depending on target object."""
        if obj is None or (isinstance(obj, (list, tuple)) and not obj):
            self.app.ClearValue(key)
            return
        # Single-parameter cases
        if isinstance(obj, OTBObject):
            self.app.ConnectImage(key, obj.app, obj.output_image_key)
        elif isinstance(obj, otb.Application):
            self.app.ConnectImage(key, obj, get_out_images_param_keys(obj)[0])
        # SetParameterValue in OTB<7.4 doesn't work for ram parameter (see OTB issue 2200)
        elif key == "ram":
            self.app.SetParameterInt("ram", int(obj))
        # SetParameterValue doesn't work with ParameterType_Field (see pyotb GitHub issue #1)
        elif self.app.GetParameterType(key) == otb.ParameterType_Field:
            if isinstance(obj, (list, tuple)):
                self.app.SetParameterStringList(key, obj)
            else:
                self.app.SetParameterString(key, obj)
        # Any other parameters (str, int...)
        elif not isinstance(obj, (list, tuple)):
            self.app.SetParameterValue(key, obj)
        # Images list
        elif self.is_key_images_list(key):
            for inp in obj:
                if isinstance(inp, OTBObject):
                    self.app.ConnectImage(key, inp.app, inp.output_image_key)
                elif isinstance(inp, otb.Application):
                    self.app.ConnectImage(key, obj, get_out_images_param_keys(inp)[0])
                # Here inp is either str or Path, already checked by __check_*_param
                else:
                    # Append it to the list, do not overwrite any previously set element of the image list
                    self.app.AddParameterStringList(key, inp)
        # List of any other types (str, int...)
        elif self.is_key_list(key):
            self.app.SetParameterValue(key, obj)
        else:
            raise TypeError(
                f"{self.name}: wrong parameter type ({type(obj)}) for '{key}'"
            )

    def __sync_parameters(self):
        """Save app parameters in _auto_parameters or data dict.

        This is always called during init or after execution, to ensure the
         parameters property of the App is in sync with the otb.Application instance.
        """
        skip = [
            k for k in self.parameters_keys if k.split(".")[-1] in ("ram", "default")
        ]
        # Prune unused choices child params
        for key in self._key_choices:
            choices = self._key_choices[key].copy()
            choices.remove(f"{key}.{self.app.GetParameterValue(key)}")
            skip.extend(
                [k for k in self.parameters_keys if k.startswith(tuple(choices))]
            )

        self._auto_parameters.clear()
        for key in self.parameters_keys:
            if key in skip or key in self._settings or not self.app.HasValue(key):
                continue
            value = self.app.GetParameterValue(key)
            if isinstance(value, otb.ApplicationProxy):
                try:
                    value = str(value)
                except RuntimeError:
                    continue
            # Keep False or 0 values, but make sure to skip empty collections or str
            if hasattr(value, "__iter__") and not value:
                continue
            # Here we should use AND self.app.IsParameterEnabled(key) but it's broken
            if self.app.GetParameterRole(key) == 0 and (
                self.app.HasAutomaticValue(key) or self.app.IsParameterEnabled(key)
            ):
                self._auto_parameters[key] = value
            # Save static output data (ReadImageInfo, ComputeImageStatistics, etc.)
            elif self.app.GetParameterRole(key) == 1:
                if isinstance(value, str):
                    try:
                        value = literal_eval(value)
                    except (ValueError, SyntaxError):
                        pass
                self.data[key] = value

    # Special functions
    def __getitem__(self, key: str | tuple) -> Any | list[float] | float | Slicer:
        """This function is called when we use App()[...].

        We allow to return attr if key is a parameter, or call OTBObject __getitem__ for pixel values or Slicer
        """
        if isinstance(key, tuple):
            return super().__getitem__(key)  # to read pixel values, or slice
        if isinstance(key, str):
            if key in self.data:
                return self.data[key]
            if key in self._out_image_keys:
                return Output(self, key, self._settings.get(key))
            if key in self.parameters:
                return self.parameters[key]
            raise KeyError(f"{self.name}: unknown or undefined parameter '{key}'")
        raise TypeError(
            f"{self.name}: cannot access object item or slice using {type(key)} object"
        )