use std::{env, fs};
use std::collections::{HashMap, HashSet, VecDeque};
use Module::{Broadcaster, Conjunction, FlipFlop, Counter};
use crate::PulseKind::{High, Low};

#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
enum PulseKind { High, Low }

#[derive(Clone, Debug)]
struct Pulse { kind: PulseKind, origin: String, destination: String }

enum Module {
    Broadcaster { out: Vec<String> },
    Conjunction { out: Vec<String>, memory: HashMap<String, PulseKind> },
    FlipFlop { out: Vec<String>, state: bool },
    Counter { out: Vec<String>, high: i32, low: i32}
}

fn main() {
    println!("Hello, AoC day 19!");

    let args: Vec<String> = env::args().collect();
    if args.len() != 2 {
        println!("wrong number of arguments!");
        std::process::exit(1);
    }

    let file_path = &args[1];
    let contents = fs::read_to_string(file_path).expect("Should have been able to read the file");

    let mut rack: HashMap<String, Module> = HashMap::new();
    for line in contents.lines() {
        let (name, connections) = line.split_once(" -> ").unwrap();
        let outputs: Vec<String> = connections.split(", ").map(|it| it.to_string()).collect();
        match name.chars().nth(0).unwrap() {
            '&' => rack.insert(name[1..].to_string(), Conjunction { out: outputs, memory: HashMap::new() } ),
            '%' => rack.insert(name[1..].to_string(), FlipFlop { out: outputs, state: false } ),
            _ => rack.insert(name.to_string(), Broadcaster { out: outputs } ),
        };
    }

    // print out the rack and also tally up the listed outputs
    println!("the rack looks like this:");
    let mut all_listed_outputs: HashSet<String> = HashSet::new();
    for (key, value) in &rack {
        match value {
            Broadcaster { out } => {
                println!("{} -> {}", key, out.join(", "));
                for o in out { all_listed_outputs.insert(o.to_string()); }
            }
            Conjunction { out, .. } => {
                println!("&{} -> {}", key, out.join(", "));
                for o in out { all_listed_outputs.insert(o.to_string()); }
            }
            FlipFlop { out, .. } => {
                println!("%{} -> {}", key, out.join(", "));
                for o in out {  all_listed_outputs.insert(o.to_string()); }
            }
            Counter { out, .. } => {
                println!("${} -> {}", key, out.join(", "));
                for o in out {  all_listed_outputs.insert(o.to_string()); }
            }
        }
    }
    // make sure all the outputs are present as outputs
    for label in all_listed_outputs {
        if rack.get(&label).is_none() {
            rack.insert(label, Counter{ out: Vec::new(), high: 0, low: 0});
        }
    }

    println!("let's fix up those conjunction modules so they know about all their inputs and are initialized properly to low.");
    let mut conjunctions_and_inputs: HashMap<String, Vec<String>> = HashMap::new();

    // go through and take note of every cnojunction module in our conjunctions_and_inputs collection
    for (label, _module) in &rack {
        match rack.get(label).unwrap() {
            Conjunction{ out:_,memory:_} => { conjunctions_and_inputs.insert(label.to_string(), Vec::new()); }
            _ => {} // get fucked!!!
        };
    }

    // look at every module. if it's got a conjunction in the output, list it in the collection of conjunctions and inputs
    for (label, value) in &rack {
        match value {
            Broadcaster{ out } => {
                for o in out {
                    if let Conjunction { .. } = rack.get(o).unwrap() {
                        conjunctions_and_inputs.get_mut(o).unwrap().push(label.to_string())
                    }
                }
            }
            Conjunction{ out, .. } => {
                for o in out {
                    if let Conjunction { .. } = rack.get(o).unwrap() {
                        conjunctions_and_inputs.get_mut(o).unwrap().push(label.to_string())
                    }
                }
            }
            FlipFlop{ out, .. } => {
                for o in out {
                    if let Conjunction { .. } = rack.get(o).unwrap() {
                        conjunctions_and_inputs.get_mut(o).unwrap().push(label.to_string())
                    }
                }
            }
            Counter { out, .. } => {
                for o in out {
                    if let Conjunction { .. } = rack.get(o).unwrap() {
                        conjunctions_and_inputs.get_mut(o).unwrap().push(label.to_string())
                    }
                }
            }
        }
    }

    // connect each input t othe cnojunctino module
    for (destination, inputs) in conjunctions_and_inputs {
        for start in inputs {
            connect(start, destination.to_string(), &mut rack);
        }
    }

    let mut high = 0;
    let mut low = 0;
    for _i in 0..1000 {
        let (h, l) = push_the_button_and_count(&mut rack);
        println!("there were {high} high pulses and {low} low pulses.");
        high += h;
        low += l;
    }
    println!("after 1000 pushes, we have sent {low} low pulses and {high} high pulses");
    let product = (high as i64) * (low as i64);
    println!("that's aproduct of {product}");

    println!("the set of things outputting to rx is:");
    let mut goes_to_rx: HashSet<String> = HashSet::new();
    for (name, module) in &rack {
        match module {
            Broadcaster { out, .. } => { if out.contains(&String::from("rx")) {goes_to_rx.insert(name.to_string());} }
            Conjunction { out, .. } => {if out.contains(&String::from("rx")) {goes_to_rx.insert(name.to_string());}}
            FlipFlop { out, .. } => {if out.contains(&String::from("rx")) {goes_to_rx.insert(name.to_string());}}
            Counter { out, .. } => {if out.contains(&String::from("rx")) {goes_to_rx.insert(name.to_string());}}
        }
    }
    println!("{goes_to_rx:?}");
    if let Conjunction{memory, ..} = rack.get(goes_to_rx.iter().nth(0).unwrap()).unwrap() {
        for x in memory.keys() {
            print!("{x}, ");
        }
        println!("are all options for what we're interestd in");
    }

    let things_to_watch: HashSet<String> = String::from("qq,sj,ls,bg").split(',').map(|x| x.to_string()).collect();
    let mut i=1001;
    loop {
        let interest = push_the_button_and_watch(&mut rack, &things_to_watch, goes_to_rx.iter().nth(0).unwrap().to_string());

        if interest {
            println!("interesting things have happened on press {i}");
        }


        if i % 100_000 == 0 {
            if let Counter { low, .. } = rack.get("rx").unwrap() {
                println!("rx has been hit with a low pulse {low} times after {i} buttons.");
            }
        }
        i+=1
    }


}

fn connect(origin: String, dest_conj: String, rack: &mut HashMap<String, Module>) {
    let conjunction_module = rack.get_mut(&dest_conj).unwrap();
    if let Conjunction { memory, ..} = conjunction_module {
        memory.insert(origin, Low);
    }
}

fn push_the_button_and_count(rack: &mut HashMap<String, Module>) -> (i32, i32) {
    let mut pulses = VecDeque::from([Pulse {
        kind: Low,
        origin: String::from("button"),
        destination: String::from("broadcaster") }]);
    let mut high = 0;
    let mut low = 0;
    while !pulses.is_empty() {
        let pulse = pulses.pop_front().unwrap();
        let _origin = pulse.origin.to_string();
        let _dest = pulse.destination.to_string();
        let _kind = match pulse.kind {
            High => { "high" }
            Low => { "low" }
        };
        //println!("{origin} -{kind}-> {dest}");
        match pulse.kind {
            High => { high += 1; }
            Low => { low += 1; }
        }
        let new_pulses = handle_pulse(&pulse, rack);
        for x in new_pulses {
            pulses.push_back(x);
        }
    }
    return (high, low);
}

fn push_the_button_and_watch(rack: &mut HashMap<String, Module>,
                             modules_to_watch: &HashSet<String>,
                             conjunction: String) -> bool {
    let mut pulses = VecDeque::from([Pulse {
        kind: Low,
        origin: String::from("button"),
        destination: String::from("broadcaster") }]);
    let mut high = 0;
    let mut low = 0;
    let mut of_interest = false;
    while !pulses.is_empty() {
        let pulse = pulses.pop_front().unwrap();

        let _origin = pulse.origin.to_string();
        let _dest = pulse.destination.to_string();
        let _kind = match pulse.kind {
            High => { "high" }
            Low => { "low" }
        };

        if modules_to_watch.contains(&_origin) && pulse.kind == Low {
            if let Conjunction {memory, ..} = &rack.get(&conjunction).unwrap() {
                let pulses: HashSet<&PulseKind>= modules_to_watch.iter().map(|x| memory.get(x).unwrap()).collect();
                if pulses.contains(&High) {
                    of_interest = true;
                }
            }
        }

        //println!("{origin} -{kind}-> {dest}");
        let new_pulses = handle_pulse(&pulse, rack);
        for x in new_pulses {
            pulses.push_back(x);
        }
    }
    return of_interest;
}

fn handle_pulse(pulse: &Pulse, rack: &mut HashMap<String, Module>) -> Vec<Pulse> {
    // a pulse has arrived!~ let's handle it.
    let destination_module = rack.get_mut(&pulse.destination).unwrap();

    match destination_module {
        Broadcaster{ out } => {
            // broadcast to all the outputs!
            return out.iter().map(|d| Pulse {
                kind: pulse.kind,
                origin: pulse.destination.to_string(),
                destination: d.to_string() }).collect(); }

        Conjunction{ out, memory} => {
            // update the memory.
            memory.insert(pulse.origin.to_string(), pulse.kind);

            // go through the memories and look for one thats low, in which case we output a low pulse.
            for value in memory.values() {
                if *value == Low {
                    // if any of the memories is low, output a high pulse
                    return out.iter().map(|d| Pulse {
                        kind: High,
                        origin: pulse.destination.to_string(),
                        destination: d.to_string() }).collect();
                }
            }

            // if we've gotten here, all the memories were high, so send a low pulse
            out.iter().map(|d| Pulse {
                kind: Low,
                origin: pulse.destination.to_string(),
                destination: d.to_string() }).collect()}

        FlipFlop{ out, state} => {
            match pulse.kind {
                High => {
                    // on a high pulse, flip flops produce nothijng
                    Vec::new()
                },
                Low => {
                    // on a low pulse, we flip it, and then send an appropriate pulse (high if it's on, low if it's off)
                    *state = !*state;
                    out.iter().map(|d| Pulse {
                        kind: match state { true => High, false => Low },
                        origin: pulse.destination.to_string(),
                        destination: d.to_string() }).collect()
                }
            }
        }

        Counter { high, low, ..} => {
            match pulse.kind {
                High => {
                    *high += 1;
                },
                Low => {
                    *low += 1;
                }
            }
            Vec::new()
        }
    }

}