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

#[derive(Debug, PartialEq, Clone)]
struct Eqa<'a> {
    a: &'a str,
    b: &'a str,
    f: fn(bool, bool) -> bool,
}

fn solve(s: &str, vals: &HashMap<&str, bool>, eqs: &HashMap<&str, Eqa>) -> bool {
    if let Some(val) = vals.get(s) {
        return *val;
    }
    if let Some(eq) = eqs.get(s) {
        return (eq.f)(solve(eq.a, vals, eqs), solve(eq.b, vals, eqs));
    }
    panic!()
}

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 (para1, para2) = content.trim_end().split_once("\n\n").unwrap();

    let mut vals: HashMap<&str, bool> = HashMap::new();
    for s in para1.split("\n") {
        let (s, v) = s.split_once(": ").unwrap();
        vals.insert(s, if v == "1" { true } else { false });
    }

    let mut zs: Vec<&str> = Vec::new();
    let mut eqs: HashMap<&str, Eqa> = HashMap::new();
    for s in para2.split("\n") {
        let (a, rest) = s.split_once(" ").unwrap();
        let (op, rest) = rest.split_once(" ").unwrap();
        let (b, s) = rest.split_once(" -> ").unwrap();

        if s.starts_with("z") {
            zs.push(s);
        }

        let e: Eqa = Eqa {
            a: a,
            b: b,
            f: match op {
                "AND" => |a, b| a & b,
                "OR" => |a, b| a | b,
                "XOR" => |a, b| a ^ b,
                _ => panic!(),
            },
        };
        eqs.insert(s, e);
    }
    zs.sort();

    let mut res1: u64 = 0;
    for (i, z) in zs.iter().enumerate() {
        let a = solve(z, &vals, &eqs);
        if a {
            res1 += 1 << i;
        }
        println!("{} {} {}", i, z, a);
    }

    let res2 = 0;
    println!("res1: {}", res1);
    println!("res2: {}", res2);
    //assert_eq!(res1, );
    //assert_eq!(res2, );
}