class DescriptorFn(Protocol):
    """Defines the Protocol that all descriptable functions must follow"""

    def __call__(
        self,
        population: np.ndarray | Sequence[Instance],
        scores: Optional[np.ndarray],
        domain: Optional[Domain],
        *args,
        **kwargs,
    ) -> np.ndarray: ...

class DescriptorPipeline:
    """Pipeline to transform descriptors with several models"""

    def __init__(self, key: DescriptorKey, *transformers: Transformer):
        if not isinstance(key, str) or key not in descriptors_registry:
            raise KeyError(
                f"Unknown descriptor key {key}. Registered keys are: {descriptors_registry.keys()}"
            )
        if any(not isinstance(t, Transformer) for t in transformers):
            raise TypeError(
                f"All transformers must implement the Transformer Protocol. Got: {transformers}"
            )
        self._key = key
        self._transformers = tuple(transformers)

    def __call__(
        self,
        population: np.ndarray | Sequence[Instance],
        scores: Optional[np.ndarray] = None,
        domain: Optional[Domain] = None,
        *args,
        **kwargs,
    ) -> np.ndarray:
        descriptors = descriptors_registry[self._key](
            population, scores, domain, *args, **kwargs
        )
        for transfomer in self._transformers:
            descriptors = transfomer(descriptors)
        return descriptors

    def __repr__(self) -> str:
        steps = [self._key] + [
            getattr(t, "__name__", repr(t)) for t in self._transformers
        ]
        return f"DescriptorPipeline({' -> '.join(steps)})"

class Domain(ABC):
    """Domain is a class that defines the domain of the problem.

    The domain is defined by its dimension and the bounds of each variable.
    """

    def __init__(
        self,
        dimension: np.uint32 | int,
        bounds: Sequence[Tuple],
        dtype=np.float64,
        domain_name: str = "Domain",
        features_names: Optional[Sequence[str]] = [],
        seed: Optional[int | np.random.SeedSequence] = None,
        *args,
        **kwargs,
    ):

        try:
            self._dimension = int(dimension)
            if self._dimension <= 0:
                raise ValueError(
                    f"Cannot create a Domain({domain_name}) with negative "
                    f"or equal to zero dimensions. Got {dimension}."
                )
        except (TypeError, ValueError) as exc:
            raise ValueError("invalid dimension in Domain.") from exc

        if len(bounds) != self._dimension:
            raise ValueError(
                f"bounds mismatch in Domain({domain_name}). "
                f"They were expected {self._dimension} bounds but got {len(bounds)}"
            )
        else:
            ranges = list(zip(*bounds))
            self._lbs = np.asarray(ranges[0], dtype=dtype)
            self._ubs = np.asarray(ranges[1], dtype=dtype)

        self.__name__ = domain_name
        self._bounds = bounds
        self._dtype = dtype
        self.features_names = features_names

        self._seed = seed
        self._rng = np.random.default_rng(seed)

    @abstractmethod
    def generate_instances(
        self, n: np.uint32 | int = np.uint32(1)
    ) -> Sequence[Instance]:
        """Generates N instances for the domain.

        Args:
            n (int, optional): Number of instances to generate. Defaults to 1.

        Returns:
            List[Instance]: A list of Instance objects created from the raw numpy generation
        """
        raise NotImplementedError(
            "generate_n_instances is not implemented in Domain class."
        )

    @abstractmethod
    def generate_problems_from_instances(
        self, instances: Sequence[Instance] | np.ndarray
    ) -> Sequence[Problem]:
        msg = "generate_problems_from_instances is not implemented in Domain class."
        raise NotImplementedError(msg)

    @abstractmethod
    def extract_features(
        self, instances: Sequence[Instance] | np.ndarray
    ) -> np.ndarray:
        """Extract the features of the instances based on the domain

        Args:
            instance (Instance): Instance to extract the features from

        Returns:
            Tuple: Values of each feature
        """
        msg = "extract_features is not implemented in Domain class."
        raise NotImplementedError(msg)

    @abstractmethod
    def extract_features_as_dict(
        self, instances: Sequence[Instance] | np.ndarray
    ) -> Sequence[Dict]:
        """Creates a dictionary with the features of the instance.

        The key are the names of each feature and the values are
        the values extracted from instance.

        Args:
            instance (Instance): Instance to extract the features from

        Returns:
            Mapping[str, float]: Dictionary with the names/values of each feature
        """
        msg = "extract_features_as_dict is not implemented in Domain class."
        raise NotImplementedError(msg)

    @property
    def bounds(self):
        return self._bounds

    @property
    def lbs(self) -> np.ndarray:
        return self._lbs

    @property
    def ubs(self) -> np.ndarray:
        return self._ubs

    def get_bounds_at(self, i: int) -> tuple:
        if i < 0 or i > len(self._bounds):
            raise ValueError(
                f"Index {i} out-of-range. The bounds are 0-{len(self._bounds)} "
            )
        return (self._lbs[i], self._ubs[i])

    @property
    def dimension(self):
        return self._dimension

    def __len__(self):
        return self._dimension

class Instance:
    __slots__ = (
        "_variables",
        "_fitness",
        "_performance_bias",
        "_novelty",
        "_descriptor",
        "_portfolio_scores",
        "_descriptor_dim",
        "_portfolio_dim",
        "_dtype",
    )

    def __init__(
        self,
        variables: Sequence | np.ndarray,
        fitness: float | np.float64 = np.float64(0.0),
        performance_bias: float | np.float64 = np.float64(0.0),
        novelty: float | np.float64 = np.float64(0.0),
        descriptor: Optional[Sequence[float | np.float64]] = None,
        portfolio_scores: Optional[Sequence[float | np.float64]] = None,
        dtype=np.uint32,
    ):
        """Creates an instance of a Instance for QD algorithms.


        This class is used to represent a solution in a QD algorithm. It contains the
        variables, fitness, performance bias, novelty, descriptor and portfolio scores
        of the instance.

        The variables, descriptor and portfolio scores are stored as a numpy array.
        The fitness, performance and novelty are stored as np.float64.

        Args:
            variables (Sequence): Variables or genome of the instance.
            fitness (float, optional): Fitness of the instance. Defaults to 0.0.
            performance_bias (float, optional): Performance score. Defaults to 0.0.
            novelty (float, optional): Novelty score. Defaults to 0.0.
            descriptor (Optional[Sequence[float | np.float64], optional): Tuple with the descriptor information of the instance. Defaults to None.
            portfolio_scores (Optional[Sequence[float | np.float64], optional): Scores of the solvers in the portfolio. Defaults to None.

        Raises:
            ValueError: If fitness, performance_bias or novelty are not convertible to float.
        """
        self._dtype = dtype
        try:
            self._fitness = float(fitness)
            self._performance_bias = float(performance_bias)
            self._novelty = float(novelty)
        except (TypeError, ValueError) as exception:
            exception.add_note(f"fitness: {fitness}")
            exception.add_note(f"performance_bias: {performance_bias}")
            exception.add_note(f"novelty: {novelty}")
            raise TypeError("Wrong parameters for Instance.") from exception
        # Todo: Consider fix the dimensions of the descriptor and portfolio
        # if type(descriptor_dim) is not int or descriptor_dim <= 0:
        #     raise ValueError(
        #         f"descriptor_dim must be a positive integer. Got {descriptor_dim}."
        #     )
        # else:
        #     self._descriptor_dim = int(descriptor_dim)

        # if type(portfolio_dim) is not int or portfolio_dim <= 0:
        #     raise ValueError(
        #         f"portfolio_dim must be a positive integer. Got {portfolio_dim}."
        #     )
        # else:
        #     self._portfolio_dim = int(portfolio_dim)
        if variables is None or len(variables) == 0:
            raise ValueError(f"variables has to be a valid sequence. Got: {variables}")
        else:
            self._variables = np.asarray(variables, dtype=self._dtype, copy=True)

        if descriptor is not None and len(descriptor) == 0:
            raise ValueError(
                f"descriptors must be either None or a sequence with at least one value. Got: {descriptor}"
            )
        else:
            if descriptor is None:
                self._descriptor = np.empty(0, dtype=np.float64)
            else:
                self._descriptor = np.asarray(descriptor, dtype=np.float64, copy=True)

        if portfolio_scores is not None and len(portfolio_scores) == 0:
            raise ValueError(
                f"portfolio_scores must be either None or a sequence with at least one value. Got: {portfolio_scores}"
            )
        else:
            if portfolio_scores is None:
                self._portfolio_scores = np.empty((0), dtype=np.float64)
            else:
                self._portfolio_scores = np.asarray(portfolio_scores, dtype=np.float64)

    @property
    def dtype(self):
        return self._dtype

    def clone(self) -> Self:
        """Create a clone of the current instance.

        This avoids Python-level list/tuple conversions by copying the underlying
        NumPy arrays directly.

        Returns:
            Self: Instance object
        """
        new_instance = object.__new__(type(self))
        new_instance._dtype = self._dtype
        new_instance._fitness = self._fitness
        new_instance._performance_bias = self._performance_bias
        new_instance._novelty = self._novelty
        new_instance._variables = self._variables.copy()
        new_instance._descriptor = self._descriptor.copy()
        new_instance._portfolio_scores = self._portfolio_scores.copy()
        return new_instance

    def clone_with(self, **overrides):
        """Clones an Instance with overriden attributes

        Returns:
            Instance
        """
        new_object = self.clone()
        for key, value in overrides.items():
            setattr(new_object, key, value)
        return new_object

    @property
    def variables(self):
        return self._variables

    @variables.setter
    def variables(self, new_variables: np.ndarray):
        if new_variables is None or len(new_variables) == 0:
            raise ValueError(
                f"new_variables cannot be None nor be empty. Got: {new_variables}."
            )

        elif len(new_variables) != len(self._variables):
            raise ValueError(
                "Updating the variables of an Instance object with a different number of values. "
                f"Instance have {len(self._variables)} variables "
                f"and the new_variables sequence have {len(new_variables)}"
            )
        else:
            self._variables = np.asarray(new_variables)

    @property
    def performance_bias(self) -> float | np.float64:
        return self._performance_bias

    @performance_bias.setter
    def performance_bias(self, performance: float | np.float64):
        try:
            self._performance_bias = float(performance)
        except (TypeError, ValueError) as exc:
            raise ValueError(
                f"performance_bias value is not a float. Got: {performance}."
            ) from exc

    @property
    def novelty(self) -> float | np.float64:
        return self._novelty

    @novelty.setter
    def novelty(self, nov_score: float | np.float64):
        try:
            self._novelty = float(nov_score)
        except (TypeError, ValueError) as exc:
            raise ValueError(
                f"nov_score value is not a float. Got: {nov_score}."
            ) from exc

    @property
    def fitness(self) -> float | np.float64:
        return self._fitness

    @fitness.setter
    def fitness(self, new_fitness: float | np.float64):
        try:
            self._fitness = float(new_fitness)
        except (TypeError, ValueError) as exc:
            raise ValueError(
                f"new_fitness value is not a float. Got: {new_fitness}."
            ) from exc

    @property
    def descriptor(self) -> np.ndarray:
        return self._descriptor

    @descriptor.setter
    def descriptor(self, descriptor: Sequence[float | np.float64] | np.ndarray):
        self._descriptor = np.asarray(descriptor)

    @property
    def portfolio_scores(self):
        return self._portfolio_scores

    @portfolio_scores.setter
    def portfolio_scores(self, scores: Sequence[float | np.float64] | np.ndarray):
        self._portfolio_scores = np.asarray(scores)

    def __repr__(self):
        return self.__str__()

    def __str__(self):
        import reprlib

        descriptor = reprlib.repr(self.descriptor)
        performance = reprlib.repr(self.portfolio_scores)
        performance = performance[performance.find("(") : performance.rfind(")") + 1]
        return (
            f"Instance:\n"
            f"   - fitness = {self.fitness}\n"
            f"   - performance_bias = {self.performance_bias}\n"
            f"   - novelty = {self.novelty}\n"
            f"   - descriptor = {descriptor}\n"
            f"   - portfolio scores = {performance}\n"
        )

    def __iter__(self):
        return iter(self._variables)

    def __len__(self):
        return len(self._variables)

    def __getitem__(self, key: int | slice) -> Sequence | np.ndarray:
        """Accessor to variables of the Instance

        Args:
            key (index | slice): index or slice to access a subset of variables

        Returns:
            Sequence or np.ndarray: If accessed with a slice the subset of variables
                are returned. Otherwise, it returns a single scalar at variables[key].
        """
        if not isinstance(key, (int, slice)):
            raise TypeError(
                f"Instance cannot be indexed with type: {type(key)}. Use slice or int."
            )
        if isinstance(key, slice):
            return self._variables[key]
        else:
            index = operator.index(key)
            return self.variables[index]

    def __setitem__(self, key: int | slice, value):
        """Setter to variables of the Instance

        Args:
            key (int | slice): index or slice to access a subset of variables
            value: Value to set in the variables

        """
        if not isinstance(key, (int, np.integer, np.unsignedinteger, slice)):
            raise TypeError(
                f"Instance cannot be update via __setitem__ with type: {type(key)}. Use slice or int."
            )

        if isinstance(key, slice):
            # Compute how many positions this slice actually targets
            start, stop, step = key.indices(len(self.variables))
            target_count = len(range(start, stop, step))
            # Accept any sequence; reject bare scalars for slice assignment
            try:
                expected_len = len(value)
            except TypeError:
                raise TypeError(
                    f"[Instance] slice assignment requires a sequence, got scalar {value!r}. "
                    f"Expected {target_count} value(s)."
                )

            if expected_len != target_count:
                raise ValueError(
                    f"[Instance] slice targets {target_count} element(s) but value has "
                    f"{expected_len} element(s)."
                )
        else:
            index = operator.index(key)
            try:
                if len(value) != 1:
                    raise ValueError(
                        f"[Instance] index {index!r} targets 1 element but value has "
                        f"{len(value)} element(s). Use a slice to assign multiple values."
                    )
            except TypeError:
                pass  # len() failed which means that we have a scalar value

        self._variables[key] = value

    def __eq__(self, other: Self) -> bool:
        """Compares two Instances based on their variables.

        Args:
            other (Self): Another instance to compare.

        Returns:
            bool: Returns True if the two instances have the same number of variables,
            and all of them are equal. Returns False otherwise.
        """
        if not isinstance(other, Instance):
            raise TypeError(
                f"Other of type {other.__class__.__name__} can not be compared with an Instance."
            )

        else:
            try:
                return all(a == b for a, b in zip(self, other, strict=True))
            except ValueError:
                return False

    def __gt__(self, other: Self) -> bool | np.bool:
        """Compares two Instances based on their fitness.

        Args:
            other (Self): Another instance to compare.

        Returns:
            bool: Returns True if the self has a greater fitness
            than the other. Returns False otherwise.
        """
        if not isinstance(other, Instance):
            raise TypeError(
                f"Other of type {other.__class__.__name__} can not be compared with an Instance."
            )
        else:
            return self.fitness > other.fitness

    def __ge__(self, other: Self) -> bool | np.bool:
        """Compares two Instances based on their fitness.

        Args:
            other (Self): Another instance to compare.

        Returns:
            bool: Returns True if the self has a greater or equal fitness
            than the other. Returns False otherwise.
        """
        if not isinstance(other, Instance):
            raise TypeError(
                f"Other of type {other.__class__.__name__} can not be compared with an Instance."
            )
        else:
            return self.fitness >= other.fitness

    def to_dict(
        self,
        variables_names: Optional[Sequence[str]] = None,
        descriptor_names: Optional[Sequence[str]] = None,
        portfolio_names: Optional[Sequence[str]] = None,
    ) -> dict:
        """Convert the instance to a dictionary.

        The keys are the names of the attributes and the values are the values of the attributes.

        Args:
            variables_names   (Optional[Sequence[str]], optional): Names of the variables in the dictionary, otherwise v_i. Defaults to None.
            descriptor_names: (Optional[Sequence[str]], optional): Names of the components of the descriptor, otherwisde di. Default to None.
            portfolio_names   (Optional[Sequence[str]], optional): Name of the solvers, otherwise solver_i. Defaults to None.

        Returns:
            dict: Dictionary with the attributes of the instance as keys and the values of the attributes as values.
        """
        _instance_data = {}

        descriptor_names = _validate_column_names(
            "descriptor", descriptor_names, len(self._descriptor), fallback_keyword="d"
        )
        _instance_data = {
            **{key: value for key, value in zip(descriptor_names, self._descriptor)}
        }

        variables_names = _validate_column_names(
            "variables_names", variables_names, len(self), fallback_keyword="v"
        )
        _instance_data["variables"] = {
            key: value for key, value in zip(variables_names, self._variables)
        }

        portfolio_names = _validate_column_names(
            "portfolio_names",
            portfolio_names,
            len(self.portfolio_scores),
            fallback_keyword="alg",
        )
        _instance_data["portfolio_scores"] = {
            key: value for key, value in zip(portfolio_names, self._portfolio_scores)
        }

        _instance_data = {
            "target": portfolio_names[0],
            "fitness": self._fitness,
            "novelty": self._novelty,
            "performance_bias": self._performance_bias,
            **_instance_data,
        }
        return _instance_data

    def to_json(self) -> str:
        """Convert the instance to a JSON string.

        The keys are the names of the attributes and the values are the values of the attributes.

        Returns:
            str: JSON string with the attributes of the instance as keys and the values of the attributes as values.
        """
        import json

        # Todo: Need to change dtypes because np is not JSON serializable
        return json.dumps(self.to_dict(), sort_keys=False, indent=2)

    def to_df(
        self,
        variables_names: Optional[Sequence[str]] = None,
        descriptor_names: Optional[Sequence[str]] = None,
        portfolio_names: Optional[Sequence[str]] = None,
    ) -> pl.DataFrame:
        """Creates a Polars DataFrame from the instance.

        Args:
            variables_names (Optional[Sequence[str]], optional): Names of the variables in the dictionary, otherwise v_i. Defaults to None.
            descriptor_names: (Optional[Sequence[str]], optional): Names of the components of the descriptor, otherwisde di. Default to None.
            portfolio_names (Optional[Sequence[str]], optional): Name of the solvers, otherwise solver_i. Defaults to None.

        Returns:
            DataFrame: Polars DataFrame with the attributes of the instance as keys and the values of the attributes as values.
        """
        _flatten_data = {}
        for key, value in self.to_dict(
            variables_names=variables_names,
            descriptor_names=descriptor_names,
            portfolio_names=portfolio_names,
        ).items():
            if isinstance(value, dict):  # Flatten nested dicts
                for sub_key, sub_value in value.items():
                    _flatten_data[sub_key] = sub_value
            else:
                _flatten_data[key] = value
        return pl.DataFrame(_flatten_data)

class Logbook(tools.Logbook):
    """Extends Deap.tools.Logbook to include additionaly features such as to_df."""

    def __init__(self):
        super().__init__()
        self._statistics = Statistics()
        self.header = "generation", "novelty", "performance bias", "fitness"
        self._chapters_headers = (
            "min",
            "mean",
            "std",
            "max",
            "qd_score",
        )
        self.chapters["novelty"].header = self._chapters_headers[:-1]
        self.chapters["performance_bias"].header = self._chapters_headers
        self.chapters["fitness"].header = self._chapters_headers

    def update(
        self,
        generation: int,
        instances: Sequence[Instance],
        feedback: bool = False,
    ):
        if generation < 0:
            raise ValueError(
                f"generation value {generation} must be greater than zero in Logbook update."
            )
        # Checks for None, empty and not isinstance() delegated to Statistics
        self.record(generation=generation, **self._statistics(instances))
        if feedback:  # pragma: no cover
            print(self.stream)

    def to_df(self) -> pl.DataFrame:
        fitness = pl.from_dicts(self.chapters["fitness"], schema=self._chapters_headers)
        novelty = pl.from_dicts(self.chapters["novelty"], schema=self._chapters_headers)
        performance = pl.from_dicts(
            self.chapters["performance_bias"], schema=self._chapters_headers
        )
        generations = pl.Series("generation", self.select("generation"))

        df = (
            fitness
            .rename({h: f"{h}_fitness" for h in self._chapters_headers})
            .with_columns(generations)
            .join(
                novelty.rename({
                    h: f"{h}_novelty" for h in self._chapters_headers
                }).with_columns(generations),
                on="generation",
            )
            .join(
                performance.rename({
                    h: f"{h}_performance_bias" for h in self._chapters_headers
                }).with_columns(generations),
                on="generation",
            )
        )

        return df.select(["generation", *[c for c in df.columns if c != "generation"]])

class Problem(ABC):
    def __init__(
        self,
        dimension: np.uint32 | int,
        bounds: Sequence[Tuple],
        name: str = "Problem",
        dtype=np.float64,
        seed: Optional[int | np.random.SeedSequence] = None,
        *args,
        **kwargs,
    ):
        """Creates a new Problem object.

        The problem is defined by its dimension and the bounds of each variable.

        Args:
            dimension (int): Number of variables in the problem
            bounds (Sequence[tuple]): Bounds of each variable in the problem
            name (str, optional): Name of the problem for printing and logging purposes. Defaults to "Problem".
            dtype (_type_, optional): Type of the variables. Defaults to np.float64.
            seed (int, optional): Seed for the random number generation (_rng). Defaults to None.
        """
        try:
            self._dimension = int(dimension)
            if dimension <= 0:
                raise ValueError
        except Exception as te:
            te.add_note(f"Dimension must be a postive integer. Got: {dimension}")
            raise te

        self.__name__ = name
        self._dimension = dimension
        self._bounds = bounds
        self._dtype = dtype
        if len(self._bounds) != 0:
            ranges = list(zip(*bounds))
            self._lbs = np.asarray(ranges[0], dtype=dtype)
            self._ubs = np.asarray(ranges[1], dtype=dtype)
        self._seed = seed
        self._rng = np.random.default_rng(seed)

    @property
    def dimension(self):
        return self._dimension

    def __len__(self):
        return self._dimension

    @property
    def bounds(self):
        return self._bounds

    @property
    def lbs(self):
        return self._lbs

    @property
    def ubs(self):
        return self._ubs

    def get_bounds_at(self, i: int) -> tuple:
        if i < 0 or i > len(self._bounds):
            raise ValueError(
                f"Index {i} out-of-range. The bounds are 0-{len(self._bounds)} "
            )
        return (self._lbs[i], self._ubs[i])

    @abstractmethod
    def create_solution(self) -> Solution | np.ndarray:
        """Creates a random solution to the problem.
        This method can be used to initialise the solutions
        for any algorithm
        """
        msg = "create_solution method not implemented in Problem"
        raise NotImplementedError(msg)

    @abstractmethod
    def __array__(self, dtype: Any = None, copy: Optional[bool] = None) -> np.ndarray:
        msg = "__array__ method not implemented in Problem"
        raise NotImplementedError(msg)

    @abstractmethod
    def evaluate(
        self, individual: Sequence | Solution | np.ndarray
    ) -> Tuple[float, ...]:
        """Evaluates the candidate individual with the information of the problem

        Args:
            individual (Sequence | Solution | np.ndarray): Individual to evaluate

        Returns:
            Tuple[float]: fitness
        """
        msg = "evaluate method not implemented in Problem"
        raise NotImplementedError(msg)

    @abstractmethod
    def __call__(
        self, individual: Sequence | Solution | np.ndarray
    ) -> Tuple[float, ...]:
        msg = "__call__ method not implemented in Problem"
        raise NotImplementedError(msg)

    @abstractmethod
    def to_instance(self) -> Instance:
        """Creates an instance from the information of the problem.
        This method is used in the generators to create instances to evolve
        """
        msg = "to_instance method not implemented in Problem"
        raise NotImplementedError(msg)

    @abstractmethod
    def to_file(self, filename: str):
        msg = "to_file method not implemented in Problem"
        raise NotImplementedError(msg)

    @classmethod
    def from_file(cls, filename: str):
        msg = "from_file method not implemented in Problem"
        raise NotImplementedError(msg)

class Solution:
    """
    Class representing a solution in a genetic algorithm.

    It contains the variables, objectives, constraints, and fitness of the solution.
    """

    __slots__ = (
        "_variables",
        "_objectives",
        "_constraints",
        "_fitness",
        "_dtype",
        "_otype",
    )

    def __init__(
        self,
        variables: Optional[Iterable] = [],
        objectives: Optional[Iterable] = [],
        constraints: Optional[Iterable] = [],
        fitness: float | np.float64 = 0.0,
        dtype=np.uint32,
        otype=np.float64,
    ):
        """Creates a new solution object.

        The variables is a numpy array of the solution's genes.
        The objectives and constraints are numpy arrays of the solution's objectives and constraints.
        The fitness is a float representing the solution's fitness value.

        Args:
            variables (Optional[Iterable], optional): Tuple or any other iterable with the variables/variables. Defaults to None.
            objectives (Optional[Iterable], optional): Tuple or any other iterable with the objectives values. Defaults to None.
            constraints (Optional[Iterable], optional): Tuple or any other iterable with the constraint values. Defaults to None.
            fitness (float, optional): Fitness of the solution. Defaults to 0.0.
        """

        self._otype = otype
        self._dtype = dtype
        self._variables = np.asarray(variables, dtype=self.dtype)
        self._objectives = np.asarray(objectives, dtype=self._otype)
        self._constraints = np.asarray(constraints, dtype=self._otype)
        try:
            if fitness is None:
                self._fitness = np.float64(0)
            else:
                self._fitness = np.float64(fitness)
        except (TypeError, ValueError) as exc:
            raise ValueError(
                "Fitness must be convertible to float in Solution"
            ) from exc

    @property
    def dtype(self):
        return self._dtype

    @property
    def variables(self):
        return self._variables

    @variables.setter
    def variables(self, new_variables: np.ndarray):
        if len(new_variables) != len(self._variables):
            raise ValueError(
                "Updating the variables of an Solution object with a different number of values. "
                f"Solution have {len(self._variables)} "
                f"variables and the new_variables sequence have {len(new_variables)}"
            )
        self._variables = np.asarray(new_variables)

    @property
    def fitness(self) -> np.float64 | float:
        return self._fitness

    @fitness.setter
    def fitness(self, f: np.float64 | float):
        try:
            self._fitness = float(f)
        except (TypeError, ValueError) as exc:
            raise ValueError(
                f"The fitness value {f} is not a float in fitness setter of class Solution."
            ) from exc
        finally:
            self._fitness = np.float64(self._fitness)

    @property
    def objectives(self):
        return self._objectives

    @objectives.setter
    def objectives(self, new_objectives: np.ndarray):
        if len(new_objectives) != len(self._objectives):
            raise ValueError(
                "Updating the objectives of an Solution object with a different number of values. "
                f"Solution have {len(self._objectives)} "
                f"objectives and the new_objectives sequence have {len(new_objectives)}"
            )
        self._objectives = np.asarray(new_objectives)

    @property
    def constraints(self):
        return self._constraints

    @constraints.setter
    def constraints(self, new_constraints: np.ndarray):
        if len(new_constraints) != len(self._constraints):
            raise ValueError(
                "Updating the constraints of an Solution object with a different number of values. "
                f"Solution have {len(self._constraints)} "
                f"constraints and the new_constraints sequence have {len(new_constraints)}"
            )
        self._constraints = np.asarray(new_constraints)

    def clone(self) -> Self:
        """Returns a deep copy of the solution. It is more efficient than using the copy module.

        Returns:
            Self: Solution object
        """
        return type(self)(
            variables=list(self._variables),
            objectives=list(self._objectives),
            constraints=list(self._constraints),
            fitness=self._fitness,
            otype=self._otype,
        )

    def clone_with(self, **overrides):
        """Clones an Instance with overriden attributes

        Returns:
            Instance
        """
        new_object = self.clone()
        for key, value in overrides.items():
            setattr(new_object, key, value)
        return new_object

    def __str__(self) -> str:
        return f"Solution(dim={len(self.variables)},f={self.fitness},objs={self.objectives},const={self.constraints})"

    def __repr__(self) -> str:
        return f"Solution<dim={len(self.variables)},f={self.fitness},objs={self.objectives},const={self.constraints}>"

    def __len__(self) -> int:
        return len(self.variables)

    def __iter__(self):
        return iter(self.variables)

    def __eq__(self, other: Self) -> bool:
        if not isinstance(other, Solution):
            raise TypeError(
                "Other of type {other.__class__.__name__} can not be compared with a Solution."
            )
        else:
            try:
                return all(a == b for a, b in zip(self, other, strict=True))
            except ValueError:
                return False

    def __gt__(self, other: Self) -> np.bool:
        if not isinstance(other, Solution):
            raise TypeError(
                f"Other of type {other.__class__.__name__} can not be compared with a Solution."
            )

        return self.fitness > other.fitness

    def __getitem__(self, key: int | slice) -> Sequence | np.ndarray:
        """Accessor to variables of the Solution

        Args:
            key (int | slice): index or slice to access a subset of variables

        Returns:
            Sequence or np.ndarray: If accessed with a slice the subset of variables
                are returned. Otherwise, it returns a single scalar at variables[key].
        """
        if not isinstance(key, (int, slice)):
            raise TypeError(
                f"Solution cannot be indexed with type: {type(key)}. Use slice or int."
            )
        if isinstance(key, slice):
            return self._variables[key]
        else:
            index = operator.index(key)
            return self.variables[index]

    def __setitem__(self, key: int | slice, value):
        """Setter to variables of the Solution

        Args:
            key (int | slice): index or slice to access a subset of variables
            value: Value to set in the variables

        """
        if not isinstance(key, (int, np.integer, np.unsignedinteger, slice)):
            raise TypeError(
                f"Solution cannot be update via __setitem__ with type: {type(key)}. Use slice or int."
            )

        if isinstance(key, slice):
            # Compute how many positions this slice actually targets
            start, stop, step = key.indices(len(self.variables))
            target_count = len(range(start, stop, step))
            # Accept any sequence; reject bare scalars for slice assignment
            try:
                expected_len = len(value)
            except TypeError:
                raise TypeError(
                    f"[Solution] slice assignment requires a sequence, got scalar {value!r}. "
                    f"Expected {target_count} value(s)."
                )

            if expected_len != target_count:
                raise ValueError(
                    f"[Solution] slice targets {target_count} element(s) but value has "
                    f"{expected_len} element(s)."
                )
        else:
            index = operator.index(key)
            try:
                if len(value) != 1:
                    raise ValueError(
                        f"[Solution] index {index!r} targets 1 element but value has "
                        f"{len(value)} element(s). Use a slice to assign multiple values."
                    )
            except TypeError:
                pass  # len() failed which means that we have a scalar value

        self._variables[key] = value