#[derive(Debug, Clone, PartialEq)]
struct RleRun<T> {
    data : Vec<T>,
    length : usize,
}

impl<T> RleRun<T> {
    pub fn new() -> Self {
        Self {
            data : Vec::new(),
            length : 0,
        }
    }
    pub fn from_data(run_data : Vec<T>, run_length : usize) -> Self {
        Self {
            data : run_data,
            length : run_length,
        }
    }
}

fn find_maximum_run<T: Clone + PartialEq>(input : Vec<T>) -> Option<RleRun<T>> {
    if input.is_empty() {
        return None
    }
    let mut the_run : Vec<T> = vec![input[0].clone()];
    let mut run_data_length : usize = 1;
    let mut run_length : usize = 0;

    let mut found = false;
    while !found {
        let mut j = 0;
        while j < input.len() {
            dbg!(&j);
            if (j + 1) % run_data_length == 0 {
                eprintln!("Incrementing");
                run_length += 1;
                dbg!(&run_length);
            }
            if the_run[j % run_data_length] != input[j] {
                eprintln!("No match");
                the_run.push(input[j].clone());
                run_data_length += 1;
                run_length = 0;
                j = 0;
            }
            else {
                j += 1;
            }
        }
        found = true;
    }
    Some(RleRun::from_data(the_run, run_length))
}

fn main() {
    dbg!(find_maximum_run(vec![1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]));
}