import OAI.Computability.BinPacking.CookLevin.ClashMachine

namespace OAI

namespace BinPackingGames.Foundations.Complexity.CookLevin.InitializationMachine

open Turing
open Reduction.MachineSubstitution (pushWord stepAux_pushWord)
open PostfixModel

inductive Tape where
  | remaining | current | threshold | scratch | reversed
  | rawInput | witnessBound | capacity | closure
  deriving DecidableEq

protected abbrev Tape.enumList : List Tape := [.remaining, .current, .threshold, .scratch,
  .reversed, .rawInput, .witnessBound, .capacity, .closure]

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

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

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

inductive Label where
  | guard | inputTag | scan | emit (symbol : Bool) | restore | test
  | result (value : Bool) | done
  deriving DecidableEq, Fintype

abbrev Alphabet (_ : Tape) := Bool
abbrev State := (Unit × Unit) × Option Bool

def initialState : State := (((), ()), none)

def program : Label → TM2.Stmt Alphabet Label State
  | .guard => MachineUnaryCounter.guard .remaining .inputTag .done
  | .inputTag => pushWord .reversed (encodeWord 5) (.goto fun _ => .scan)
  | .scan => MachineTransducerCopy.scanLoop .current .scratch () (fun _ b => .emit b) .restore
  | .emit b => MachineTransducerCopy.emitter .reversed (fun _ _ => ())
      (fun _ symbol => [symbol]) .scan () b
  | .restore => Reduction.MachineTransfer.loopAt .scratch .current id false .restore (some .test)
  | .test => MachineUnaryCounter.guard .threshold (.result false) (.result true)
  | .result b => pushWord .reversed (encodeWords [if b then 1 else 0, 3])
      (.push .current (fun _ => true) (.goto fun _ => .guard))
  | .done => .halt

def machine : FinTM2 where
  K := Tape
  k₀ := .rawInput
  k₁ := .reversed
  Γ _ := Bool
  Λ := Label
  main := .guard
  σ := State
  initialState := initialState
  m := program

def tapes (base : Tape → List Bool) (remaining current threshold : Nat)
    (output : List Bool) : Tape → List Bool
  | .remaining => encodeWord remaining
  | .current => encodeWord current
  | .threshold => encodeWord threshold
  | .scratch => []
  | .reversed => output
  | tape => base tape

@[simp] theorem tapes_current (base : Tape → List Bool) (m i d : Nat) (output : List Bool) :
    tapes base m i d output .current = encodeWord i := rfl

@[simp] theorem tapes_reversed (base : Tape → List Bool) (m i d : Nat) (output : List Bool) :
    tapes base m i d output .reversed = output := rfl

theorem update_reversed (base : Tape → List Bool) (m i d : Nat)
    (output replacement : List Bool) :
    Function.update (tapes base m i d output) .reversed replacement =
      tapes base m i d replacement := by
  funext tape
  cases tape <;> simp [tapes]

theorem push_current (base : Tape → List Bool) (m i d : Nat) (output : List Bool) :
    Function.update (tapes base m i d output) .current (true :: encodeWord i) =
      tapes base m (i + 1) d output := by
  funext tape
  cases tape <;> simp [tapes, encodeWord, List.replicate_succ]

theorem counterTapes_remaining (base : Tape → List Bool) (m i d r : Nat)
    (output : List Bool) :
    MachineUnaryCounter.counterTapes .remaining (tapes base m i d output) r [] =
      tapes base r i d output := by
  funext tape
  cases tape <;> simp [MachineUnaryCounter.counterTapes, tapes]

theorem counterTapes_threshold (base : Tape → List Bool) (m i d r : Nat)
    (output : List Bool) :
    MachineUnaryCounter.counterTapes .threshold (tapes base m i d output) r [] =
      tapes base m i r output := by
  funext tape
  cases tape <;> simp [MachineUnaryCounter.counterTapes, tapes]

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

theorem inputTagStep (base : Tape → List Bool) (m i d : Nat) (output : List Bool) :
    TM2.step program ⟨some .inputTag, initialState, tapes base m i d output⟩ =
      some ⟨some .scan, initialState,
        tapes base m i d ((encodeWord 5).reverse ++ output)⟩ := by
  change some (TM2.stepAux (program .inputTag) initialState (tapes base m i d output)) = _
  rw [program, stepAux_pushWord]
  change some (⟨some .scan, initialState, Function.update (tapes base m i d output)
    .reversed ((encodeWord 5).reverse ++ output)⟩ : TM2.Cfg Alphabet Label State) = _
  rw [update_reversed]

private theorem identity_output (input : List Bool) :
    Reduction.MachineTransducer.output (fun (_ : Unit) _ => ())
      (fun _ symbol => [symbol]) () input = input := by
  induction input with
  | nil => rfl
  | cons b input ih => simp [Reduction.MachineTransducer.output, ih]

theorem indexTrace (base : Tape → List Bool) (m i d : Nat) (output : List Bool) :
    (MachineComposition.advance (TM2.step program))^[3 * (i + 1) + 2]
      (some ⟨some .scan, initialState, tapes base m i d output⟩) =
      some ⟨some .test, initialState,
        tapes base m i d ((encodeWord i).reverse ++ output)⟩ := by
  have h := MachineTransducerCopy.transduceCopyTrace Tape.current Tape.scratch Tape.reversed
    (by decide) (by decide) (by decide) () (fun _ _ => ()) (fun _ symbol => [symbol])
    Label.scan Label.restore (fun _ b => Label.emit b) (some Label.test)
    program rfl (by intro control symbol; cases control; rfl) rfl
    (tapes base m i d output) rfl () () none
  simpa only [tapes_current, tapes_reversed, encodeWord_length, identity_output,
    update_reversed, initialState] using h

theorem thresholdStep (base : Tape → List Bool) (m i d : Nat) (output : List Bool) :
    TM2.step program ⟨some .test, initialState, tapes base m i d output⟩ =
      some ⟨some (.result (decide (d = 0))), initialState,
        tapes base m i (d - 1) output⟩ := by
  cases d with
  | zero =>
    simpa only [counterTapes_threshold, Nat.zero_sub, decide_true, initialState] using
      MachineUnaryCounter.guardStep_zero Tape.threshold Label.test (.result false) (.result true)
        program rfl (tapes base m i 0 output) [] ((), ()) none
  | succ d =>
    simpa only [counterTapes_threshold, Nat.add_sub_cancel, Nat.succ_ne_zero,
      decide_false, initialState] using
      MachineUnaryCounter.guardStep_succ Tape.threshold Label.test (.result false) (.result true)
        program rfl (tapes base m i (d + 1) output) d [] ((), ()) none

theorem resultStep (base : Tape → List Bool) (m i d : Nat) (output : List Bool) (b : Bool) :
    TM2.step program ⟨some (.result b), initialState, tapes base m i d output⟩ =
      some ⟨some .guard, initialState, tapes base m (i + 1) d
        ((encodeWords [if b then 1 else 0, 3]).reverse ++ output)⟩ := by
  change some (TM2.stepAux (program (.result b)) initialState (tapes base m i d output)) = _
  rw [program, stepAux_pushWord]
  simp only [TM2.stepAux, tapes_reversed]
  rw [update_reversed, tapes_current, push_current]

def termTokens (i d : Nat) : List Token :=
  [.input i, .const (decide (d = 0)), .and]

theorem termTokens_bits (i d : Nat) :
    tokenBits (termTokens i d) = encodeWord 5 ++ encodeWord i ++
      encodeWords [if decide (d = 0) then 1 else 0, 3] := by
  by_cases hd : d = 0 <;>
    simp [termTokens, tokenBits, tokenWords, Token.words, hd, encodeWords, List.append_assoc]

def bodySteps (i : Nat) : Nat := 3 * (i + 1) + 5

theorem bodyTrace (base : Tape → List Bool) (m i d : Nat) (output : List Bool) :
    (MachineComposition.advance (TM2.step program))^[bodySteps i]
      (some ⟨some .inputTag, initialState, tapes base m i d output⟩) =
      some ⟨some .guard, initialState, tapes base m (i + 1) (d - 1)
        ((tokenBits (termTokens i d)).reverse ++ output)⟩ := by
  have tag : (MachineComposition.advance (TM2.step program))^[1]
      (some ⟨some .inputTag, initialState, tapes base m i d output⟩) =
      some ⟨some .scan, initialState,
        tapes base m i d ((encodeWord 5).reverse ++ output)⟩ := by
    simpa only [Function.iterate_one, MachineComposition.advance_some] using
      inputTagStep base m i d output
  have index := indexTrace base m i d ((encodeWord 5).reverse ++ output)
  let out := (encodeWord i).reverse ++ ((encodeWord 5).reverse ++ output)
  have test : (MachineComposition.advance (TM2.step program))^[1]
      (some ⟨some .test, initialState, tapes base m i d out⟩) =
      some ⟨some (.result (decide (d = 0))), initialState,
        tapes base m i (d - 1) out⟩ := by
    simpa only [Function.iterate_one, MachineComposition.advance_some] using
      thresholdStep base m i d out
  have result : (MachineComposition.advance (TM2.step program))^[1]
      (some ⟨some (.result (decide (d = 0))), initialState,
        tapes base m i (d - 1) out⟩) =
      some ⟨some .guard, initialState, tapes base m (i + 1) (d - 1)
        ((encodeWords [if decide (d = 0) then 1 else 0, 3]).reverse ++ out)⟩ := by
    simpa only [Function.iterate_one, MachineComposition.advance_some] using
      resultStep base m i (d - 1) out (decide (d = 0))
  have whole := chain (chain (chain tag index) test) result
  have htime : 1 + (3 * (i + 1) + 2) + 1 + 1 = bodySteps i := by
    unfold bodySteps
    omega
  rw [htime] at whole
  simpa only [termTokens_bits, List.reverse_append, List.append_assoc, out] using whole

theorem guardStep_succ (base : Tape → List Bool) (m i d : Nat) (output : List Bool) :
    TM2.step program ⟨some .guard, initialState, tapes base (m + 1) i d output⟩ =
      some ⟨some .inputTag, initialState, tapes base m i d output⟩ := by
  simpa only [counterTapes_remaining, initialState] using
    MachineUnaryCounter.guardStep_succ Tape.remaining Label.guard Label.inputTag Label.done
      program rfl (tapes base (m + 1) i d output) m [] ((), ()) none

theorem guardStep_zero (base : Tape → List Bool) (i d : Nat) (output : List Bool) :
    TM2.step program ⟨some .guard, initialState, tapes base 0 i d output⟩ =
      some ⟨some .done, initialState, tapes base 0 i d output⟩ := by
  simpa only [counterTapes_remaining, initialState] using
    MachineUnaryCounter.guardStep_zero Tape.remaining Label.guard Label.inputTag Label.done
      program rfl (tapes base 0 i d output) [] ((), ()) none

theorem tokens_append_bits (xs ys : List Token) :
    tokenBits (xs ++ ys) = tokenBits xs ++ tokenBits ys := by
  simp [tokenBits, tokenWords, List.flatMap_append]

def selectorSteps : Nat → Nat → Nat
  | _, 0 => 1
  | i, m + 1 => 1 + bodySteps i + selectorSteps (i + 1) m

theorem selectorTrace (base : Tape → List Bool) (m i d : Nat) (output : List Bool) :
    (MachineComposition.advance (TM2.step program))^[selectorSteps i m]
      (some ⟨some .guard, initialState, tapes base m i d output⟩) =
      some ⟨some .done, initialState, tapes base 0 (i + m) (d - m)
        ((tokenBits (InitializationTemplate.selectorLoopTokens m i d)).reverse ++ output)⟩ := by
  induction m generalizing i d output with
  | zero =>
    simpa only [selectorSteps, InitializationTemplate.selectorLoopTokens,
      InitializationTemplate.forTokens, tokenBits, tokenWords, List.flatMap_nil,
      encodeWords, List.reverse_nil, List.nil_append, Nat.add_zero, Nat.sub_zero,
      Function.iterate_one, MachineComposition.advance_some] using
      guardStep_zero base i d output
  | succ m ih =>
    have guard : (MachineComposition.advance (TM2.step program))^[1]
        (some ⟨some .guard, initialState, tapes base (m + 1) i d output⟩) =
        some ⟨some .inputTag, initialState, tapes base m i d output⟩ := by
      simpa only [Function.iterate_one, MachineComposition.advance_some] using
        guardStep_succ base m i d output
    have body := bodyTrace base m i d output
    have rest := ih (i + 1) (d - 1) ((tokenBits (termTokens i d)).reverse ++ output)
    have whole := chain (chain guard body) rest
    have hs : InitializationTemplate.selectorLoopTokens (m + 1) i d =
        termTokens i d ++ InitializationTemplate.selectorLoopTokens m (i + 1) (d - 1) :=
      InitializationTemplate.selectorLoopTokens_succ m i d
    rw [hs, tokens_append_bits, List.reverse_append, List.append_assoc]
    simpa only [selectorSteps, Nat.add_assoc, Nat.add_comm, Nat.add_left_comm,
      Nat.sub_sub] using whole

theorem selectorSteps_le (i m : Nat) :
    selectorSteps i m ≤ m * (3 * (i + m) + 6) + 1 := by
  induction m generalizing i with
  | zero => simp [selectorSteps]
  | succ m ih =>
    let B := 3 * (i + (m + 1)) + 6
    have hbody : 1 + bodySteps i ≤ B := by unfold bodySteps B; omega
    have hrest : selectorSteps (i + 1) m ≤ m * B + 1 := by
      simpa only [B, Nat.add_assoc, Nat.add_comm, Nat.add_left_comm] using ih (i + 1)
    calc
      selectorSteps i (m + 1) = (1 + bodySteps i) + selectorSteps (i + 1) m := rfl
      _ ≤ B + (m * B + 1) := Nat.add_le_add hbody hrest
      _ = (m + 1) * B + 1 := by rw [Nat.succ_mul]; omega

def selectorInTime (base : Tape → List Bool) (m i d : Nat) (output : List Bool) :
    StateTransition.EvalsToInTime (TM2.step program)
      ⟨some .guard, initialState, tapes base m i d output⟩
      (some ⟨some .done, initialState, tapes base 0 (i + m) (d - m)
        ((tokenBits (InitializationTemplate.selectorLoopTokens m i d)).reverse ++ output)⟩)
      (m * (3 * (i + m) + 6) + 1) where
  steps := selectorSteps i m
  evals_in_steps := selectorTrace base m i d output
  steps_le_m := selectorSteps_le i m

theorem tapes_rawInput (base : Tape → List Bool) (m i d : Nat) (output : List Bool) :
    tapes base m i d output .rawInput = base .rawInput := rfl

theorem tapes_witnessBound (base : Tape → List Bool) (m i d : Nat) (output : List Bool) :
    tapes base m i d output .witnessBound = base .witnessBound := rfl

theorem tapes_capacity (base : Tape → List Bool) (m i d : Nat) (output : List Bool) :
    tapes base m i d output .capacity = base .capacity := rfl

theorem tapes_closure (base : Tape → List Bool) (m i d : Nat) (output : List Bool) :
    tapes base m i d output .closure = base .closure := rfl

end BinPackingGames.Foundations.Complexity.CookLevin.InitializationMachine

end OAI