mod config;
mod corpus;
mod layout;

use rayon::prelude::*;

use rand::prelude::*;
use rand_pcg::*;

use corpus::*;
use layout::*;

fn main() {
    let corpus = Corpus::load("new.txt").unwrap();
    println!("{}", corpus);

    let starting_layout = Layout::from_verbose(
        "
        Y W F L M  K P O , Q
        U R S N H  D T E A I
        Z X C V J  B G ' . /
        ",
    )
    .unwrap();

    let mut rng = Pcg64::from_entropy();

    type Fun = Vec<(Layout, u32)>;

    let mut best = std::u32::MAX;
    let mut layouts: Fun = (0..10)
        .into_iter()
        .map(|i| {
            let layout;
            if i >= 0 {
                layout = Layout::new_random_from(&starting_layout, &mut rng);
            } else {
                layout = starting_layout;
            }

            return (layout, corpus.layout_fitness(&layout));
        })
        .collect();

    loop {
        let new_layouts = layouts
            .iter()
            .enumerate()
            .map(|(i, (kbd, _))| {
                if i > 0 {
                    Layout::new_random_from(kbd, &mut rng)
                } else {
                    kbd.clone()
                }
            })
            .collect::<Vec<Layout>>();

        new_layouts
            .par_iter()
            .map(|layout| {
                return (*layout, corpus.layout_fitness(layout));
            })
            .collect_into_vec(&mut layouts);

        layouts.sort_by(|(_, lfit), (_, rfit)| lfit.cmp(rfit));

        if layouts[0].1 < best {
            best = layouts[0].1;
            let evl = corpus.evaluate_layout(&layouts[0].0);
            println!("");
            println!("================================================================================\nLayout:\n{}",
                         layouts[0].0
                    );

            println!("{}\n{}", evl, layouts[0].1);
        }
    }
}