path: root/src/layout.rs

use crate::config::*;

use rand::prelude::*;
use std::fmt;

#[derive(Copy, Clone)]
pub struct Prelayout {
    standard_columns: [[char; 3]; 6],
    index_columns: [[char; 6]; 2],
}

impl Prelayout {
    pub fn get_standard_column(&self, index: usize) -> &[char; 3] {
        &self.standard_columns[index]
    }

    pub fn get_index_column(&self, index: usize) -> &[char; 6] {
        &self.index_columns[index]
    }

    pub fn new_random_from<R: RngCore>(pl: &Prelayout, rng: &mut R) -> Prelayout {
        let mut standard_columns = pl.standard_columns.clone();
        let mut index_columns = pl.index_columns.clone();

        let mut count = rng.gen_range(1..=NUM_KEYS - 1);
        while count > 0 {
            let source_index: bool = rng.gen();
            let target_index: bool = rng.gen();

            let saved;
            let target_col: usize;
            let target_idx: usize;
            if target_index {
                target_col = rng.gen_range(0..2);
                target_idx = rng.gen_range(0..6);
                saved = index_columns[target_col][target_idx];
            } else {
                target_col = rng.gen_range(0..6);
                target_idx = rng.gen_range(0..3);
                saved = standard_columns[target_col][target_idx];
            }

            let source_col: usize;
            let source_idx: usize;
            if source_index {
                source_col = rng.gen_range(0..2);
                source_idx = rng.gen_range(0..6);
                if target_index {
                    index_columns[target_col][target_idx] = index_columns[source_col][source_idx];
                } else {
                    standard_columns[target_col][target_idx] =
                        index_columns[source_col][source_idx];
                }
                index_columns[source_col][source_idx] = saved;
            } else {
                source_col = rng.gen_range(0..6);
                source_idx = rng.gen_range(0..3);
                if target_index {
                    index_columns[target_col][target_idx] =
                        standard_columns[source_col][source_idx];
                } else {
                    standard_columns[target_col][target_idx] =
                        standard_columns[source_col][source_idx];
                }
                standard_columns[source_col][source_idx] = saved;
            }
            count -= 1;
        }
        Prelayout {
            standard_columns,
            index_columns,
        }
    }

    fn from_char_array(ca: &[char; NUM_KEYS]) -> Prelayout {
        let mut standard_columns = [['x'; 3]; 6];
        let mut index_columns = [['x'; 6]; 2];

        for i in 0..6 {
            let ind = if i < 3 { i } else { i + 4 };
            for j in 0..3 {
                standard_columns[i][j] = ca[ind + j * ROW_LENGTH];
            }
        }

        for j in 0..3 {
            index_columns[0][j] = ca[3 + j * ROW_LENGTH];
            index_columns[1][j] = ca[6 + j * ROW_LENGTH];
            index_columns[0][j + 3] = ca[4 + j * ROW_LENGTH];
            index_columns[1][j + 3] = ca[5 + j * ROW_LENGTH];
        }

        Prelayout {
            standard_columns,
            index_columns,
        }
    }

    fn to_char_array(&self) -> [char; NUM_KEYS] {
        let mut result = ['x'; NUM_KEYS];

        for i in 0..6 {
            let ind = if i < 3 { i } else { i + 4 };
            for j in 0..3 {
                result[ind + j * ROW_LENGTH] = self.standard_columns[i][j];
            }
        }

        for j in 0..3 {
            result[3 + j * ROW_LENGTH] = self.index_columns[0][j];
            result[6 + j * ROW_LENGTH] = self.index_columns[1][j];
            result[4 + j * ROW_LENGTH] = self.index_columns[0][j + 3];
            result[5 + j * ROW_LENGTH] = self.index_columns[1][j + 3];
        }

        result
    }
}

#[derive(Copy, Clone)]
pub struct Layout {
    keys: [char; NUM_KEYS],
    // index in KEY_CHAR -> index in layout
    translate_index: [usize; NUM_KEYS],
}

impl Layout {
    pub fn as_prelayout(&self) -> Prelayout {
        Prelayout::from_char_array(&self.keys)
    }

    pub fn from_prelayout(pl: &Prelayout) -> Layout {
        // TODO: something more clever about permuting colums, keys within columns etc
        Layout::char_array_to_layout(pl.to_char_array())
    }

    fn char_array_to_layout(layout: [char; NUM_KEYS]) -> Layout {
        let mut translate_index: [usize; NUM_KEYS] = [0; NUM_KEYS];

        for (i, seek) in KEY_CHARS.iter().enumerate() {
            for (j, found) in layout.iter().enumerate() {
                if seek == found {
                    translate_index[i] = j;
                }
            }
        }

        return Layout {
            keys: layout,
            translate_index,
        };
    }

    pub fn get_key(&self, index: usize) -> char {
        self.keys[index]
    }

    pub fn translate_index(&self, i: usize) -> usize {
        self.translate_index[i]
    }

    pub fn from_verbose(inp: &str) -> Option<Layout> {
        let mut layout: [char; NUM_KEYS] = ['x'; NUM_KEYS];

        let mut k: usize = 0;
        for c in inp.chars() {
            let valid = (c.is_uppercase() && c.is_alphabetic())
                || c == '.'
                || c == '/'
                || c == ','
                || c == '\'';
            if valid {
                layout[k] = c;
                k += 1;
            }
            if k > NUM_KEYS {
                return None;
            }
        }

        return Some(Layout::char_array_to_layout(layout));
    }

    // pub fn new_random_from<R: RngCore>(kbd: &Layout, rng: &mut R) -> Layout {
    //     let mut layout = kbd.keys;
    //     // layout.shuffle(rng);
    //     let mut count = rng.gen_range(1..=NUM_KEYS / 2);
    //     while count > 0 {
    //         let a = rng.gen_range(0..NUM_KEYS);
    //         let b = rng.gen_range(0..NUM_KEYS);
    //         let k = layout[b];
    //         layout[b] = layout[a];
    //         layout[a] = k;
    //         count -= 1;
    //     }
    //     Layout::char_array_to_layout(layout)
    // }
}

impl fmt::Display for Layout {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str(&format_block_output(self.keys.into_iter()))
    }
}

#[derive(Copy, Clone)]
pub struct Evaluation {
    keypress: [u32; NUM_KEYS],
    total_keypress: u32,
    sfb: [u32; 8],
}

impl Evaluation {
    pub fn new(keypress: [u32; NUM_KEYS], total_keypress: u32, sfb: [u32; 8]) -> Evaluation {
        Evaluation {
            keypress,
            sfb,
            total_keypress,
        }
    }

    fn output_eval(&self) -> String {
        let mut result = String::new();
        let tot = self.total_keypress as f32;

        result += &format!(
            "Total keypresses: {}\nPercent per key:\n",
            self.total_keypress
        );
        result += &format_block_output(self.keypress.into_iter().map(|k| 100.0 * k as f32 / tot));

        let mut finger_usages = [0; 8];
        for (i, &c) in self.keypress.iter().enumerate() {
            finger_usages[KEY_TO_FINGER[i]] += c;
        }

        result += "finger usage: ";
        for (i, &u) in finger_usages.iter().enumerate() {
            result += &format!(
                "{:>5.2}%{}",
                u as f32 / tot * 100.0,
                if i < 7 { ", " } else { "" }
            );
        }

        result += "\nsame finger bigrams: ";
        for (i, &u) in self.sfb.iter().enumerate() {
            result += &format!(
                "{:>6.3}%{}",
                u as f32 / tot * 100.0,
                if i < 7 { ", " } else { "" }
            );
        }

        let sfb = self.sfb.iter().sum::<u32>();
        result += &format!("\ntotal sfb: {:.2}% ({})", sfb as f32 / tot * 100.0, sfb);

        return result;
    }

    // TODO
    // pub fn fitness(&self) -> f32 {
    // let mut finger_usages = [0; 8];
    // let tot = self.total_keypress as f32;
    // for (i, &c) in self.keypress.iter().enumerate() {
    //     finger_usages[KEY_TO_FINGER[i]] += c;
    // }
    // const MAX_FINGER_USAGES: [f32; 8] = [8.0, 11.0, 21.0, 21.0, 21.0, 21.0, 11.0, 8.0];
    // const MAX_FINGER_USAGES: [f32; 8] =
    //     [100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0];
    // if finger_usages
    //     .iter()
    //     .enumerate()
    //     .any(|(i, &c)| c as f32 / tot * 100.00 > MAX_FINGER_USAGES[i])
    // {
    //     std::u32::MAX
    // } else {
    // self.sfb
    //     .iter()
    //     .enumerate()
    //     .map(|(i, &s)| s as f32 / finger_usages[i] as f32 * 50.0)
    //     .sum()
    // }
    // self.sfb.iter().sum::<u32>() as f32
    // }
}

impl fmt::Display for Evaluation {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str(&self.output_eval())
    }
}

// This is a silly amount of work to genericise the below...
trait ToMyString {
    const BLANK_STRING: &'static str;
    fn to_my_string(&self) -> String;
}

impl ToMyString for char {
    const BLANK_STRING: &'static str = " ";
    fn to_my_string(&self) -> String {
        self.to_string()
    }
}

impl ToMyString for u32 {
    const BLANK_STRING: &'static str = "     ";
    fn to_my_string(&self) -> String {
        format!("{:5}", *self)
    }
}

impl ToMyString for f32 {
    const BLANK_STRING: &'static str = "    ";
    fn to_my_string(&self) -> String {
        format!("{:>4.1}", *self)
    }
}

fn format_block_output<T: Iterator<Item = S>, S: ToMyString>(things: T) -> String {
    let mut result = String::new();
    for (i, t) in things.enumerate() {
        result += &t.to_my_string();
        if i < NUM_KEYS - 1 {
            result.push(' ');
        }
        if (i + 1) % 10 == 0 {
            result.push('\n');
            if NUM_KEYS < 30 && i == 19 {
                result += S::BLANK_STRING;
                result.push(' ')
            }
        } else if (i < 20 && (i + 1) % 5 == 0) || (i == (NUM_KEYS - 20) / 2 + 19) {
            result.push(' ');
        }
        if i + 1 >= NUM_KEYS {
            break;
        }
    }
    return result;
}