#![allow(dead_code)]
#![allow(unused_variables)]
#![allow(unused_mut)]
use std::env;
use std::fs::File;
use std::io::Read;

fn sim(w: i64, h: i64, mut pv: Vec<(i64, i64, i64, i64)>) -> Vec<(i64, i64, i64, i64)> {
    for i in 0..pv.len() {
        let (mut px, mut py, vx, vy) = pv[i];
        px += vx;
        py += vy;
        if px < 0 {
            px += w;
        }
        if px >= w {
            px -= w;
        }
        if py < 0 {
            py += h;
        }
        if py >= h {
            py -= h;
        }
        pv[i] = (px, py, vx, vy);
    }
    pv
}

fn main() {
    let args: Vec<String> = env::args().collect();
    let filename = if args.len() == 1 {
        "in/".to_owned() + args[0].split('/').last().unwrap() + ".pzl"
    } else {
        args[1].clone()
    };
    let mut f = File::open(filename).expect("cannot open file");
    let mut content = String::new();
    f.read_to_string(&mut content).expect("cannot read file");
    let lines = content.trim_end().split("\n");

    let mut pv: Vec<(i64, i64, i64, i64)> = Vec::new();
    for line in lines {
        let (s, rest) = line.split_once("p=").unwrap();
        let (s, rest) = rest.split_once(",").unwrap();
        let px = s.parse().unwrap();

        let (s, rest) = rest.split_once(" ").unwrap();
        let py = s.parse().unwrap();

        let (s, rest) = rest.split_once("v=").unwrap();
        let (s, rest) = rest.split_once(",").unwrap();
        let vx = s.parse().unwrap();

        let vy = rest.parse().unwrap();

        pv.push((px, py, vx, vy));
    }

    let w = 101;
    let h = 103;
    //let w = 11;
    //let h = 7;

    let pv_orig = pv.clone();
    for i in 1..=100 {
        pv = sim(w, h, pv);
    }
    let q1 = pv
        .clone()
        .into_iter()
        .filter(|(px, py, vx, vy)| *px > w / 2 && *py < h / 2)
        .collect::<Vec<_>>()
        .len();
    let q2 = pv
        .clone()
        .into_iter()
        .filter(|(px, py, vx, vy)| *px < w / 2 && *py < h / 2)
        .collect::<Vec<_>>()
        .len();
    let q3 = pv
        .clone()
        .into_iter()
        .filter(|(px, py, vx, vy)| *px > w / 2 && *py > h / 2)
        .collect::<Vec<_>>()
        .len();
    let q4 = pv
        .clone()
        .into_iter()
        .filter(|(px, py, vx, vy)| *px < w / 2 && *py > h / 2)
        .collect::<Vec<_>>()
        .len();
    let res1 = q1 * q2 * q3 * q4;

    let mut res2 = 0;
    pv = pv_orig.clone();
    for i in 1.. {
        pv = sim(w, h, pv);
        //println!("{:?}", pv);
        if pv == pv_orig {
            println!("END OF SIM {}", i);
            break;
        }

        let mut diag1 = 0;
        for i in 0..pv.len() {
            let (px, py, vx, vy) = pv[i];
            if py < -px * h / (w / 2) + h {
                diag1 += 1;
            }
        }

        let mut diag2 = 0;
        for i in 0..pv.len() {
            let (px, py, vx, vy) = pv[i];
            if py < px * h / (w / 2) - h {
                diag2 += 1;
            }
        }

        //if diag1 < 110 && diag2 < 110 {
        if i == 7916 {
            res2 = i;
            println!("{}", i);
            let mut m: Vec<Vec<i64>> = vec![vec![0; w as usize]; h as usize];
            for i in 0..pv.len() {
                let (px, py, vx, vy) = pv[i];
                m[py as usize][px as usize] += 1;
            }
            for y in 0..m.len() {
                for x in 0..m[0].len() {
                    if m[y][x] == 0 {
                        print!(" ");
                    } else {
                        print!("{}", m[y][x]);
                    }
                }
                println!();
            }
        }
    }

    println!("res1: {}", res1);
    println!("res2: {}", res2);
    assert_eq!(res1, 221142636);
    assert_eq!(res2, 7916);
}