aoc17

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

fn blocks(c: char) -> bool{
    c == '#' || c == '~'
}

fn water_below(map :&mut Vec<Vec<char>>, x:usize, y:usize, maxy:usize) {
    println!("water below {} {}",x,y);
    let mut cury = y;
    loop {
        if map[cury][x] == '|' || cury>maxy {
            return;
                }
        if map[cury][x] == '#' {
          break;
        }
        map[cury][x] = '|';
        cury = cury + 1;
    }
    cury=cury-1;

    let mut maxtopy = y;
    let maxcury = cury;
    let mut maxleftx = x;
    let mut maxrightx = x;
    let mut leftx ;
    let mut rightx ;
    //fill
    loop {
        leftx = x;
        while blocks(map[cury+1][leftx-1]) && !blocks(map[cury][leftx-1]) {
            map[cury][leftx-1] = '~';
            leftx = leftx - 1;
        }

        rightx = x;
        while blocks(map[cury+1][rightx+1]) && !blocks(map[cury][rightx+1]) {
            map[cury][rightx+1] = '~';
            rightx = rightx + 1;
        }
        if maxleftx>leftx {
            maxleftx = leftx;
        }
        if maxrightx<rightx {
            maxrightx = rightx;
        }
        if blocks(map[cury][rightx+1]) && blocks(map[cury][leftx-1]) {
            map[cury][x] = '~';
            cury=cury-1;
            if maxtopy > cury {
                maxtopy = cury;
            }
        } else {
            break;
        }
    }
    for i in leftx..rightx+1 {
        map[cury][i] = '|';
    }
    for l in map.iter().skip(maxtopy-2).take(maxcury+4-maxtopy) {
        for c in l.iter().skip(maxleftx-2).take(maxrightx-maxleftx+4) {
            print!("{}",c);
        }
        println!("");
    }

    if map[cury][leftx-1] == '.' {
        // overflow left
        water_below(map, leftx-1,cury, maxy)
    }
    if map[cury][rightx+1] == '.' {
        // overflow right
        water_below(map, rightx+1,cury,maxy)
    }
}

fn main() {

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

    let mut maxy = 0;
    let mut miny = 3000;
    let mut maxx = 0;
    let mut minx = 3000;
    for line in f.lines() {
        let line = line.unwrap();
        let split = line.split(|c| ". =,".contains(c)).collect::<Vec<_>>();
        let direction = *(split.get(0).unwrap()) == "x";
        let base = split.get(1).unwrap().parse::<usize>().ok().unwrap();
        let rstart = split.get(4).unwrap().parse::<usize>().ok().unwrap();
        let rend = split.get(6).unwrap().parse::<usize>().ok().unwrap();
        if direction {
            if maxy < rend {
                maxy = rend;
            }
            if miny > rstart {
                miny = rstart;
            }
            if maxx < base {
                maxx = base;
            }
            if minx > base {
                minx = base;
            }
            for i in rstart..rend+1 {
                map[i][base] = '#';
            }
        } else {
            if maxy < base {
                maxy = base;
            }
            if miny > base {
                miny = base;
            }
            if maxx < rend {
                maxx = rend;
            }
            if minx > rstart {
                minx = rstart;
            }
            for i in rstart..rend+1 {
                map[base][i] = '#';
            }
        }
    }
    println!("{}",miny);
    println!("{}",maxy);
    map[0][500] = '+';
    water_below(&mut map, 500, miny,maxy);

    let mut count = 0;
    let mut count2 = 0;
    for l in map.iter() {
        for c in l.iter() {
            if *c == '~' || *c == '|' {
                count = count +1;
            }
            if *c == '~' {
                count2 = count2 +1;
            }
        }
    }

    for l in map.iter().skip(miny-1).take(maxy-miny+2) {
        for c in l.iter().skip(minx-1).take(maxx-minx+2) {
            print!("{}",c);
        }
        println!("");
    }
    println!("{}",count);
    println!("{}",count2);

}