extern crate advent_of_code_2018;
use advent_of_code_2018::*;

use std::str::FromStr;

use std::error::Error;
use std::path::PathBuf;

use std::collections::HashMap;

// cargo watch -cs "cargo run --release --bin day_3"

#[derive(Debug)]
struct Claim {
    id: u32,
    x: u32,
    y: u32,
    w: u32,
    h: u32
}

impl FromStr for Claim {
    type Err = Box<Error>;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        //#123 @ 3,2: 5x4
        let split = s
            .split(|c: char| !c.is_numeric())
            .filter(|s| !s.is_empty())
            .map(|s| s.parse())
            .collect::<Result<Vec<u32>, _>>()?;

        Ok(Claim {
            id: split[0],
            x: split[1],
            y: split[2],
            w: split[3],
            h: split[4]
        })
    }
}

fn main() -> Result<(), Box<Error>> {
    let input = read_file(&PathBuf::from("inputs/3.txt"))?;
    let claims = input.iter().map(|line| line.parse::<Claim>()).collect::<Result<Vec<_>, _>>()?;

    let mut claimed = HashMap::new();
    for claim in &claims {
        for x in claim.x..claim.x+claim.w {
            for y in claim.y..claim.y+claim.h {
                *claimed.entry((x,y)).or_insert(0) += 1;
            }
        }
    }

    let conflicts = claimed.values().filter(|&x| *x > 1).count();
    println!("Conflicts: {}", conflicts);

    let conflict_free = claims.iter().filter(|c| check_for_conflicts(c, &claimed)).collect::<Vec<_>>();

    println!("Conflict free: {:?}", conflict_free);

    Ok(())
}


fn check_for_conflicts(claim: &Claim, claimed: &HashMap<(u32, u32), u32>) -> bool {
    for x in claim.x..claim.x+claim.w {
        for y in claim.y..claim.y+claim.h {
            if claimed.get(&(x,y)).map_or(false, |c| *c > 1) {
                return false;
            }
        }
    }
    true
}