ToCode

}
      }

    def helper(modules: Map[String, CommunicationModule]): Map[String, CommunicationModule] =
      this.pressButton()
      process(modules)

    def findCycleSize(modules: Map[String, CommunicationModule], end: String): Long =
      val relevantModules = influencedBy(modules, inputs, Set(end))

      val data = LazyList.iterate(modules)(helper).map { modules =>
        modules.view.filterKeys(relevantModules.contains).toMap
      }
      findCycleIndex(data)

    @tailrec
    final def process(modules: Map[String, CommunicationModule]): Map[String, CommunicationModule] =
      if (this.pendingSignals.nonEmpty) {
        val updatedModules = handleSignals(modules)
        this.process(updatedModules)
      } else {
        modules
      }
  }

  sealed trait CommunicationModule {
    def name: String
  }

  case class FlipFlop(name: String, state: Boolean) extends CommunicationModule
  case class Conjunction(name: String, state: Map[String, Int]) extends CommunicationModule
  case class Broadcaster(name: String) extends CommunicationModule
  case class UntypedModule(name: String) extends CommunicationModule

  def parseInput(input: Source): (Map[String, CommunicationModule], Map[String, List[String]], Map[String, List[String]]) =

    input
      .getLines()
      .concat(List("button -> broadcaster"))
      .map { line => line.split(" -> ") }
      .collect { case Array(name, outputs) =>
        val outputModules = outputs.split(", ").toList
        val module = name match
          case "broadcaster" => Broadcaster(name)
          case s"%${name}" => FlipFlop(name, false)
          case s"&${name}" => Conjunction(name, Map[String, Int]())
          case s"${name}" => UntypedModule(name)
        (module, outputModules)

      }.foldLeft((
        Map[String, CommunicationModule](),
        Map[String, List[String]](),
        Map[String, List[String]]())) { (a, v) =>
        val (modules, inputs, outputs) = a
        val (newModule, itsOutputs) = v
        val newName = newModule.name

        val updatedInputs = itsOutputs.foldLeft(inputs) { (inputs, output) =>
          inputs.updatedWith(output) {
            case Some(existingInputs) => Some(existingInputs :+ newName)
            case None => Some(List(newName))
          }
        }

        val updatedOutputs = outputs.updatedWith(newName) {
          case Some(existingOutputs) => Some(existingOutputs ++ itsOutputs) // unreachable, because there's only one line per module
          case None => Some(itsOutputs)
        }

        val updatedModules = modules.updated(newName, newModule)

        (updatedModules, updatedInputs, updatedOutputs)
      }

  @main
  def day20part1(): Unit =
    val (modules, inputs, outputs) = parseInput(Source.fromResource("day20.txt"))
    println(modules)
    println(inputs)
    println(outputs)
    val runner = Runner(inputs, outputs)
    var round = 0L
    var modules_i = modules

    1.to(1000).foreach { i =>
      runner.pressButton()
      modules_i = runner.process(modules_i)
    }

    println(runner.lowCount)
    println(runner.highCount)
    println(runner.lowCount * runner.highCount)


  @main
  def day20part2(): Unit =
    val (modules, inputs, outputs) = parseInput(Source.fromResource("day20.txt"))
    println(influencedBy(modules, inputs, Set("output")))
    val runner = Runner(inputs, outputs)
    var m = modules

    while (true) {
      m = runner.helper(m)
    }
//    println(runner.findCycleSize(modules, "xf"))
}

import org.neo4j.driver.internal.messaging.request.CommitMessage

import scala.annotation.tailrec
import scala.collection.mutable
import scala.io.Source
import scala.util.chaining._

object aoc2023day20 {
  val HIGH_PULSE = 1
  val LOW_PULSE = -1

  val demoInput: String = """broadcaster -> a, b, c
                            |%a -> b
                            |%b -> c
                            |%c -> inv
                            |&inv -> a""".stripMargin

  val demoInput2: String = """broadcaster -> a
                             |%a -> inv, con
                             |&inv -> b
                             |%b -> con
                             |&con -> output""".stripMargin

  def receive(sender: String, target: CommunicationModule, signal: Int, runner: Runner): CommunicationModule =
    target match
      case cm @ FlipFlop(name, state) if signal == LOW_PULSE && state =>
        runner.sendSignal(LOW_PULSE, name)
        cm.copy(state = false)

      case cm @ FlipFlop(name, state) if signal == LOW_PULSE && !state =>
        runner.sendSignal(HIGH_PULSE, name)
        cm.copy(state = true)

      case cm @ Conjunction(name, state) =>
        val updatedState = runner.inputs(name).map {
          case i if i == sender => Map(sender -> signal)
          case i if state.contains(i) => Map(i -> state(i))
          case i => Map(i -> LOW_PULSE)
        }.foldLeft(Map[String, Int]())(_ ++ _)

        if (updatedState.values.forall(_ == HIGH_PULSE)) {
          runner.sendSignal(LOW_PULSE, name)
        } else {
          runner.sendSignal(HIGH_PULSE, name)
        }

        cm.copy(state = updatedState)

      case cm @ Broadcaster(name) =>
        runner.sendSignal(signal, name)
        cm

      case _ => target

  @tailrec
  def influencedBy(modules: Map[String, CommunicationModule],
                   inputs: Map[String, List[String]],
                   searching: Set[String] = Set(),
                   found: Set[String] = Set()): Set[String] =
    if (searching.isEmpty) {
      found
    } else {
      val nextModule = searching.head
      val nextSearching = searching ++ inputs.getOrElse(nextModule, List()) - nextModule -- found
      val nextFound = found + nextModule

      influencedBy(modules,
        inputs,
        nextSearching,
        nextFound)
    }

  def findCycleIndex[T](data: Seq[T]): Long =
    data
      .scanLeft(Some(Set()): Option[Set[T]]) {
        case (Some(seen), newItem) if seen.contains(newItem) => None
        case (Some(seen), newItem) => Some(seen + newItem)
        case (None, newItem) => None
      }.zipWithIndex
      .find { (item, index) => item.isEmpty }.get._2 - 1


  class Runner(val inputs: Map[String, List[String]], val outputs: Map[String, List[String]]) {
    val pendingSignals: mutable.Queue[(String, String, Int)] = mutable.Queue()
    var lowCount = 0
    var highCount = 0
    var buttonPresses = 0

    def pressButton(): Unit =
      buttonPresses += 1
      this.sendSignal(LOW_PULSE, "button")

    def sendSignal(signal: Int, from: String): Unit =
      val to = outputs(from)
      if (signal == LOW_PULSE) {
        lowCount += to.size
      } else if (signal == HIGH_PULSE) {
        highCount += to.size
      }

      to.foreach { to =>
        if (to == "gc" && signal == HIGH_PULSE) {
          throw new Exception(s"gc ${this.buttonPresses}")
        }
        this.pendingSignals.enqueue((from, to, signal))
      }

    def handleSignals(modules: Map[String, CommunicationModule]): Map[String, CommunicationModule] =
      this.pendingSignals.dequeueAll((item) => true).foldLeft(modules) { (modules, message) =>
        val (from, to, signal) = message
        println(s"${from} - ${if (signal == -1) "low" else "high"} - ${to}")
        modules.updatedWith(to) {
          case Some(cm) =>
            Some(receive(from, cm, signal, this))
          case _ =>
            println(s"Tried to send signal to untyped module: ${to}")
            None

val updatedInputs = itsOutputs.foldLeft(inputs) { (inputs, output) =>
          inputs.updatedWith(output) {
            case Some(existingInputs) => Some(existingInputs :+ newName)
            case None => Some(List(newName))
          }
        }

        val updatedOutputs = outputs.updatedWith(newName) {
          case Some(existingOutputs) => Some(existingOutputs ++ itsOutputs) // unreachable, because there's only one line per module
          case None => Some(itsOutputs)
        }

        val updatedModules = modules.updated(newName, newModule)

        (updatedModules, updatedInputs, updatedOutputs)
      }

  @main
  def day20part1(): Unit =
    val (modules, inputs, outputs) = parseInput(Source.fromResource("day20.txt"))
    println(modules)
    println(inputs)
    println(outputs)
    val runner = Runner(inputs, outputs)
    var round = 0L
    var modules_i = modules

    1.to(1000).foreach { i =>
      runner.pressButton()
      modules_i = runner.process(modules_i)
    }

    println(runner.lowCount)
    println(runner.highCount)
    println(runner.lowCount * runner.highCount)

&zr -> rx
&gc -> zr
&sz -> zr
&cm -> zr
&xf -> zr

    def sendSignal(signal: Int, from: String): Unit =
      val to = outputs(from)
      if (signal == LOW_PULSE) {
        lowCount += to.size
      } else if (signal == HIGH_PULSE) {
        highCount += to.size
      }

      to.foreach { to =>
        if (to == "gc" && signal == HIGH_PULSE) {
          throw new Exception(s"gc ${this.buttonPresses}")
        }
        this.pendingSignals.enqueue((from, to, signal))
      }

  @tailrec
  def influencedBy(modules: Map[String, CommunicationModule],
                   inputs: Map[String, List[String]],
                   searching: Set[String] = Set(),
                   found: Set[String] = Set()): Set[String] =
    if (searching.isEmpty) {
      found
    } else {
      val nextModule = searching.head
      val nextSearching = searching ++ inputs.getOrElse(nextModule, List()) - nextModule -- found
      val nextFound = found + nextModule

      influencedBy(modules,
        inputs,
        nextSearching,
        nextFound)
    }

    def findCycleSize(modules: Map[String, CommunicationModule], end: String): Long =
      val relevantModules = influencedBy(modules, inputs, Set(end))

      val data = LazyList.iterate(modules)(helper).map { modules =>
        modules.view.filterKeys(relevantModules.contains).toMap
      }
      findCycleIndex(data)

  class Runner(val inputs: Map[String, List[String]], val outputs: Map[String, List[String]]) {
    val pendingSignals: mutable.Queue[(String, String, Int)] = mutable.Queue()
    var lowCount = 0
    var highCount = 0
    var buttonPresses = 0

    def pressButton(): Unit =
      buttonPresses += 1
      this.sendSignal(LOW_PULSE, "button")

    def sendSignal(signal: Int, from: String): Unit =
      val to = outputs(from)
      if (signal == LOW_PULSE) {
        lowCount += to.size
      } else if (signal == HIGH_PULSE) {
        highCount += to.size
      }

      to.foreach { to =>
//        if (to == "xf" && signal == LOW_PULSE) {
//          throw new Exception(s"xf ${this.buttonPresses}")
//        }
        this.pendingSignals.enqueue((from, to, signal))
      }

    def handleSignals(modules: Map[String, CommunicationModule]): Map[String, CommunicationModule] =
      this.pendingSignals.dequeueAll((item) => true).foldLeft(modules) { (modules, message) =>
        val (from, to, signal) = message
        println(s"${from} - ${if (signal == -1) "low" else "high"} - ${to}")
        modules.updatedWith(to) {
          case Some(cm) =>
            Some(receive(from, cm, signal, this))
          case _ =>
            println(s"Tried to send signal to untyped module: ${to}")
            None
        }
      }

    def helper(modules: Map[String, CommunicationModule]): Map[String, CommunicationModule] =
      this.pressButton()
      process(modules)

    def findCycleSize(modules: Map[String, CommunicationModule], end: String): Long =
      val relevantModules = influencedBy(modules, inputs, Set(end))

      val data = LazyList.iterate(modules)(helper).map { modules =>
        modules.view.filterKeys(relevantModules.contains).toMap
      }
      findCycleIndex(data)

    @tailrec
    final def process(modules: Map[String, CommunicationModule]): Map[String, CommunicationModule] =
      if (this.pendingSignals.nonEmpty) {
        val updatedModules = handleSignals(modules)
        this.process(updatedModules)
      } else {
        modules
      }
  }

  def parseInput(input: Source): (Map[String, CommunicationModule], Map[String, List[String]], Map[String, List[String]]) =

    input
      .getLines()
      .concat(List("button -> broadcaster"))
      .map { line => line.split(" -> ") }
      .collect { case Array(name, outputs) =>
        val outputModules = outputs.split(", ").toList
        val module = name match
          case "broadcaster" => Broadcaster(name)
          case s"%${name}" => FlipFlop(name, false)
          case s"&${name}" => Conjunction(name, Map[String, Int]())
          case s"${name}" => UntypedModule(name)
        (module, outputModules)

      }.foldLeft((
        Map[String, CommunicationModule](),
        Map[String, List[String]](),
        Map[String, List[String]]())) { (a, v) =>
        val (modules, inputs, outputs) = a
        val (newModule, itsOutputs) = v
        val newName = newModule.name

broadcaster -> a, b, c
%a -> b
%b -> c
%c -> inv
&inv -> a

  sealed trait CommunicationModule {
    def name: String
  }

  case class FlipFlop(name: String, state: Boolean) extends CommunicationModule
  case class Conjunction(name: String, state: Map[String, Int]) extends CommunicationModule
  case class Broadcaster(name: String) extends CommunicationModule
  case class UntypedModule(name: String) extends CommunicationModule

  def receive(sender: String, target: CommunicationModule, signal: Int, runner: Runner): CommunicationModule =
    target match
      case cm @ FlipFlop(name, state) if signal == LOW_PULSE && state =>
        runner.sendSignal(LOW_PULSE, name)
        cm.copy(state = false)

      case cm @ FlipFlop(name, state) if signal == LOW_PULSE && !state =>
        runner.sendSignal(HIGH_PULSE, name)
        cm.copy(state = true)

      case cm @ Conjunction(name, state) =>
        val updatedState = runner.inputs(name).map {
          case i if i == sender => Map(sender -> signal)
          case i if state.contains(i) => Map(i -> state(i))
          case i => Map(i -> LOW_PULSE)
        }.foldLeft(Map[String, Int]())(_ ++ _)

        if (updatedState.values.forall(_ == HIGH_PULSE)) {
          runner.sendSignal(LOW_PULSE, name)
        } else {
          runner.sendSignal(HIGH_PULSE, name)
        }

        cm.copy(state = updatedState)

      case cm @ Broadcaster(name) =>
        runner.sendSignal(signal, name)
        cm

      case _ => target

(def state (reagent/atom {:foo {:bar "BAR"}
                          :baz "BAZ"
                          :quux "QUUX"}))
;; Now create a cursor
(def bar-cursor (reagent/cursor state [:foo :bar]))

(defn bar-component []
  (js/console.log "bar-component is rendering")
  [:div @bar-cursor])