import Mathlib.Tactic.Linarith
import OAI.Computability.PerfectCompleteness.Machines.BinaryNameSearch
import OAI.Computability.PerfectCompleteness.Machines.CanonicalDictionaryAppendMachine
import OAI.Computability.UniqueGames.Machines.MachineDrain
import OAI.Computability.UniqueGames.Machines.MachineSubroutineLemmas

namespace OAI


namespace PerfectCompleteness.CanonicalDictionaryMachine


open Turing
open UniqueGamesTheorem.Foundations.Complexity
open MachineComposition
open UniqueGamesTheorem.Reduction.MachineTransfer

abbrev Token := BinaryNameSearch.Token

def updatedTokens (tokens : List Token) (bits : List Bool) : List Token :=
  tokens ++ [(false, bits)]

theorem stream_append (first second : List Token) :
    BinaryNameSearch.stream (first ++ second) =
      BinaryNameSearch.stream first ++ BinaryNameSearch.stream second := by
  induction first with
  | nil => rfl
  | cons token first ih =>
      simp only [List.cons_append, BinaryNameSearch.stream_cons, ih, List.append_assoc]

theorem stream_updated (tokens : List Token) (bits : List Bool) :
    BinaryNameSearch.stream (updatedTokens tokens bits) =
      BinaryNameSearch.stream tokens ++ (false :: BinaryNameMachine.frame bits) := by
  simp only [updatedTokens, stream_append, BinaryNameSearch.stream_cons,
    BinaryNameSearch.stream_nil, List.append_nil, BinaryNameSearch.tokenBits]

theorem stream_updated_length (tokens : List Token) (bits : List Bool) :
    (BinaryNameSearch.stream (updatedTokens tokens bits)).length =
      (BinaryNameSearch.stream tokens).length + 2 * bits.length + 2 := by
  rw [stream_updated]
  simp only [List.length_append, List.length_cons, BinaryNameMachine.frame_length]
  omega

theorem present (tokens : List Token) (bits : List Bool) :
    bits ∈ BinaryNameSearch.payloads (updatedTokens tokens bits) := by
  apply List.mem_map.mpr
  exact ⟨(false, bits), by simp [updatedTokens], rfl⟩

theorem updated_canonical (tokens : List Token) (bits : List Bool)
    (canonical : BinaryNameMachine.canonical bits = true)
    (allCanonical : ∀ token ∈ tokens, BinaryNameMachine.canonical token.2 = true) :
    ∀ token ∈ updatedTokens tokens bits, BinaryNameMachine.canonical token.2 = true := by
  intro token mem
  rcases List.mem_append.mp mem with old | new
  · exact allCanonical token old
  · have same : token = (false, bits) := by simpa only [List.mem_singleton] using new
    simpa only [same] using canonical

def index (tokens : List Token) (bits : List Bool) : Nat :=
  (BinaryNameSearch.payloads (updatedTokens tokens bits)).idxOf bits

theorem index_le (tokens : List Token) (bits : List Bool) : index tokens bits ≤ tokens.length := by
  have h := List.idxOf_lt_length_of_mem (present tokens bits)
  simpa only [index, BinaryNameSearch.payloads, List.length_map, updatedTokens,
    List.length_append, List.length_singleton, Nat.lt_add_one_iff] using h

theorem suffix_length_le (tokens : List Token) (bits : List Bool) :
    (BinaryNameSearch.stream (BinaryNameSearch.afterMatch tokens bits)).length ≤
      (BinaryNameSearch.stream tokens).length := by
  induction tokens with
  | nil => simp [BinaryNameSearch.afterMatch]
  | cons token tokens ih =>
      simp only [BinaryNameSearch.afterMatch, BinaryNameSearch.stream_cons, List.length_append]
      split <;> omega

def steps (tokens : List Token) (bits : List Bool) : Nat :=
  CanonicalDictionaryAppendMachine.steps bits.length (BinaryNameSearch.stream tokens).length +
    2 * ((BinaryNameSearch.stream (updatedTokens tokens bits)).length + 1) + 1 +
    BinaryNameSearch.steps (updatedTokens tokens bits) bits +
    ((BinaryNameSearch.stream (BinaryNameSearch.afterMatch (updatedTokens tokens bits) bits)).length + 1) +
    (index tokens bits + 2)

theorem steps_le (tokens : List Token) (bits : List Bool) :
    steps tokens bits ≤ 3 * (BinaryNameSearch.stream (updatedTokens tokens bits)).length ^ 2 +
      16 * (BinaryNameSearch.stream (updatedTokens tokens bits)).length + 12 := by
  have search := BinaryNameSearch.steps_le_stream (updatedTokens tokens bits) bits
  have suffix := suffix_length_le (updatedTokens tokens bits) bits
  have idx := index_le tokens bits
  have oldCount : tokens.length ≤ (BinaryNameSearch.stream tokens).length := by
    rw [BinaryNameSearch.stream_length]
    omega
  have sizes := stream_updated_length tokens bits
  have keyBound : bits.length ≤ (BinaryNameSearch.stream (updatedTokens tokens bits)).length := by omega
  have product := Nat.mul_le_mul_right (BinaryNameSearch.stream (updatedTokens tokens bits)).length keyBound
  unfold steps CanonicalDictionaryAppendMachine.steps
  nlinarith

section Program

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

abbrev Alphabet (_ : K) := Bool
abbrev State (A : Type) := BinaryNameCompare.State A
abbrev clean (ambient : A) : State A := BinaryNameCompare.clean ambient

def appendMap : Fin 5 → Fin 8
  | 0 => 0
  | 1 => 1
  | 2 => 4
  | 3 => 5
  | 4 => 2

def searchMap : Fin 6 → Fin 8
  | 0 => 2
  | 1 => 0
  | 2 => 3
  | 3 => 4
  | 4 => 5
  | 5 => 6

def appendTapes (tape : Fin 8 → K) : Fin 5 → K := fun i => tape (appendMap i)
def searchTapes (tape : Fin 8 → K) : Fin 6 → K := fun i => tape (searchMap i)

omit [DecidableEq K] in
theorem appendTapes_injective (tape : Fin 8 → K) (distinct : Function.Injective tape) :
    Function.Injective (appendTapes tape) :=
  distinct.comp (by decide : Function.Injective appendMap)

omit [DecidableEq K] in
theorem searchTapes_injective (tape : Fin 8 → K) (distinct : Function.Injective tape) :
    Function.Injective (searchTapes tape) :=
  distinct.comp (by decide : Function.Injective searchMap)

inductive Label
  | append (label : CanonicalDictionaryAppendMachine.Label)
  | copyOut
  | copyBack
  | seed
  | search (label : BinaryNameSearch.Label)
  | drain
  | emit
  deriving DecidableEq, Fintype

def main : Label := .append .copyOut

def instruction (tape : Fin 8 → K) (labels : Label → Λ) (done rejected : Option Λ) :
    Label → TM2.Stmt (Alphabet (K := K)) Λ (State A)
  | .append l => CanonicalDictionaryAppendMachine.instruction (appendTapes tape)
      (fun l => labels (.append l)) (some (labels .copyOut)) l
  | .copyOut => loopAt (tape 1) (tape 5) id false (labels .copyOut) (some (labels .copyBack))
  | .copyBack => MachineCopy.forkLoop (tape 5) (tape 1) (tape 2) false
      (labels .copyBack) (some (labels .seed))
  | .seed => .push (tape 6) (fun _ => false) (.goto fun _ => labels (.search .sign))
  | .search l => BinaryNameSearch.instruction (searchTapes tape)
      (fun l => labels (.search l)) (some (labels .drain)) rejected rejected l
  | .drain => MachineDrain.drain (tape 2) (labels .drain) (some (labels .emit))
  | .emit => loopAt (tape 6) (tape 7) id false (labels .emit) done

private theorem joinTrace {X : Type*} {f : X → X} {a b c : X} {n m : Nat}
    (first : f^[n] a = b) (second : f^[m] b = c) : f^[n + m] a = c := by
  rw [Nat.add_comm, Function.iterate_add_apply, first, second]

theorem dictionaryTrace (tape : Fin 8 → K) (distinct : Function.Injective tape)
    (labels : Label → Λ) (done rejected : Option Λ)
    (program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (State A))
    (atLabels : ∀ l, program (labels l) = instruction tape labels done rejected l)
    (base : K → List Bool) (ambient : A) (tokens : List Token) (bits : List Bool)
    (canonical : BinaryNameMachine.canonical bits = true)
    (allCanonical : ∀ token ∈ tokens, BinaryNameMachine.canonical token.2 = true)
    (keyWord : base (tape 0) = bits.reverse)
    (dictionaryWord : base (tape 1) = BinaryNameSearch.stream tokens)
    (empty : ∀ i : Fin 8, 2 ≤ i.val → i.val ≤ 6 → base (tape i) = []) :
    (advance (TM2.step program))^[steps tokens bits]
      (some ⟨some (labels main), clean ambient, base⟩) =
      some ⟨done, clean ambient,
        Function.update (Function.update base (tape 1)
          (BinaryNameSearch.stream (updatedTokens tokens bits))) (tape 7)
          ((encodeWord (index tokens bits)).reverse ++ base (tape 7))⟩ := by
  have hd (i j : Fin 8) (hne : i ≠ j) : tape i ≠ tape j := fun h => hne (distinct h)
  have he (i : Fin 8) (lo : 2 ≤ i.val := by decide) (hi : i.val ≤ 6 := by decide) :
      base (tape i) = [] := empty i lo hi
  let updated := updatedTokens tokens bits
  let dictionary := BinaryNameSearch.stream updated
  let tail := BinaryNameSearch.stream (BinaryNameSearch.afterMatch updated bits)
  let s₁ := Function.update base (tape 1) dictionary
  let s₂ := Function.update s₁ (tape 2) dictionary
  let s₃ := Function.update s₂ (tape 6) [false]
  let s₄ := tapesAt (tape 2) (tape 6) s₃ tail (encodeWord (index tokens bits))
  let s₅ := Function.update s₄ (tape 2) []
  let s₆ := tapesAt (tape 6) (tape 7) s₅ []
    ((encodeWord (index tokens bits)).reverse ++ s₅ (tape 7))
  have appended := CanonicalDictionaryAppendMachine.appendTrace (appendTapes tape)
    (appendTapes_injective tape distinct) (fun l => labels (.append l))
    (some (labels .copyOut)) program (fun l => atLabels (.append l))
    base bits (BinaryNameSearch.stream tokens) keyWord dictionaryWord
    (he 4) (he 5) (he 2) ambient
  rw [← stream_updated tokens bits] at appended
  change (advance (TM2.step program))^[CanonicalDictionaryAppendMachine.steps
      bits.length (BinaryNameSearch.stream tokens).length]
    (some ⟨some (labels main), clean ambient, base⟩) =
    some ⟨some (labels .copyOut), clean ambient, s₁⟩ at appended
  have s₁dictionary : s₁ (tape 1) = dictionary := by simp [s₁]
  have s₁empty (i : Fin 8) (lo : 2 ≤ i.val) (hi : i.val ≤ 6) : s₁ (tape i) = [] := by
    have ne : i ≠ 1 := by intro h; subst i; omega
    simp [s₁, hd i 1 ne, he i lo hi]
  have copied : (advance (TM2.step program))^[2 * (dictionary.length + 1)]
      (some ⟨some (labels .copyOut), clean ambient, s₁⟩) =
      some ⟨some (labels .seed), clean ambient, s₂⟩ := by
    have h := MachineCopy.copyTrace (tape 1) (tape 2) (tape 5)
      (hd 1 2 (by decide)) (hd 1 5 (by decide)) (hd 2 5 (by decide)) false
      (labels .copyOut) (labels .copyBack) (some (labels .seed)) program
      (atLabels .copyOut) (atLabels .copyBack) s₁ (s₁empty 5 (by decide) (by decide))
      (ambient, false, none) none
    simpa only [s₁dictionary, s₁empty 2 (by decide) (by decide), List.append_nil,
      clean, BinaryNameCompare.clean, s₂] using h
  have s₂counter : s₂ (tape 6) = [] := by
    simp [s₂, hd 6 2 (by decide), s₁empty 6 (by decide) (by decide)]
  have seeded : (advance (TM2.step program))^[1]
      (some ⟨some (labels .seed), clean ambient, s₂⟩) =
      some ⟨some (labels (.search .sign)), clean ambient, s₃⟩ := by
    change some (TM2.stepAux (program (labels .seed)) _ _) = _
    rw [atLabels .seed]
    simp [instruction, TM2.stepAux, s₂counter, s₃]
  have s₃key : s₃ (tape 0) = bits.reverse := by
    simpa [s₃, s₂, s₁, hd 0 6 (by decide), hd 0 2 (by decide), hd 0 1 (by decide)] using keyWord
  have s₃stream : s₃ (tape 2) = dictionary := by simp [s₃, s₂, hd 2 6 (by decide)]
  have s₃counter : s₃ (tape 6) = [false] := by simp [s₃]
  have s₃empty (i : Fin 8) (hi : i = 3 ∨ i = 4 ∨ i = 5) : s₃ (tape i) = [] := by
    rcases hi with rfl | rfl | rfl <;> simp [s₃, s₂, s₁, hd, he]
  have searched : (advance (TM2.step program))^[BinaryNameSearch.steps updated bits]
      (some ⟨some (labels (.search .sign)), clean ambient, s₃⟩) =
      some ⟨some (labels .drain), clean ambient, s₄⟩ := by
    have h := BinaryNameSearch.searchTrace (searchTapes tape) (searchTapes_injective tape distinct)
      (fun l => labels (.search l)) (some (labels .drain)) rejected rejected program
      (fun l => atLabels (.search l)) s₃ ambient updated bits [] [false]
      (updated_canonical tokens bits canonical allCanonical) (present tokens bits) s₃key
      (s₃empty 3 (by simp)) (s₃empty 4 (by simp)) (s₃empty 5 (by simp))
    have initial : tapesAt (tape 2) (tape 6) s₃ dictionary [false] = s₃ := by
      rw [← s₃stream, ← s₃counter]
      exact tapesAt_self _ _ _
    change (advance (TM2.step program))^[BinaryNameSearch.steps updated bits]
      (some ⟨some (labels (.search .sign)), clean ambient,
        tapesAt (tape 2) (tape 6) s₃ (dictionary ++ []) [false]⟩) =
      some ⟨some (labels .drain), clean ambient,
        tapesAt (tape 2) (tape 6) s₃ (tail ++ []) (encodeWord (index tokens bits))⟩ at h
    simpa only [List.append_nil, initial, s₄] using h
  have s₄stream : s₄ (tape 2) = tail := by simp [s₄, hd 2 6 (by decide)]
  have drained : (advance (TM2.step program))^[tail.length + 1]
      (some ⟨some (labels .drain), clean ambient, s₄⟩) =
      some ⟨some (labels .emit), clean ambient, s₅⟩ := by
    have h := MachineDrain.drainTrace (tape 2) (labels .drain) (some (labels .emit)) program
      (atLabels .drain) s₄ tail (ambient, false, none) none
    have initial : Function.update s₄ (tape 2) tail = s₄ := by
      rw [← s₄stream]
      exact Function.update_eq_self _ _
    simpa only [initial, clean, BinaryNameCompare.clean, s₅] using h
  have s₅counter : s₅ (tape 6) = encodeWord (index tokens bits) := by
    simp [s₅, s₄, hd 6 2 (by decide)]
  have emitted : (advance (TM2.step program))^[index tokens bits + 2]
      (some ⟨some (labels .emit), clean ambient, s₅⟩) =
      some ⟨done, clean ambient, s₆⟩ := by
    have h := transferAt_fromTapes (Γ := Alphabet) (σ := A × Bool × Option Bool)
      (tape 6) (tape 7) (hd 6 7 (by decide)) id false (labels .emit) done program
      (atLabels .emit) s₅ (ambient, false, none) none
    change (advance (TM2.step program))^[(s₅ (tape 6)).length + 1]
      (some ⟨some (labels .emit), clean ambient, s₅⟩) =
      some ⟨done, clean ambient, tapesAt (tape 6) (tape 7) s₅ []
        ((s₅ (tape 6)).reverse.map id ++ s₅ (tape 7))⟩ at h
    simpa only [s₅counter, encodeWord_length, List.map_id_fun, id_eq, Nat.add_assoc,
      clean, BinaryNameCompare.clean, s₆] using h
  have restored : s₆ = Function.update (Function.update base (tape 1) dictionary) (tape 7)
      ((encodeWord (index tokens bits)).reverse ++ base (tape 7)) := by
    funext k
    by_cases h7 : k = tape 7
    · subst k
      simp [s₆, s₅, s₄, s₃, s₂, s₁, tapesAt, hd]
    · by_cases h1 : k = tape 1
      · subst k
        simp [s₆, s₅, s₄, s₃, s₂, s₁, tapesAt, hd]
      · by_cases h2 : k = tape 2
        · subst k
          simp [s₆, s₅, tapesAt, hd, he 2]
        · by_cases h6 : k = tape 6
          · subst k
            simp [s₆, tapesAt, hd, he 6]
          · simp [s₆, s₅, s₄, s₃, s₂, s₁, tapesAt, h7, h1, h2, h6,
              Function.update_apply]
  have full := joinTrace (joinTrace (joinTrace (joinTrace
    (joinTrace appended copied) seeded) searched) drained) emitted
  simpa only [steps, dictionary, updated, tail, restored] using full

def dictionaryInTime (tape : Fin 8 → K) (distinct : Function.Injective tape)
    (labels : Label → Λ) (done rejected : Option Λ)
    (program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (State A))
    (atLabels : ∀ l, program (labels l) = instruction tape labels done rejected l)
    (base : K → List Bool) (ambient : A) (tokens : List Token) (bits : List Bool)
    (canonical : BinaryNameMachine.canonical bits = true)
    (allCanonical : ∀ token ∈ tokens, BinaryNameMachine.canonical token.2 = true)
    (keyWord : base (tape 0) = bits.reverse)
    (dictionaryWord : base (tape 1) = BinaryNameSearch.stream tokens)
    (empty : ∀ i : Fin 8, 2 ≤ i.val → i.val ≤ 6 → base (tape i) = []) :
    StateTransition.EvalsToInTime (TM2.step program)
      ⟨some (labels main), clean ambient, base⟩
      (some ⟨done, clean ambient,
        Function.update (Function.update base (tape 1)
          (BinaryNameSearch.stream (updatedTokens tokens bits))) (tape 7)
          ((encodeWord (index tokens bits)).reverse ++ base (tape 7))⟩)
      (3 * (BinaryNameSearch.stream (updatedTokens tokens bits)).length ^ 2 +
        16 * (BinaryNameSearch.stream (updatedTokens tokens bits)).length + 12) where
  steps := steps tokens bits
  evals_in_steps := dictionaryTrace tape distinct labels done rejected program atLabels base ambient
    tokens bits canonical allCanonical keyWord dictionaryWord empty
  steps_le_m := steps_le tokens bits

end Program

end PerfectCompleteness.CanonicalDictionaryMachine

end OAI