use std::convert::Infallible;
use eoa_lib::{
    constraints::ConstraintFunction,
    fitness::FitnessFunction,
};
use nalgebra::SVector;

/// Individual constraint fitness function - wraps a single constraint to act as a fitness function
pub struct SingleConstraintFitness<const DIM: usize, TConstraint: ConstraintFunction<Chromosome = SVector<f64, DIM>, Out = f64>> {
    constraint: TConstraint,
    capped: bool
}

impl<const DIM: usize, TConstraint: ConstraintFunction<Chromosome = SVector<f64, DIM>, Out = f64>> SingleConstraintFitness<DIM, TConstraint> {
    pub fn new(constraint: TConstraint, capped: bool) -> Self {
        Self { constraint, capped }
    }
}

impl<const DIM: usize, TConstraint: ConstraintFunction<Chromosome = SVector<f64, DIM>, Out = f64>> FitnessFunction for SingleConstraintFitness<DIM, TConstraint> {
    type In = SVector<f64, DIM>;
    type Out = f64;
    type Err = Infallible;

    fn fit(&self, inp: &Self::In) -> Result<Self::Out, Self::Err> {
        Ok(if self.constraint.is_feasible(inp).unwrap() && self.capped {
            0.0
        } else {
            self.constraint.evaluate(inp).unwrap()
        })
    }
}