///Genetic Algorithm, similar to BinaryF6
extern crate rand;

use chromosome::rand::Rng;

///A chromosome struct to be used to generate binary genes.
#[derive(Debug)]
pub struct Chromosome {
    genes: Vec<i32>,
}

impl Chromosome {
    ///new() instantiates a new Chromosome. It has 44 genes (0 or 1) in a vector
    #[allow(dead_code)]
    pub fn new() -> Chromosome {
        let mut rng = rand::thread_rng();
        let mut vec : Vec<i32> = Vec::new();
        for _ in 0..44 {
            vec.push(rng.gen::<i32>().abs() % 2);
        }
        Chromosome {genes: vec}
    }

    ///x_y() is used to get a fitness value for the genes combination. (X: i32, Y: i32) is a tuple used to calculate fitness
    #[allow(dead_code)]
    fn x_y(&self) -> (i32, i32) {
        let x: i32 = self.genes[0..22].iter().map(|x| x.pow(2)).fold(0i32, |sum, x| sum + x) -11i32;
        let y: i32 = self.genes[22..44].iter().map(|y| y.pow(2)).fold(0i32, |sum, y| sum + y) -11i32;
        (x, y)
    }

    ///fitness is the adaptability of the respective chromosome. Fitness should be between 0 and 1, where 1 is best.
    #[allow(dead_code)]
    pub fn fitness(&self) -> f32 {
        let xyv = vec![self.x_y().0 as f32, self.x_y().1 as f32];
        let xy = xyv.iter().fold(0f32, |sum, xy| sum + xy.powi(2));
        let mant = xy.sqrt().sin().powi(2);
        let fitness = 0.5f32 - ((mant - 0.5f32) / (1f32 + (0.001f32 * xy * xy)));
        fitness
    }

    ///During the evolution process a chromosome should mutate.
    ///Chromosomes should be able to mutate during the eveolution process
    #[allow(dead_code)]
    pub fn mutate(&mut self) {
        let mut rng = rand::thread_rng();
        let idx = rng.gen::<usize>() % 44;
        self.genes.insert(idx, rng.gen::<i32>() % 2);
        self.genes.remove(idx + 1);
    }
}

///Crosses over two individuals genes
#[allow(dead_code)]
fn cross_over(indv1: &Vec<i32>, indv2: &Vec<i32>) -> Vec<i32> {
    let mut new_gene = Vec::new();
    for i in 0..44 {
        if i < 22 {
            new_gene.push(indv1[i]);
        } else {
            new_gene.push(indv2[i]);
        }
    }
    new_gene
}

///Gets Best Chromosome fitness
#[allow(dead_code)]
fn get_best(pop: Vec<Chromosome>) -> Vec<i32> {
    let mut fitness = 0f32;
    let mut best = Vec::new();
    for indv in &pop {
        if indv.fitness() > fitness {
            fitness = indv.fitness();
            best = indv.genes.clone();
        }
    }
    best
}

///Generate as initial population
#[allow(dead_code)]
fn generate_pop() -> Vec<Chromosome> {
    let mut pop = Vec::new();
    for _ in 0..100 {
        pop.push(Chromosome::new());
    }
    pop
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn chromosome_creation() {
        let individual = Chromosome {genes: vec![1, 1]};
        assert_eq!(individual.genes.len(), 2)
    }

    #[test]
    fn creates_binary_chromosome() {
        let mut individual = Chromosome::new();

        assert!(individual.genes.iter().all(|&x| x as i32 == 0i32 || x as i32 == 1i32));
    }

    #[test]
    fn fitness_xy_tuple_in_range() {
        let individual = Chromosome::new();
        let xy = individual.x_y();
        assert!(xy.0 >= -11i32 && xy.0 <= 11i32);
        assert!(xy.1 >= -11i32 && xy.1 <= 11i32);
    }

    #[test]
    fn fitness_in_range() {
        let individual = Chromosome::new();
        let fitness = individual.fitness();
        assert!(fitness >= 0f32 && fitness <= 1f32);
    }

    #[test]
    fn has_mutated() {
        let mut individual = Chromosome::new();
        let prev_genes = individual.genes.clone();
        individual.mutate();
        individual.mutate();
        individual.mutate();
        individual.mutate();
        assert!(individual.genes != prev_genes);
        assert_eq!(individual.genes.len(), 44);
    }

    #[test]
    fn has_crossovered() {
        let indv1 = Chromosome::new();
        let indv2 = Chromosome::new();
        let mut new_indv = Vec::new();
        new_indv = cross_over(&indv1.genes, &indv2.genes);
        assert_eq!(&new_indv[0..22], &indv1.genes[0..22]);
        assert_eq!(&new_indv[22..44], &indv2.genes[22..44]);
    }

    #[test]
    fn instanciate_crossovered_gene() {
        let indv1 = Chromosome::new();
        let indv2 = Chromosome::new();
        let mut new_indv = Vec::new();
        new_indv = cross_over(&indv1.genes, &indv2.genes);
        let individual = Chromosome {genes: new_indv.to_vec()};
        assert_eq!(new_indv, individual.genes);
    }

    #[test] //May fail due to randomness
    fn get_best_returns_last() {
        let mut pop = Vec::new();
        pop.push(Chromosome::new());
        let indv2 = Chromosome {genes: vec![1; 44]};
        let indv3 = Chromosome {genes: indv2.genes.clone()};
        pop.push(indv2);
        assert_eq!(indv3.genes, get_best(pop));
    }

    #[test]
    fn initial_pop_is_100_sized() {
        let pop = generate_pop();
        assert_eq!(pop.len(), 100);
    }
}