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