ah, i am losing my marbles

Signed-off-by: Business Goose <did:plc:hsqwcidfez66lwm3gxhfv5in>

day10/src/button.rs

···
 use crate::switchboard::SwitchBoard;
 use std::str::FromStr;
 
-#[derive(Debug)]
+#[derive(Debug, Eq, PartialEq, Clone)]
 pub struct Button {
-    targets: Vec<usize>,
+    pub targets: Vec<usize>,
 }
 
 impl Button {

day10/src/main.rs

···
     debug: bool,
 }
 
-fn mash_buttons(switchboard: &mut SwitchBoard, buttons: &Vec<Button>) {
+fn mash_buttons(switchboard: &mut SwitchBoard, buttons: &[Button]) -> usize {
+    let mut total_presses = 0;
     while !switchboard.is_solved() {
+        if total_presses > 100 {
+            println!("Max presses reached");
+            break;
+        }
         for i in 0..switchboard.size {
             if !switchboard.is_correct(i) {
-                println!("Lightbulb {} is incorrect", i);
-                let valid_buttons = buttons
+                //                println!("Lightbulb {} is incorrect", i);
+                let mut valid_buttons = buttons
                     .iter()
                     .filter(|b| b.toggles(i))
                     .collect::<Vec<&Button>>();
+                valid_buttons.sort_by(|a, b| a.targets.len().cmp(&b.targets.len()));
+                let distance = switchboard.dist_from_solution();
+                println!(
+                    "Current button options: {:?}, distance: {}",
+                    valid_buttons, distance
+                );
+                for btn in valid_buttons.iter() {
+                    btn.press(switchboard);
+                    total_presses += 1;
+                    if switchboard.dist_from_solution() < distance {
+                        println!("Toggled button {:?}", btn);
+                        println!("Switchboard: {}", switchboard);
+                        break;
+                    } else {
+                        btn.press(switchboard);
+                    }
+                }
+            }
+        }
+    }
+
+    total_presses
+}
+
+fn solve_switches(switchboard: &mut SwitchBoard, buttons: &[Button]) -> usize {
+    let mut opstack: Vec<Button> = Vec::new();
+
+    while !switchboard.is_solved() {
+        if opstack.len() > 10 {
+            println!("Failed in loop, {:?}", opstack);
+            panic!("Too many operations");
+        }
+        println!("Switchboard: {}", switchboard);
+        println!("Current state: {:?}", opstack);
+        // find first switch that is incorrect
+        let first_wrong = switchboard.first_wrong();
+        // if we find a wrong switch, get its index
+        if let Some(index) = first_wrong {
+            // find all buttons that toggle this index
+            let mut valid_buttons = buttons
+                .iter()
+                .filter(|b| b.toggles(index))
+                .collect::<Vec<&Button>>();
+            // don't press the same button twice in a row
+            valid_buttons.retain(|b| !opstack.contains(b));
+            if !valid_buttons.is_empty() {
+                opstack.push(valid_buttons[0].clone());
                 valid_buttons[0].press(switchboard);
-                println!("Toggled button {:?}", valid_buttons[0]);
-                println!("Switchboard: {}", switchboard);
+            } else {
+                let first_button = opstack[1].clone();
+                opstack.clear();
+                switchboard.reset();
+                println!(
+                    "Reset switchboard, first operation will be {:?}",
+                    first_button
+                );
+
+                first_button.press(switchboard);
+                opstack.push(first_button.clone());
             }
         }
     }
+    opstack.len()
 }
 
 fn main() {
···
             buttons.push(button);
         }
 
-        mash_buttons(&mut switchboard, &buttons);
+        solve_switches(&mut switchboard, &buttons);
     }
 
     println!("{}", file);

day10/src/switchboard.rs

···
         }
     }
 
+    pub fn reset(&mut self) {
+        self.lights = vec![false; self.size];
+    }
+
     pub fn is_correct(&self, index: usize) -> bool {
         self.lights[index] == self.target[index]
     }
···
 
     pub fn toggle(&mut self, i: usize) {
         self.lights[i] = !self.lights[i];
+    }
+
+    pub fn dist_from_solution(&self) -> usize {
+        self.lights
+            .iter()
+            .zip(self.target.iter())
+            .filter(|&(a, b)| a != b)
+            .count()
+    }
+
+    pub fn first_wrong(&self) -> Option<usize> {
+        self.lights
+            .iter()
+            .zip(self.target.iter())
+            .enumerate()
+            .position(|(_, (a, b))| a != b)
     }
 }