aoc18

use std::io::{BufReader};
use std::io::prelude::*;
use std::fs::File;
use std::collections::HashMap;

fn nextstate(neighbours: &[char], c: char) -> char {
    //println!("nextstate {:?} {:?}",c, neighbours);
    match c {
        '.'=> if neighbours.iter().cloned().filter(|&d| d == '|').count() >=3 { '|' } else { '.' },
        '|'=> if neighbours.iter().cloned().filter(|&d| d == '#').count() >=3 { '#' } else { '|' },
        '#'=> if neighbours.iter().cloned().filter(|&d| d == '|').count() >=1 &&
             neighbours.iter().cloned().filter(|&d| d == '#').count() >=1 { '#' } else { '.' },
        _ => unreachable!("bad char {}", c)
    }
}

fn neighbours(map: &[[char;50];50], pos: (usize,usize)) -> Vec<(char)> {
    [(-1,-1), (0,-1),(1,-1),
     (-1, 0),        (1, 0),
     (-1, 1), (0, 1),(1, 1)]
         .iter().map(|poo| (poo.0+pos.0 as isize, poo.1+pos.1 as isize) )
    .filter(|pos| pos.0 >= 0 && pos.0<50 && pos.1 >=0 && pos.1 < 50)
    .map(|pos| (map[pos.0 as usize][pos.1 as usize])).collect::<Vec<_>>()
}

fn main() {

    let mut map = [['.'; 50];50];
    let f = File::open("/tmp/input").unwrap();
    let f = BufReader::new(f);

    for (i,line) in f.lines().enumerate() {
        let line = line.unwrap();
        for (j,c) in line.chars().enumerate() {
            map[i][j] = c;
        }
    }

//  for l in map.iter() {
//      for c in l.iter() {
//          print!("{}",c);
//      }
//      println!();
//  }
//      println!();
    let mut othermap = [['.'; 50];50];
    let mut mapstates = HashMap::<Vec<char>, usize>::new();
    let mut mapidx = HashMap::<usize, Vec<char>>::new();
    let mut loopend = 0;
    let mut loopstart = 0;
    for t in 0..1000{

        if t % 2 == 0 {
            let key = map.iter().map(|a| a.iter().cloned()).flatten().collect::<Vec<_>>();
            if mapstates.contains_key(&key) {
                loopend = t;
                loopstart = *(mapstates.get(&key).unwrap());
                println!("loop! {} {}", loopstart, loopend);
                break;
            } else {
                mapstates.insert(map.iter().map(|a| a.iter().cloned()).flatten().collect(), t);
                mapidx.insert(t, map.iter().map(|a| a.iter().cloned()).flatten().collect());
            }
            for i in 0..50 {
                for j in 0..50 {
                    othermap[i][j] = nextstate(&neighbours(&map, (i,j)), map[i][j]);
                }
            }
            //for i in 0..50 {
            //  println!("");
            //}
            //println!("map");
            //for l in othermap.iter() {
            //  for c in l.iter() {
            //      print!("{}",c);
            //  }
            //  println!();
            //}
            //println!();
        } else {
            let key = othermap.iter().map(|a| a.iter().cloned()).flatten().collect::<Vec<_>>();
            if mapstates.contains_key(&key) {
                loopend = t;
                loopstart = *(mapstates.get(&key).unwrap());
                println!("loop! {} {}", loopstart, loopend);
                break;
            } else {
                mapstates.insert(othermap.iter().map(|a| a.iter().cloned()).flatten().collect(), t);
                mapidx.insert(t, othermap.iter().map(|a| a.iter().cloned()).flatten().collect());
            }
            for i in 0..50 {
                for j in 0..50 {
                    map[i][j] = nextstate(&neighbours(&othermap, (i,j)), othermap[i][j]);
                }
            }
            //for i in 0..50 {
            //  println!("");
            //}
            //println!("map");
            //for l in map.iter() {
            //  for c in l.iter() {
            //      print!("{}",c);
            //  }
            //  println!();
            //}
            //println!();
        }
    }
    let cycle_length = loopend - loopstart;
    let nb_cycle = (1000000000-loopstart) / cycle_length;
    let final_idx = 1000000000 - (loopstart + nb_cycle*cycle_length) + loopstart;
    println!("cycle length {} nb cycle {} final idx : {}", cycle_length, nb_cycle, final_idx);
    let mut counttree = 0;
    let mut countlumb = 0;
    for &c in mapidx.get(&final_idx).unwrap().iter() {
            if c == '|' {
                counttree = counttree+1;
            }
            if c == '#' {
                countlumb = countlumb+1;
            }
        }
    println!("{}", counttree*countlumb);
}