class Domain(ABC, RNG):
    """Domain is a class that defines the domain of the problem.
    The domain is defined by its dimension and the bounds of each variable.

    Args:
        RNG: Subclass that implements the RNG protocol
    """

    def __init__(
        self,
        dimension: int,
        bounds: Sequence[tuple],
        dtype=np.float64,
        name: str = "Domain",
        feat_names: Optional[Sequence[str]] = None,
        seed: Optional[int] = None,
        *args,
        **kwargs,
    ):
        self.name = name
        self.__name__ = name
        self._dimension = dimension
        self._bounds = bounds
        self._dtype = dtype
        self.feat_names = feat_names if feat_names else list()
        self.initialize_rng(seed=seed)

        if len(self._bounds) != 0:
            ranges = list(zip(*bounds))
            self._lbs = np.array(ranges[0], dtype=dtype)
            self._ubs = np.array(ranges[1], dtype=dtype)

    @abstractmethod
    def generate_instances(self, n: int = 1) -> List[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
    ) -> List[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
    ) -> List[Dict[str, np.float32]]:
        """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


    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__ = (
        "_vars",
        "_fit",
        "_p",
        "_s",
        "_features",
        "_desc",
        "_pscores",
        "_otype",
        "_dtype",
    )

    def __init__(
        self,
        variables: Optional[npt.ArrayLike] = None,
        fitness: np.float64 = np.float64(0.0),
        p: np.float64 = np.float64(0.0),
        s: np.float64 = np.float64(0.0),
        features: Optional[tuple[np.float32]] = None,
        descriptor: Optional[tuple[np.float32]] = None,
        portfolio_scores: Optional[tuple[np.float64]] = None,
        otype=np.float64,
        dtype=np.uint32,
    ):
        """Creates an instance of a Instance (unstructured) for QD algorithms
        This class is used to represent a solution in a QD algorithm. It contains the
        variables, fitness, performance, novelty, features, descriptor and portfolio scores
        of the solution.
        The variables are stored as a numpy array, and the fitness, performance and novelty
        are stored as floats. The features, descriptor and portfolio scores are stored as
        numpy arrays.

        Args:
            variables (Optional[npt.ArrayLike], optional): Variables or genome of the instance. Defaults to None.
            fitness (float, optional): Fitness of the instance. Defaults to 0.0.
            p (float, optional): Performance score. Defaults to 0.0.
            s (float, optional): Novelty score. Defaults to 0.0.
            features (Optional[tuple[float]], optional): Tuple of features extracted from the domain. Defaults to None.
            descriptor (Optional[tuple[float]], optional): Tuple with the descriptor information of the instance. Defaults to None.
            portfolio_scores (Optional[tuple[float]], optional): Scores of the solvers in the portfolio. Defaults to None.

        Raises:
            ValueError: If fitness, p or s are not convertible to float.
        """
        self._otype = otype
        self._dtype = dtype
        try:
            fitness = self._otype(fitness)
            p = self._otype(p)
            s = self._otype(s)
        except ValueError:
            raise ValueError(
                "The fitness, p and s parameters must be convertible to float"
            )

        self._vars = (
            np.array(variables, dtype=self._dtype)
            if variables is not None
            else np.empty(0, dtype=self._dtype)
        )
        self._fit = fitness
        self._p = p
        self._s = s
        self._features = (
            np.array(features, dtype=np.float32)
            if features is not None
            else np.empty(0, dtype=np.float32)
        )
        self._pscores = (
            np.array(portfolio_scores, dtype=self._otype)
            if portfolio_scores is not None
            else np.empty(0, dtype=self._otype)
        )

        self._desc = (
            np.array(descriptor, dtype=np.float32)
            if descriptor is not None
            else np.empty(0, dtype=np.float32)
        )

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

    @property
    def otype(self):
        return self._otype

    def clone(self) -> Self:
        """Create a clone of the current instance. More efficient than using copy.deepcopy.

        Returns:
            Self: Instance object
        """
        return Instance(
            variables=list(self._vars),
            fitness=self._fit,
            p=self._p,
            s=self._s,
            features=tuple(self._features),
            portfolio_scores=tuple(self._pscores),
            descriptor=tuple(self._desc),
        )

    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._vars

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

    @property
    def p(self) -> np.float64:
        return self._p

    @p.setter
    def p(self, performance: np.float64):
        try:
            performance = np.float64(performance)
        except ValueError:
            # if performance != 0.0 and not float(performance):
            msg = f"The performance value {performance} is not a float in 'p' setter of class {self.__class__.__name__}"
            raise ValueError(msg)
        self._p = performance

    @property
    def s(self) -> np.float64:
        return self._s

    @s.setter
    def s(self, novelty: np.float64):
        try:
            novelty = np.float64(novelty)
        except ValueError:
            # if novelty != 0.0 and not float(novelty):
            msg = f"The novelty value {novelty} is not a float in 's' setter of class {self.__class__.__name__}"
            raise ValueError(msg)
        self._s = novelty

    @property
    def fitness(self) -> np.float64:
        return self._fit

    @fitness.setter
    def fitness(self, f: np.float64):
        try:
            f = np.float64(f)
        except ValueError:
            # if f != 0.0 and not float(f):
            msg = f"The fitness value {f} is not a float in fitness setter of class {self.__class__.__name__}"
            raise ValueError(msg)

        self._fit = f

    @property
    def features(self) -> np.ndarray:
        return self._features

    @features.setter
    def features(self, features: npt.ArrayLike):
        self._features = np.asarray(features)

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

    @descriptor.setter
    def descriptor(self, desc: npt.ArrayLike):
        self._desc = np.array(desc)

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

    @portfolio_scores.setter
    def portfolio_scores(self, p: npt.ArrayLike):
        self._pscores = np.asarray(p)

    def __repr__(self):
        return f"Instance<f={self.fitness},p={self.p},s={self.s},vars={len(self._vars)},features={len(self.features)},descriptor={len(self.descriptor)},performance={len(self.portfolio_scores)}>"

    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(f={self.fitness},p={self.p},s={self.s},features={len(self.features)},descriptor={descriptor},performance={performance})"

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

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

    def __getitem__(self, key):
        if isinstance(key, slice):
            cls = type(self)  # To facilitate subclassing
            return cls(self._vars[key])
        index = operator.index(key)
        return self._vars[index]

    def __setitem__(self, key, value):
        self._vars[key] = value

    def __eq__(self, other):
        if not isinstance(other, Instance):
            print(
                f"Other of type {other.__class__.__name__} can not be compared with with {self.__class__.__name__}"
            )
            return NotImplemented

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

    def __gt__(self, other):
        if not isinstance(other, Instance):
            print(
                f"Other of type {other.__class__.__name__} can not be compared with with {self.__class__.__name__}"
            )
            return NotImplemented

        return self.fitness > other.fitness

    def __ge__(self, other):
        if not isinstance(other, Instance):
            print(
                f"Other of type {other.__class__.__name__} can not be compared with with {self.__class__.__name__}"
            )
            return NotImplemented

        return self.fitness >= other.fitness

    def __hash__(self):
        from functools import reduce

        hashes = (hash(x) for x in self)
        return reduce(operator.or_, hashes, 0)

    def __bool__(self):
        return self._vars.size != 0

    def __format__(self, fmt_spec=""):
        if fmt_spec.endswith("p"):
            # We are showing only the performances
            fmt_spec = fmt_spec[:-1]
            components = self.portfolio_scores
        else:
            fmt_spec = fmt_spec[:-1]
            components = self.descriptor

        components = (format(c, fmt_spec) for c in components)
        decriptor = "descriptor=({})".format(",".join(components))
        msg = f"Instance(f={self.fitness},p={format(self.p, fmt_spec)}, s={format(self.s, fmt_spec)}, {decriptor})"

        return msg

    def asdict(
        self,
        only_genotype: bool = False,
        variables_names: Optional[Sequence[str]] = None,
        features_names: Optional[Sequence[str]] = None,
        score_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:
            only_genotype (bool, Default True): Whether to return the Instance as a dictionary containing only the variables.
            variables_names (Optional[Sequence[str]], optional): Names of the variables in the dictionary, otherwise v_i. Defaults to None.
            features_names (Optional[Sequence[str]], optional): Name of the features in the dictionary, otherwise f_i. Defaults to None.
            score_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.
        """
        _data = {}
        if variables_names:
            if len(variables_names) != len(self._vars):
                print(
                    f"Error in asdict(). len(variables_names) = {len(variables_names)} != len(variables) ({len(self._vars)}). Fallback to v#"
                )
                _data["variables"] = {f"v{i}": v for i, v in enumerate(self._vars)}
            else:
                _data["variables"] = {
                    vk: v for vk, v in zip(variables_names, self._vars)
                }

        else:
            _data["variables"] = {f"v{i}": v for i, v in enumerate(self._vars)}
        if only_genotype:
            return _data

        else:
            sckeys = (
                [f"solver_{i}" for i in range(len(self._pscores))]
                if score_names is None
                else score_names
            )
            _data = {
                "fitness": self._fit,
                "s": self._s,
                "p": self._p,
                "portfolio_scores": {sk: v for sk, v in zip(sckeys, self._pscores)},
                **_data,
            }

            if len(self._desc) not in (
                len(self._vars),
                len(self._features),
                len(self._pscores),
            ):  # Transformed descriptor
                _data["descriptor"] = {f"d{i}": v for i, v in enumerate(self._desc)}
            if len(self.features) != 0:
                f_keys = (
                    [f"f{i}" for i in range(len(self._features))]
                    if features_names is None or len(features_names) == 0
                    else features_names
                )
                _data["features"] = {fk: v for fk, v in zip(f_keys, self._features)}

        return _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

        return json.dumps(self.asdict(), sort_keys=True, indent=4)

    def to_series(
        self,
        only_genotype: bool = False,
        variables_names: Optional[Sequence[str]] = None,
        features_names: Optional[Sequence[str]] = None,
        score_names: Optional[Sequence[str]] = None,
    ) -> pd.Series:
        """Creates a pandas Series from the instance.

        Args:
            only_genotype (bool, Default True): Whether to return the Instance as a pd.Series containing only the variables.
            variables_names (Optional[Sequence[str]], optional): Names of the variables in the dictionary, otherwise v_i. Defaults to None.
            features_names (Optional[Sequence[str]], optional): Name of the features in the dictionary, otherwise f_i. Defaults to None.
            score_names (Optional[Sequence[str]], optional): Name of the solvers, otherwise solver_i. Defaults to None.

        Returns:
            pd.Series: Pandas Series with the attributes of the instance as keys and the values of the attributes as values.
        """
        _flatten_data = {}
        for key, value in self.asdict(
            only_genotype=only_genotype,
            variables_names=variables_names,
            features_names=features_names,
            score_names=score_names,
        ).items():
            if isinstance(value, dict):  # Flatten nested dicts
                for sub_key, sub_value in value.items():
                    _flatten_data[f"{sub_key}"] = sub_value
            else:
                _flatten_data[key] = value
        return pd.Series(_flatten_data)

class NS:
    def __init__(
        self,
        archive: Optional[Archive] = None,
        k: int = 15,
    ):
        """Creates an instance of the Novelty Search Algorithm
        Args:
            archive (Archive): Archive to store the instances to guide the evolution. Defaults to Archive(threshold=0.001).
            k (int, optional): Number of neighbours to calculate the sparseness. Defaults to 15.
        """
        if k < 0:
            raise ValueError(
                f"{__name__} k must be a positive integer and less than the number of instances."
            )

        if archive is not None and not isinstance(archive, Archive):
            raise ValueError("You must provide a valid Archive object")
        self._k = k
        self._archive = archive if archive is not None else Archive(threshold=0.001)

    @property
    def archive(self):
        return self._archive

    @property
    def k(self):
        return self._k

    def __str__(self):
        return f"NS(k={self._k},A={self._archive})"

    def __repr__(self) -> str:
        return f"NS<k={self._k},A={self._archive}>"

    def __call__(self, instances_descriptors: np.ndarray) -> np.ndarray:
        """Computes the Novelty Search of the instance descriptors with respect to the archive.
           It uses the Euclidean distance to compute the sparseness.

        Args:
            instance_descriptors (np.ndarray): Numpy array with the descriptors of the instances
            archive (Archive): Archive which stores the novelty instances found so far
            k (int, optional): Number of neighbors to consider in the computation of the sparseness. Defaults to 15.

        Raises:
            ValueError: If len(instance_descriptors) <= k

        Returns:
            np.ndarray: novelty scores (s) of the instances descriptors
        """
        if len(instances_descriptors) == 0:
            raise ValueError(
                f"NS was given an empty population to compute the sparseness. Shape is: {instances_descriptors.shape}"
            )
        num_instances = len(instances_descriptors)
        num_archive = len(self.archive)
        result = np.zeros(num_instances, dtype=np.float64)
        if num_archive == 0 and num_instances <= self._k:
            # Initially, the archive is empty and we may not have enough instances to evaluate
            print(
                f"NS has an empty archive at this moment and the given population is not large enough to compute the sparseness. {num_instances} < k ({self._k}). Returning zeros.",
                file=sys.stderr,
            )
            return result

        if num_instances + num_archive <= self._k:
            msg = f"Trying to calculate novelty search with k({self._k}) >= {num_instances} (instances) + {num_archive} (archive)."
            raise ValueError(msg)

        combined = (
            instances_descriptors
            if num_archive == 0
            else np.vstack([instances_descriptors, self._archive.descriptors])
        )
        for i in range(num_instances):
            mask = np.ones(num_instances, bool)
            mask[i] = False
            differences = combined[i] - combined[np.nonzero(mask)]
            distances = np.linalg.norm(differences, axis=1)
            _neighbors = np.partition(distances, self._k + 1)[1 : self._k + 1]
            result[i] = np.sum(_neighbors) / self._k

        return result

class Problem(ABC, RNG):
    def __init__(
        self,
        dimension: int,
        bounds: Sequence[tuple],
        name: str = "DefaultProblem",
        dtype=np.float64,
        seed: int = 42,
        *args,
        **kwargs,
    ):
        """Creates a new problem instance.
        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 "DefaultProblem".
            dtype (_type_, optional): Type of the variables. Defaults to np.float64.
            seed (int, optional): Seed for the RNG. Defaults to 42.
        """
        self._name = name
        self.__name__ = name
        self._dimension = dimension
        self._bounds = bounds
        self._dtype = dtype
        self.initialize_rng(seed=seed)
        if len(self._bounds) != 0:
            ranges = list(zip(*bounds))
            self._lbs = np.array(ranges[0], dtype=dtype)
            self._ubs = np.array(ranges[1], dtype=dtype)

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

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

    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
    ) -> npt.ArrayLike:
        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 Knapsack

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

        Raises:
            ValueError: Raises an error if the len(individual) != len(instance) / 2

        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 RNG(Protocol):
    """Protocol to type check all operators have _rng of instances types in digneapy"""

    _rng: Generator
    _seed: int | None

    def initialize_rng(self, seed: Optional[int] = None):
        self._seed = seed
        self._rng = np.random.default_rng()

class Solution:
    """
    Class representing a solution in a genetic algorithm.
    It contains the variables, objectives, constraints, and fitness of the solution.
    """

    def __init__(
        self,
        variables: Optional[Iterable] = [],
        objectives: Optional[Iterable] = [],
        constraints: Optional[Iterable] = [],
        fitness: np.float64 = 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.array(objectives, dtype=self.otype)
        self.constraints = np.array(constraints, dtype=self.otype)
        self.fitness = otype(fitness)

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

    @property
    def otype(self):
        return self._otype

    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 Solution(
            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 __bool__(self):
        return len(self) != 0

    def __eq__(self, other) -> bool:
        if isinstance(other, Solution):
            try:
                return all(a == b for a, b in zip(self, other, strict=True))
            except ValueError:
                return False
        else:
            return NotImplemented

    def __gt__(self, other):
        if not isinstance(other, Solution):
            msg = f"Other of type {other.__class__.__name__} can not be compared with with {self.__class__.__name__}"
            print(msg)
            return NotImplemented
        return self.fitness > other.fitness

    def __getitem__(self, key):
        if isinstance(key, slice):
            cls = type(self)  # To facilitate subclassing
            return cls(self.variables[key])
        index = operator.index(key)
        return self.variables[index]

    def __setitem__(self, key, value):
        self.variables[key] = value