use rayon::prelude::*;
use std::io;
use std::io::prelude::*;
use std::iter;
use std::num::ParseIntError;
use std::process;
use structopt::StructOpt;

#[derive(Debug, StructOpt)]
#[structopt(name = "Day 16: Flawed Frequency Transmission")]
/// Performs the flawed frequency transform of a number.
///
/// See https://adventofcode.com/2019/day/16 for details.
struct Opt {
    /// the offset after which you start reading output
    #[structopt(short = "o", long = "offset", default_value = "0")]
    offset: usize,
    input_repeats: usize,
    fft_repeats: usize,
}

fn main() {
    let stdin = io::stdin();
    let opt = Opt::from_args();

    stdin
        .lock()
        .lines()
        .map(|x| exit_on_failed_assertion(x, "Error reading input"))
        .map(|x| exit_on_failed_assertion(parse(&x), "Input was not a valid recipe"))
        .for_each(|input| {
            println!(
                "{}",
                transform(input, opt.input_repeats, opt.fft_repeats, opt.offset)
                    .into_iter()
                    .map(|c| c.to_string())
                    .collect::<String>()
            );
        });
}

fn exit_on_failed_assertion<A, E: std::error::Error>(data: Result<A, E>, message: &str) -> A {
    match data {
        Ok(data) => data,
        Err(e) => {
            eprintln!("{}: {}", message, e);
            process::exit(1);
        }
    }
}

fn parse(s: &str) -> Result<Vec<i32>, ParseIntError> {
    s.chars().map(|c| c.to_string().parse::<i32>()).collect()
}

fn transform(input: Vec<i32>, input_repeats: usize, fft_repeats: usize, offset: usize) -> Vec<i32> {
    iter::successors(
        Some(
            input
                .iter()
                .cycle()
                .take(input.len() * input_repeats)
                .cloned()
                .collect::<Vec<i32>>(),
        ),
        |input| Some(next_phase(input, offset)),
    )
    .nth(fft_repeats)
    .unwrap()
    .into_iter()
    .skip(offset)
    .take(8)
    .collect()
}

fn next_phase(input: &Vec<i32>, offset: usize) -> Vec<i32> {
    if offset > input.len() / 2 {
        (0..input.len())
            .into_par_iter()
            .map(|digit| {
                if digit < offset {
                    0
                } else {
                    input.iter().skip(digit).sum::<i32>().abs() % 10
                }
            })
            .collect()
    } else {
        (0..input.len())
            .into_par_iter()
            .map(|digit| {
                input
                    .iter()
                    .zip(pattern(digit))
                    .map(|(x, y)| x * y)
                    .sum::<i32>()
                    .abs()
                    % 10
            })
            .collect()
    }
}

fn pattern(digit: usize) -> impl Iterator<Item = i32> {
    iter::repeat(0)
        .take(digit + 1)
        .chain(iter::repeat(1).take(digit + 1))
        .chain(iter::repeat(0).take(digit + 1))
        .chain(iter::repeat(-1).take(digit + 1))
        .cycle()
        .skip(1)
}