use std::cmp;

pub fn main() {
    let txt = std::fs::read_to_string("./input/day5.txt").unwrap();

    let mut seeds: Vec<(i64, i64)> = vec![];
    let mut rules: Vec<(i64, i64, i64)> = vec![];

    for (i, line) in txt.lines().enumerate() {
        if line != "" {
            // dodaj u vec
            if i != 0 && line.chars().nth(line.len() - 1).unwrap() != ':' {
                let br: Vec<i64> = line.split(" ").map(|s| s.parse().unwrap()).collect();
                rules.push((br[0], br[1], br[2] - 1));
            }
        } else {
            // obradi
            let mut obradjeno: Vec<(i64, i64)> = vec![];
            let mut neobradjeno: Vec<(i64, i64)> = vec![];

            neobradjeno.clear();
            neobradjeno.extend(seeds.clone());

            while neobradjeno.len() != 0 {
                seeds.clear();
                seeds.extend(neobradjeno.clone());
                neobradjeno.clear();

                for seed in &seeds {
                    let mut ind: bool = false;
                    for rule in &rules {
                        let l_seed = seed.0;
                        let r_seed = seed.1;
                        let l_rule = rule.1;
                        let r_rule = rule.1 + rule.2;

                        if r_rule < l_seed || r_seed < l_rule {
                            continue;
                        }
                        ind = true;
                        let levi = cmp::max(l_seed, l_rule);
                        let desni = cmp::min(r_seed, r_rule);
                        obradjeno.push((levi + rule.0 - rule.1, desni + rule.0 - rule.1));

                        if l_seed != levi {
                            neobradjeno.push((l_seed, levi - 1));
                        }

                        if desni != r_seed {
                            neobradjeno.push((desni + 1, r_seed));
                        }
                    }

                    if !ind {
                        obradjeno.push((seed.0, seed.1));
                    }
                }
            }

            seeds = obradjeno;
            rules.clear();
        }

        if seeds.is_empty() && line != "" {
            let x: Vec<i64> = line
                .split(": ")
                .collect::<Vec<_>>()
                .get(1)
                .unwrap()
                .split(" ")
                .map(|s| s.parse().unwrap())
                .collect();

            let mut j = 0;
            while j < x.len() {
                seeds.push((x[j], x[j] + x[j + 1] - 1));
                j += 2;
            }
        }
    }

    let mut min = i64::MAX;
    for seed in seeds {
        if seed.0 < min {
            min = seed.0;
        }
    }

    println!("{}", min);
}