import OAI.Computability.BinPacking.CookLevin.InitializationMachineAt
import OAI.Computability.BinPacking.CookLevin.ValidityComposition

namespace OAI

namespace BinPackingGames.Foundations.Complexity.CookLevin.PayloadPresenceMachine

open Turing MachineComposition PostfixModel InitializationTemplate
open ClashMachine (State clean emitted)

variable {K Λ σ : Type} [DecidableEq K]

abbrev Alphabet (_ : K) := Bool
abbrev Ports (K : Type) := Fin 9 ↪ K

def presenceMap : Fin 6 ↪ Fin 9 := ⟨![2, 3, 4, 5, 7, 8], by decide⟩

omit [DecidableEq K] in
theorem closing_distinct (slots : Ports K) (j : Fin 6) : slots 6 ≠ (presenceMap.trans slots) j := by
  apply slots.injective.ne
  fin_cases j <;> decide

def closurePorts (slots : Ports K) : OrClosure.Ports K :=
  InitializationMachineAt.closurePorts (presenceMap.trans slots) (slots 6) (closing_distinct slots)

inductive CopyContext where
  | remaining | threshold | closing
  deriving DecidableEq

protected abbrev CopyContext.enumList : List CopyContext := [.remaining, .threshold, .closing]

protected theorem CopyContext.enumList_getElem?_ctorIdx_eq (x : CopyContext) :
    CopyContext.enumList[x.ctorIdx]? = some x := by
  cases x <;> rfl

protected theorem CopyContext.enumList_nodup : CopyContext.enumList.Nodup := by decide

instance : Fintype CopyContext where
  elems := ⟨CopyContext.enumList, CopyContext.enumList_nodup⟩
  complete x := by cases x <;> decide

inductive Label where
  | initialize
  | copy (context : CopyContext) (l : MachineUnaryAffineAt.Label)
  | presence (l : InitializationMachine.Label)
  | orLoop | cleanup | drain
  deriving DecidableEq, Fintype

def presenceLabels : InitializationMachine.Label ↪ Label :=
  ⟨Label.presence, fun _ _ h => by cases h; rfl⟩

def copySource (slots : Ports K) : CopyContext → K
  | .remaining | .closing => slots 0
  | .threshold => slots 1

def copyTarget (slots : Ports K) : CopyContext → K
  | .remaining => slots 2
  | .threshold => slots 4
  | .closing => slots 6

def copyExit (labels : Label ↪ Λ) : CopyContext → Λ
  | .remaining => labels (.copy .threshold .seed)
  | .threshold => labels (.copy .closing .seed)
  | .closing => labels (.presence .guard)

def statement (slots : Ports K) (labels : Label ↪ Λ) (exit : Option Λ) :
    Label → TM2.Stmt (Alphabet (K := K)) Λ (State σ)
  | .initialize => .push (slots 3) (fun _ => false) (.goto fun _ => labels (.copy .remaining .seed))
  | .copy context l => ValidityMachine.Nonempty.copyStatement (copySource slots context) (slots 5)
      (copyTarget slots context) (fun l => labels (.copy context l)) (some (copyExit labels context)) l
  | .presence .done => OrClosure.seed (closurePorts slots) (labels .orLoop)
  | .presence l => InitializationMachineAt.statement (presenceMap.trans slots)
      (presenceLabels.trans labels) l
  | .orLoop => OrClosure.loop (closurePorts slots) (labels .orLoop) (some (labels .cleanup))
  | .cleanup => .pop (slots 2) (fun s _ => s)
      (.pop (slots 4) (fun s _ => s) (.pop (slots 6) (fun s _ => s) (.goto fun _ => labels .drain)))
  | .drain => MachineDrain.drain (slots 3) (labels .drain) exit

structure Ready (slots : Ports K) (base : K → List Bool) (q i : Nat) : Prop where
  boundWord : base (slots 0) = encodeWord q
  indexWord : base (slots 1) = encodeWord i
  empty : ∀ j : Fin 9, j ≠ 0 → j ≠ 1 → j ≠ 7 → j ≠ 8 → base (slots j) = []

theorem Ready.emitted {slots : Ports K} {base : K → List Bool} {q i : Nat}
    (h : Ready slots base q i) (tokens : List Token) :
    Ready slots (emitted (slots 7) (slots 8) base tokens) q i := by
  constructor
  · simpa [ClashMachine.emitted, slots.injective.eq_iff] using h.boundWord
  · simpa [ClashMachine.emitted, slots.injective.eq_iff] using h.indexWord
  · intro j h₀ h₁ h₇ h₈
    simpa [ClashMachine.emitted, slots.injective.eq_iff, h₇, h₈] using h.empty j h₀ h₁ h₇ h₈

def working (slots : Ports K) (base : K → List Bool) (r j d c : Nat) : K → List Bool :=
  Function.update (Function.update (Function.update (Function.update base
    (slots 2) (encodeWord r)) (slots 3) (encodeWord j)) (slots 4) (encodeWord d))
      (slots 6) (encodeWord c)

def steps (q i : Nat) : Nat :=
  1 + (2 * (q + 1) + 1) + (2 * (i + 1) + 1) + (2 * (q + 1) + 1) +
    (InitializationMachine.selectorSteps 0 (q + 1) + (q + 1 + 2)) + 1 + (q + 3)

private theorem chain {A : Type*} {f : A → A} {x y z : A} {n m : Nat}
    (first : f^[n] x = y) (second : f^[m] y = z) : f^[n + m] x = z := by
  rw [Nat.add_comm n m, Function.iterate_add_apply, first, second]

theorem copyTrace (slots : Ports K) (labels : Label ↪ Λ) (exit : Option Λ)
    (program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (State σ))
    (atLabels : ∀ l, program (labels l) = statement slots labels exit l)
    (context : CopyContext) (base : K → List Bool) (n : Nat)
    (sourceWord : base (copySource slots context) = encodeWord n)
    (scratchEmpty : base (slots 5) = []) (targetEmpty : base (copyTarget slots context) = [])
    (ambient : σ) :
    (advance (TM2.step program))^[2 * (n + 1) + 1]
      (some ⟨some (labels (.copy context .seed)), clean ambient, base⟩) =
      some ⟨some (copyExit labels context), clean ambient,
        Function.update base (copyTarget slots context) (encodeWord (n + 1))⟩ := by
  have hs : copySource slots context ≠ slots 5 := by
    cases context <;> exact slots.injective.ne (by decide)
  have hd : copySource slots context ≠ copyTarget slots context := by
    cases context <;> exact slots.injective.ne (by decide)
  have hsd : slots 5 ≠ copyTarget slots context := by
    cases context <;> exact slots.injective.ne (by decide)
  have h := MachineUnaryAffineAt.seededAffineTrace (copySource slots context) (slots 5)
    (copyTarget slots context) hs hd hsd 1 1
    (labels (.copy context .seed)) (labels (.copy context .scan)) (labels (.copy context .restore))
    (some (copyExit labels context)) program
    (atLabels (.copy context .seed)) (atLabels (.copy context .scan)) (atLabels (.copy context .restore))
    base n [] (by simpa using sourceWord) scratchEmpty (ambient, false) none
  simpa only [Nat.one_mul, targetEmpty, List.append_nil, clean] using h

theorem trace (slots : Ports K) (labels : Label ↪ Λ) (exit : Option Λ)
    (program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (State σ))
    (atLabels : ∀ l, program (labels l) = statement slots labels exit l)
    (base : K → List Bool) (q i : Nat) (hi : i < q)
    (ready : Ready slots base q i) (ambient : σ) :
    (advance (TM2.step program))^[steps q i]
      (some ⟨some (labels .initialize), clean ambient, base⟩) =
      some ⟨exit, clean ambient, emitted (slots 7) (slots 8) base (presenceTokens q i)⟩ := by
  have e₂ := ready.empty 2 (by decide) (by decide) (by decide) (by decide)
  have e₃ := ready.empty 3 (by decide) (by decide) (by decide) (by decide)
  have e₄ := ready.empty 4 (by decide) (by decide) (by decide) (by decide)
  have e₅ := ready.empty 5 (by decide) (by decide) (by decide) (by decide)
  have e₆ := ready.empty 6 (by decide) (by decide) (by decide) (by decide)
  let b₀ := Function.update base (slots 3) (encodeWord 0)
  let b₁ := Function.update b₀ (slots 2) (encodeWord (q + 1))
  let b₂ := Function.update b₁ (slots 4) (encodeWord (i + 1))
  let b₃ := Function.update b₂ (slots 6) (encodeWord (q + 1))
  have hinit : (advance (TM2.step program))^[1]
      (some ⟨some (labels .initialize), clean ambient, base⟩) =
      some ⟨some (labels (.copy .remaining .seed)), clean ambient, b₀⟩ := by
    change some (TM2.stepAux (program (labels .initialize)) _ _) = _
    rw [atLabels, statement]
    simp [TM2.stepAux, e₃, b₀, encodeWord]
  have hr := copyTrace slots labels exit program atLabels .remaining b₀ q
    (by simpa [b₀, copySource, slots.injective.eq_iff] using ready.boundWord)
    (by simpa [b₀, slots.injective.eq_iff] using e₅)
    (by simpa [b₀, copyTarget, slots.injective.eq_iff] using e₂) ambient
  have ht := copyTrace slots labels exit program atLabels .threshold b₁ i
    (by simpa [b₁, b₀, copySource, slots.injective.eq_iff] using ready.indexWord)
    (by simpa [b₁, b₀, slots.injective.eq_iff] using e₅)
    (by simpa [b₁, b₀, copyTarget, slots.injective.eq_iff] using e₄) ambient
  have hc := copyTrace slots labels exit program atLabels .closing b₂ q
    (by simpa [b₂, b₁, b₀, copySource, slots.injective.eq_iff] using ready.boundWord)
    (by simpa [b₂, b₁, b₀, slots.injective.eq_iff] using e₅)
    (by simpa [b₂, b₁, b₀, copyTarget, slots.injective.eq_iff] using e₆) ambient
  let loopBase := Function.update base (slots 6) (encodeWord (q + 1))
  have hprepared : b₃ = InitializationMachineAt.tapes (presenceMap.trans slots)
      loopBase (q + 1) 0 (i + 1) (base (slots 7)) (base (slots 8)) := by
    apply ClashMachine.Full.ext_slots slots
    · intro j
      fin_cases j <;> simp [b₃, b₂, b₁, b₀, loopBase, InitializationMachineAt.tapes,
        InitializationMachineAt.frame, InitializationMachineAt.contents, presenceMap,
        slots.injective.eq_iff, e₅]
    · intro k hk
      simp [b₃, b₂, b₁, b₀, loopBase, InitializationMachineAt.tapes,
        InitializationMachineAt.frame, presenceMap, hk]
  have agrees : InitializationMachineAt.Agrees (presenceMap.trans slots)
      (presenceLabels.trans labels) program := by
    intro l hl
    change program (labels (.presence l)) =
      InitializationMachineAt.statement (presenceMap.trans slots) (presenceLabels.trans labels) l
    have h := atLabels (.presence l)
    cases l <;> try contradiction
    all_goals simpa only [statement] using h
  have hp := InitializationMachineAt.presenceTrace (presenceMap.trans slots) (presenceLabels.trans labels)
    (slots 6) (closing_distinct slots) (labels .orLoop) (some (labels .cleanup)) program agrees
    (atLabels (.presence .done)) (atLabels .orLoop) loopBase q i []
    (base (slots 7)) (base (slots 8)) (by simp [loopBase]) ambient
  dsimp only at hp
  let selected := InitializationMachineAt.tapes (presenceMap.trans slots) loopBase
    0 (q + 1) (i + 1 - (q + 1))
    ((tokenBits (selectorLoopTokens (q + 1) 0 (i + 1))).reverse ++ base (slots 7))
    (List.replicate (3 * (q + 1)) true ++ base (slots 8))
  let result := emitted (slots 7) (slots 8) base (presenceTokens q i)
  let produced := working slots result 0 (q + 1) 0 0
  have hsub : i + 1 - (q + 1) = 0 := by omega
  have hproduced : OrClosure.frame (closurePorts slots) selected (encodeWord 0 ++ [])
      ((tokenBits (presenceTokens q i)).reverse ++ base (slots 7))
      (List.replicate (4 * (q + 1) + 1) true ++ base (slots 8)) = produced := by
    apply ClashMachine.Full.ext_slots slots
    · intro j
      fin_cases j <;> simp [produced, working, result, emitted, OrClosure.frame,
        selected, closurePorts, InitializationMachineAt.closurePorts,
        InitializationMachineAt.tapes, InitializationMachineAt.frame,
        InitializationMachineAt.contents, presenceMap, loopBase, hsub,
        slots.injective.eq_iff, presenceTokens_length, e₅]
    · intro k hk
      simp [produced, working, result, emitted, OrClosure.frame,
        selected, closurePorts, InitializationMachineAt.closurePorts,
        InitializationMachineAt.tapes, InitializationMachineAt.frame, presenceMap, loopBase, hk]
  change (advance (TM2.step program))^[InitializationMachine.selectorSteps 0 (q + 1) + (q + 1 + 2)]
    (some ⟨some (labels (.presence .guard)), clean ambient,
      InitializationMachineAt.tapes (presenceMap.trans slots) loopBase
        (q + 1) 0 (i + 1) (base (slots 7)) (base (slots 8))⟩) =
    some ⟨some (labels .cleanup), clean ambient,
      OrClosure.frame (closurePorts slots) selected (encodeWord 0 ++ [])
        ((tokenBits (presenceTokens q i)).reverse ++ base (slots 7))
        (List.replicate (4 * (q + 1) + 1) true ++ base (slots 8))⟩ at hp
  rw [← hprepared, hproduced] at hp
  let cleared := Function.update (Function.update (Function.update produced (slots 2) [])
    (slots 4) []) (slots 6) []
  have hcleanup : (advance (TM2.step program))^[1]
      (some ⟨some (labels .cleanup), clean ambient, produced⟩) =
      some ⟨some (labels .drain), clean ambient, cleared⟩ := by
    change some (TM2.stepAux (program (labels .cleanup)) _ _) = _
    rw [atLabels, statement]
    simp [TM2.stepAux, produced, working, encodeWord, cleared, slots.injective.eq_iff]
  have hcurrent : cleared (slots 3) = encodeWord (q + 1) := by
    simp [cleared, produced, working, slots.injective.eq_iff]
  have hd := MachineDrain.drainTrace (slots 3) (labels .drain) exit program (atLabels .drain)
    cleared (encodeWord (q + 1)) (ambient, false) none
  rw [← hcurrent, Function.update_eq_self] at hd
  rw [hcurrent, encodeWord_length] at hd
  have hfinish : Function.update cleared (slots 3) [] = result := by
    apply ClashMachine.Full.ext_slots slots
    · intro j
      fin_cases j <;> simp [cleared, produced, working, result, emitted,
        slots.injective.eq_iff, e₂, e₃, e₄, e₆]
    · intro k hk
      simp [cleared, produced, working, hk]
  rw [hfinish] at hd
  exact chain (chain (chain (chain (chain (chain hinit hr) ht) hc) hp) hcleanup) hd

theorem steps_le (q i : Nat) (hi : i < q) : steps q i ≤ 30 * (q + 2) ^ 2 := by
  have h := InitializationMachineAt.presenceSteps_le q
  unfold steps
  nlinarith

def inTime (slots : Ports K) (labels : Label ↪ Λ) (exit : Option Λ)
    (program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (State σ))
    (atLabels : ∀ l, program (labels l) = statement slots labels exit l)
    (base : K → List Bool) (q i : Nat) (hi : i < q)
    (ready : Ready slots base q i) (ambient : σ) :
    StateTransition.EvalsToInTime (TM2.step program)
      ⟨some (labels .initialize), clean ambient, base⟩
      (some ⟨exit, clean ambient, emitted (slots 7) (slots 8) base (presenceTokens q i)⟩)
      (30 * (q + 2) ^ 2) where
  steps := steps q i
  evals_in_steps := by
    change (advance (TM2.step program))^[steps q i] _ = _
    exact trace slots labels exit program atLabels base q i hi ready ambient
  steps_le_m := steps_le q i hi

end BinPackingGames.Foundations.Complexity.CookLevin.PayloadPresenceMachine

end OAI