use std::convert::Infallible;
#[cfg(test)]
use crate::test_infra::load_test_file;
use crate::binary_string::BinaryString;
use super::FitnessFunction;

pub struct LABS;

impl LABS {
    pub fn new() -> Self {
        LABS
    }

    fn ck(k: usize, s: &Vec<i32>) -> i32 {
        let d = s.len();
        s.iter()
            .take(d - k)
            .zip(s.iter().skip(k))
            .map(|(x, y)| x * y)
            .sum()
    }
}

impl FitnessFunction for LABS {
    type In = BinaryString;
    type Out = i32;
    type Err = Infallible;

    fn fit(self: &Self, chromosome: &BinaryString) -> Result<i32, Infallible> {
        let s: Vec<i32> = chromosome
            .into_iter()
            .map(|c| (*c as i32) * 2 - 1)
            .collect();
        let d = s.len();

        Ok((1..=d-1)
           .map(|k| LABS::ck(k, &s).pow(2))
           .sum())
    }
}

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

    for test in data {
        println!("Test vector {}", test.inp.iter()
            .map(|x| x.to_string())
            .collect::<Vec<String>>()
            .join(", "));
        assert_eq!(
            LABS::new().fit(&BinaryString::new(test.inp)).unwrap(),
            test.out
        )
     }
}