use std::fs::File;
use std::io::prelude::*;
use std::iter;

fn main() {
    /*
    let pattern = EnumeratedCycle::new(vec![0, 1, 0, -1], 1);
    let pattern = pattern
        .map(|(iteration, item)| iter::repeat(item).take(iteration))
        .flatten();
    */

    // part 1
    let f = File::open("input16").expect("unable to load \"input16\"");
    let transmission: Vec<_> = f.bytes().map(|b| (b.unwrap() - b'0') as i64).collect();
    print!("output: ");
    phase_n(transmission, 100)
        .iter()
        .take(8)
        .for_each(|i| print!("{}", i));
    println!();
}

fn phase_n(input: Vec<i64>, phases: usize) -> Vec<i64> {
    let mut output = input;
    for _ in 0..phases {
        output = phase(output)
    }
    output
}

fn phase(input: Vec<i64>) -> Vec<i64> {
    let mut output: Vec<i64> = Vec::with_capacity(input.len());
    for (pos, _) in input.iter().enumerate() {
        let mut pattern = repeated_cycle(vec![0, 1, 0, -1], pos + 1);
        pattern.next();
        let mut value =
            input
                .iter()
                .zip(pattern)
                .map(|(a, b)| (a * b) % 10)
                .fold(0, |i, mut acc| {
                    acc += i;
                    acc
                });
        if value < 0 {
            value *= -1
        }
        output.push(value % 10);
    }
    output
}

fn repeated_cycle(input: Vec<i64>, repeats: usize) -> impl Iterator<Item = i64> {
    input
        .clone()
        .into_iter()
        .map(move |item| iter::repeat(item).take(repeats))
        .flatten()
        .cycle()
}

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

    #[test]
    fn example1() {
        assert_eq!(
            phase(vec![1, 2, 3, 4, 5, 6, 7, 8]),
            vec![4, 8, 2, 2, 6, 1, 5, 8]
        );
        assert_eq!(
            phase(vec![4, 8, 2, 2, 6, 1, 5, 8]),
            vec![3, 4, 0, 4, 0, 4, 3, 8]
        );
        assert_eq!(
            phase(vec![3, 4, 0, 4, 0, 4, 3, 8]),
            vec![0, 3, 4, 1, 5, 5, 1, 8]
        );
        assert_eq!(
            phase(vec![0, 3, 4, 1, 5, 5, 1, 8]),
            vec![0, 1, 0, 2, 9, 4, 9, 8]
        );
    }

    #[test]
    fn example2() {
        let data: Vec<_> = "80871224585914546619083218645595"
            .bytes()
            .map(|i| (i - b'0') as i64)
            .collect();
        assert!(phase_n(data, 100)
            .into_iter()
            .take(8)
            .eq(vec![2, 4, 1, 7, 6, 1, 7, 6]));
    }

    #[test]
    fn example3() {
        let data: Vec<_> = "19617804207202209144916044189917"
            .bytes()
            .map(|i| (i - b'0') as i64)
            .collect();
        assert!(phase_n(data, 100)
            .into_iter()
            .take(8)
            .eq(vec![7, 3, 7, 4, 5, 4, 1, 8]));
    }

    #[test]
    fn example4() {
        let data: Vec<_> = "69317163492948606335995924319873"
            .bytes()
            .map(|i| (i - b'0') as i64)
            .collect();
        assert!(phase_n(data, 100)
            .into_iter()
            .take(8)
            .eq(vec![5, 2, 4, 3, 2, 1, 3, 3]));
    }
}