use std::{convert::Infallible, marker::PhantomData};
use nalgebra::{allocator::Allocator, DefaultAllocator, Dim};

use crate::binary_string::BinaryString;
use super::FitnessFunction;

pub struct OneMax<D> {
    _phantom: PhantomData<D>
}

impl<D> OneMax<D> {
    pub fn new() -> Self {
        Self {
            _phantom: PhantomData
        }
    }
}

impl<D> FitnessFunction for OneMax<D>
where
    D: Dim,
    DefaultAllocator: Allocator<D>
{
    type In = BinaryString<D>;
    type Out = i32;
    type Err = Infallible;

    fn fit(self: &Self, chromosome: &BinaryString<D>) -> Result<i32, Infallible> {
        Ok(chromosome.into_iter()
           .map(|x| *x as i32)
           .sum())
    }
}

#[cfg(test)]
pub mod tests {
    use crate::fitness::one_max::OneMax;
    use crate::{binary_string::BinaryString, test_infra::load_test_file};
    use crate::fitness::FitnessFunction;

    #[test]
    fn test_one_max() {
        let data = load_test_file::<i8, i32>("tests/onemax.txt");

        for test in data {
            assert_eq!(
                OneMax::new().fit(&BinaryString::new_dyn(test.inp)).unwrap(),
                test.out
            );
        }
    }
}