package aoc.day8

import aoc._
import scala.collection.mutable
import scala.collection.immutable.NumericRange.Exclusive

enum Instruction { case Left, Right }

case class Node(name: String, edges: Array[String]):
  assert(edges.length == 2)
  def go(i: Instruction) = edges(i.ordinal)

object Parser extends CommonParser:
  import Instruction._
  val instruction = ("R" ^^ { _ => Right }) | ("L" ^^ { _ => Left })
  val instructions = rep(instruction)

  val name = """[\dA-Z]{3}""".r
  val node = name ~ "= (" ~ name ~ "," ~ name ~ ")" ^^ {
    case (name ~ _ ~ a ~ _ ~ b ~ _) => Node(name, Array(a, b))
  }

// part 1

val instructions = Parser.parse(Parser.instructions, lines.next()).get.toArray
def nextOf(i: Int) = if i + 1 == instructions.length then 0 else i + 1
val map = lines
  .drop(1) // empty line
  .map(Parser.parse(Parser.node, _).get)
  .map(n => n.name -> n)
  .toMap

def part1 =
  val insRep =
    Iterator.unfold(0)(i => Some(instructions(i), nextOf(i)))
  val steps = insRep
    .scanLeft("AAA")((pos, ins) => map(pos).go(ins))
    .zipWithIndex
    .find(_._1 == "ZZZ")
    .map(_._2)
  println(steps.get)

// part 2
case class State(node: String, insPos: Int):
  def isGood = node.endsWith("Z")
  def next = State(map(node).go(instructions(insPos)), nextOf(insPos))

case class Loop(loopSize: Long, goodPositions: Set[Long]):
  def shiftBy(stepsTaken: Long) =
    val inLoop = stepsTaken % loopSize
    Loop(loopSize, goodPositions.map(v => (v + loopSize - inLoop) % loopSize))

  def scaleTo(newSize: Long) =
    assert(newSize % loopSize == 0)
    val range = Exclusive(0L, newSize, loopSize)
    Loop(newSize, goodPositions.flatMap(v => range.map(r => r + v)))

def getLoop(from: State) =
  val visited = mutable.Map[State, Long]()
  @scala.annotation.tailrec
  def visit(
      s: State,
      idx: Long
  ): (Long, Long) = // returns loop size and steps before loop
    visited.get(s) match
      case None =>
        visited += (s -> idx)
        visit(s.next, idx + 1)
      case Some(value) => (idx - value, value)
  val (loopSize, beforeLoop) = visit(from, 0)
  val goodPos = visited.toIterator
    .filter(_._2 >= beforeLoop)
    .filter(_._1.isGood)
    .map(_._2 - beforeLoop)
    .toSet
  (beforeLoop, Loop(loopSize, goodPos))

def part2 =
  val start =
    map.values.filter(_.name.endsWith("A")).map(n => State(n.name, 0)).toSeq
  val loopInfos = start.map(getLoop)
  val toManuallySimulate = loopInfos.map(_._1).max
  traverse(start, toManuallySimulate) match
    case Right(v) => println(v)
    case Left(states) =>
      val loops = loopInfos.map((before, loop) =>
        loop.shiftBy(toManuallySimulate - before)
      )
      val size = loops.foldLeft(1L)((v, loop) => lcm(v, loop.loopSize))
      if loops.forall(l => l.goodPositions == Set(l.loopSize - 3))
      then // dirty hack from input
        println(toManuallySimulate + size - 3)
      else
        val scaled = loops.map(_.scaleTo(size))
        val res = scaled
          .map(_.goodPositions)
          .foldLeft(scaled.head.goodPositions)((s, pos) => s.intersect(pos))
          .min + toManuallySimulate
        println(res)

def lcm(a: Long, b: Long) =
  @scala.annotation.tailrec
  def gcd(a: Long, b: Long): Long =
    if b == 0 then a
    else gcd(b, a % b)
  a / gcd(a, b) * b

def traverse(states: Seq[State], toSimulate: Long): Either[Seq[State], Long] =
  @scala.annotation.tailrec
  def go(states: Seq[State], steps: Long): Either[Seq[State], Long] =
    if states.forall(_.isGood) then Right(steps)
    else if steps == toSimulate then Left(states)
    else go(states.map(_.next), steps + 1)
  go(states, 0)

@main def Day8(part: Int) = part match
  case 1 => part1
  case 2 => part2