class BatchUniformMutation(Mutation):
    def __init__(self, seed: Optional[int | np.random.SeedSequence] = None):
        super().__init__(seed)

    def __call__(
        self, population: np.ndarray, lb: np.ndarray, ub: np.ndarray
    ) -> np.ndarray:
        """Performs uniform one mutation in batches

        Args:
            population (np.ndarray): Batch of individuals to mutate
            lb (np.ndarray): Lower bound for each dimension
            ub (np.ndarray): Upper bound for each dimension
            seed (Optional[int  |  np.random.SeedSequence], optional): Seed for the random number generator. Defaults to None.

        Raises:
            ValueError: If the dimension of the individuals do not match the bounds

        Returns:
            np.ndarray: mutated population
        """
        dimension = len(population[0])
        n_individuals = len(population)

        if len(lb) != len(ub) or dimension != len(lb):
            msg = f"len of individuals ({dimension}) and bounds {len(lb)} differs in uniform_one_mutation"
            raise ValueError(msg)

        mutation_points = self._rng.integers(low=0, high=dimension, size=n_individuals)
        new_values = self._rng.uniform(
            low=lb[mutation_points], high=ub[mutation_points], size=n_individuals
        )

        population[np.arange(n_individuals), mutation_points] = new_values

        return population

class BinarySelection(Selection):
    def __init__(
        self, attr: str = "fitness", seed: Optional[int | np.random.SeedSequence] = None
    ):
        super().__init__(seed)
        self._attr = attr

    def __call__(
        self,
        population: Sequence[IndType] | np.ndarray,
    ) -> IndType:
        """Binary Tournament Selection Operator

        Args:
            population (Sequence): Population of individuals to select a parent from

        Raises:
            RuntimeError: If the population is empty

        Returns:
            Instance or Solution: New parent
        """
        if not population:
            msg = "Trying to selection individuals in an empty population."
            raise ValueError(msg)
        elif len(population) == 1:
            return population[0]
        else:
            idx1, idx2 = self._rng.integers(low=0, high=len(population), size=2)
            return max(population[idx1], population[idx2], key=attrgetter(self._attr))

class Elitist(Replacement):
    def __init__(
        self,
        hall_of_fame: int = 1,
        attr: str = "fitness",
        seed: Optional[int | np.random.SeedSequence] = None,
    ):
        super().__init__(seed)
        self._hof = hall_of_fame
        self._attr = attr

    def __call__(
        self,
        population: Sequence[IndType],
        offspring: Sequence[IndType],
    ) -> Sequence[IndType]:
        """Returns a new population constructed using the Elitist approach.
        HoF number of individuals from the current + offspring populations are
        kept in the new population. The remaining individuals are selected from
        the offspring population.

        Args:
            population Sequence[IndType],: Current population in the algorithm
            offspring  Sequence[IndType],: Offspring population
            hof (int, optional): _description_. Defaults to 1.

        Raises:
            ValueError: Raises if the sizes of the population are different

        Returns:
            list[IndType]:
        """
        if len(population) != len(offspring):
            msg = f"The size of the current population ({len(population)}) != size of the offspring ({len(offspring)}) in elitist_replacement"
            raise ValueError(msg)

        combined_population = sorted(
            itertools.chain(population, offspring),
            key=attrgetter(self._attr),
            reverse=True,
        )
        top = combined_population[: self._hof]
        return list(top + offspring[1:])

class Generational(Replacement):
    def __init__(self, seed: Optional[int | np.random.SeedSequence] = None):
        super().__init__(seed)

    def __call__(
        self, population: Sequence[IndType], offspring: Sequence[IndType]
    ) -> Sequence[IndType]:
        """Returns the offspring population as the new current population

        Args:
            population (Sequence[IndType]): Current population in the algorithm
            offspring (Sequence[IndType]): Offspring population

        Raises:
            ValueError: Raises if the sizes of the population are different

        Returns:
            Sequence[IndType]: New population
        """
        if len(population) != len(offspring):
            msg = f"The size of the current population ({len(population)}) != size of the offspring ({len(offspring)}) in generational replacement"
            raise ValueError(msg)

        return offspring[:]

class GreedyReplacement(Replacement):
    def __init__(self, seed: Optional[int | np.random.SeedSequence] = None):
        super().__init__(seed)

    def __call__(
        self,
        population: Sequence[IndType],
        offspring: Sequence[IndType],
    ) -> Sequence[IndType]:
        """Returns a new population produced by a greedy operator.
        Each individual in the current population is compared with its analogous in the offspring population
        and the best survives

        Args:
            population (Sequence[IndType]): Current population in the algorithm
            offspring (Sequence[IndType]): Offspring population

        Raises:
            ValueError: Raises if the sizes of the population are different

        Returns:
            Sequence[IndType]: New population
        """
        if len(population) != len(offspring):
            msg = f"The size of the current population ({len(population)}) != size of the offspring ({len(offspring)}) in first_improve_replacement"
            raise ValueError(msg)
        return [a if a > b else b for a, b in zip(population, offspring)]

class ISOLineMutation(Mutation):
    def __init__(
        self,
        sigma_iso: float,
        sigma_line: float,
        seed: Optional[int | np.random.SeedSequence] = None,
    ):
        super().__init__(seed)
        try:
            self._sigma_iso = float(sigma_iso)
            self._sigma_line = float(sigma_line)
        except ValueError:
            raise ValueError("sigma_iso and sigma_line must be float.")

    def __call__(
        self, population: np.ndarray, lb: np.ndarray, ub: np.ndarray
    ) -> np.ndarray:
        """Performs ISO+Line mutation from Vassiliades & Mouret 2018

        Args:
            population (np.ndarray): Batch of individuals to mutate
            lb (np.ndarray): Lower bound for each dimension
            ub (np.ndarray): Upper bound for each dimension

        Raises:
            ValueError: if dimension != bounds

        Returns:
            np.ndarray: Newly mutated individuals
        """
        dimension = len(population[0])
        if len(lb) != len(ub) or dimension != len(lb):
            msg = f"The size of individuals ({dimension}) and bounds {len(lb)} is different in iso_line_mutation"
            raise ValueError(msg)
        indices = np.arange(len(population))

        parents_a = np.asarray(
            population[self._rng.choice(indices, size=len(population))], copy=True
        )
        parents_b = np.asarray(
            population[self._rng.choice(indices, size=len(population))], copy=True
        )
        iso_noise = self._rng.normal(0, self._sigma_iso, size=parents_a.shape)
        line_steps = self._rng.uniform(0, self._sigma_line, size=(len(parents_a), 1))
        direction = parents_b - parents_a
        offspring = parents_a + iso_noise + line_steps * direction
        offspring = np.clip(offspring, lb, ub)
        return offspring

class OnePointCrossover(Crossover):
    def __init__(
        self, cxpb: float = 0.5, seed: Optional[int | np.random.SeedSequence] = None
    ):
        super().__init__(cxpb, seed)

    def __call__(self, individual: IndType, other: IndType) -> IndType:
        """One point crossover

        Args:
            individual Instance or Solution: First individual to apply crossover. Returned object
            other Instance or Solution: Second individual to apply crossover
            cxpb (float64, optional): Crossover probability. Not used in this operator.
            seed (Optional[int  |  np.random.SeedSequence], optional): Seed for the random number generator. Defaults to None.

        Raises:
            ValueError: When the len(ind_1) != len(ind_2)

        Returns:
            Instance or Solution: New individual
        """
        if len(individual) != len(other):
            msg = f"Individual of different length in uniform_crossover. len(ind) = {len(individual)} != len(other) = {len(other)}"
            raise ValueError(msg)

        offspring = individual.clone()
        cross_point = self._rng.integers(low=0, high=len(individual))
        offspring[cross_point:] = other[cross_point:]
        return offspring

class UniformCrossover(Crossover):
    def __init__(
        self, cxpb: float = 0.5, seed: Optional[int | np.random.SeedSequence] = None
    ):
        super().__init__(cxpb, seed)

    def __call__(self, individual: IndType, other: IndType) -> IndType:
        """Uniform Crossover Operator for Instances and Solutions

        Args:
            individual (IndType): First individual to apply crossover. Returned object.
            other (IndType): Second individual to apply crossover
            cxpb (float64, optional): Crossover probability. Defaults to 0.5.
            seed (Optional[int  |  np.random.SeedSequence], optional): Seed for the random number generator. Defaults to None.

        Raises:
            ValueError: When the len(ind_1) != len(ind_2)

        Returns:
            ndarray: New individual
        """

        if len(individual) != len(other):
            msg = f"Individual of different length in uniform_crossover. len(ind) = {len(individual)} != len(other) = {len(other)}"
            raise ValueError(msg)

        cloned = individual.clone()
        probs = self._rng.random(size=len(individual))
        genotype = np.empty_like(individual)
        genotype = np.where(probs <= self._cxpb, individual, other)
        cloned.variables = genotype
        return cloned

class UniformMutation(Mutation):
    def __init__(self, seed: Optional[int | np.random.SeedSequence] = None):
        super().__init__(seed)

    def __call__(self, individual: IndType, lb: np.ndarray, ub: np.ndarray) -> IndType:
        """Performs Uniform One Mutation on Instances and Solution objects.

        Args:
            individual (IndType): Instance or Solution to mutate.
            lb (np.ndarray): Lower bound for each dimension
            ub (np.ndarray): Upper bound for each dimension
            seed (Optional[int  |  np.random.SeedSequence], optional): Seed for the random number generator. Defaults to None.

        Raises:
            ValueError: If bouns != dimension

        Returns:
            IndType: Newly mutated individual
        """
        if len(lb) != len(ub) or len(individual) != len(lb):
            msg = f"The size of individual ({len(individual)}) and bounds {len(lb)} is different in uniform_one_mutation."
            raise ValueError(msg)

        mutation_point = self._rng.integers(low=0, high=len(individual))
        new_value = self._rng.uniform(low=lb[mutation_point], high=ub[mutation_point])
        individual[mutation_point] = new_value
        return individual