import Mathlib.Tactic.Ring
import OAI.Computability.PerfectCompleteness.Model
import OAI.Computability.PerfectCompleteness.Reduction.Target
import OAI.Computability.UniqueGames.Machines.MachineSubroutineLemmas

namespace OAI


namespace PerfectCompleteness.Encoding

open UniqueGamesTheorem.Foundations.Complexity

def parseLabel (alphabet value : Nat) : Option (Fin alphabet) :=
  if bounded : value < alphabet then some ⟨value, bounded⟩ else none

@[simp] theorem parseLabel_value {q : Nat} (label : Fin q) :
    parseLabel q label.val = some label := by
  simp [parseLabel, label.isLt]

@[simp] theorem parseLabels_values {q : Nat} (labels : List (Fin q)) :
    (labels.map Fin.val).mapM (parseLabel q) = some labels := by
  induction labels with
  | nil => rfl
  | cons label labels ih => simp [ih]

def parseImages (alphabet : Nat) (words : List Nat) :
    Option (Vector (Fin alphabet) (2 * alphabet)) := do
  let labels ← words.mapM (parseLabel alphabet)
  if length_ok : labels.length = 2 * alphabet then
    some ⟨labels.toArray, by simpa using length_ok⟩
  else none

@[simp] theorem parseImages_values {q : Nat}
    (images : Vector (Fin q) (2 * q)) :
    parseImages q (images.toList.map Fin.val) = some images := by
  unfold parseImages
  rw [parseLabels_values]
  simp
  exact Vector.toArray_toList

def parseProjection (alphabet : Nat) (words : List Nat) :
    Option (ProjectionTable alphabet) := do
  let images ← parseImages alphabet words
  if exactlyTwo : ∀ b : Fin alphabet,
      ((List.finRange (2 * alphabet)).filter
        (fun a => decide (images[a] = b))).length = 2 then
    some ⟨images, exactlyTwo⟩
  else none

@[simp] theorem parseProjection_encoded {q : Nat} (table : ProjectionTable q) :
    parseProjection q (tableWords table) = some table := by
  simp only [parseProjection, tableWords, parseImages_values]
  dsimp only [Bind.bind, Option.bind]
  simp only [table.exactlyTwo, implies_true, dite_true]

@[simp] theorem tableWords_length {q : Nat} (table : ProjectionTable q) :
    (tableWords table).length = 2 * q := by
  simp [tableWords]

def parseEdge (leftVertices rightVertices alphabet : Nat) :
    List Nat → Option (Edge leftVertices rightVertices alphabet × List Nat)
  | left :: right :: words => do
      let left ← parseLabel leftVertices left
      let right ← parseLabel rightVertices right
      let projection ← parseProjection alphabet (words.take (2 * alphabet))
      return (⟨left, right, projection⟩, words.drop (2 * alphabet))
  | _ => none

@[simp] theorem parseEdge_encoded {l r q : Nat}
    (edge : Edge l r q) (rest : List Nat) :
    parseEdge l r q (edgeWords edge ++ rest) = some (edge, rest) := by
  cases edge with
  | mk left right projection =>
      have taken := List.take_left' (l₂ := rest) (tableWords_length projection)
      have dropped := List.drop_left' (l₂ := rest) (tableWords_length projection)
      simp [edgeWords, parseEdge, taken, dropped]

def parseEdges (leftVertices rightVertices alphabet : Nat) :
    Nat → List Nat → Option (List (Edge leftVertices rightVertices alphabet) × List Nat)
  | 0, words => some ([], words)
  | count + 1, words => do
      let (edge, words) ← parseEdge leftVertices rightVertices alphabet words
      let (edges, words) ← parseEdges leftVertices rightVertices alphabet count words
      return (edge :: edges, words)

@[simp] theorem parseEdges_encoded {l r q : Nat}
    (edges : List (Edge l r q)) (rest : List Nat) :
    parseEdges l r q edges.length (edges.flatMap edgeWords ++ rest) =
      some (edges, rest) := by
  induction edges with
  | nil => rfl
  | cons edge edges ih => simp [parseEdges, List.append_assoc, ih]

def decodeGameWords (alphabet : Nat) : List Nat → Option (Instance alphabet)
  | leftVertices :: rightVertices :: encodedAlphabet :: count :: words => do
      if encodedAlphabet = alphabet then
        let (edges, trailing) ← parseEdges leftVertices rightVertices alphabet count words
        if trailing = [] then
          if nonempty : edges ≠ [] then
            some ⟨leftVertices, rightVertices, edges, nonempty⟩
          else none
        else none
      else none
  | _ => none

@[simp] theorem decodeGameWords_encoded {q : Nat} (game : Instance q) :
    decodeGameWords q (gameWords game) = some game := by
  cases game with
  | mk leftVertices rightVertices edges nonempty =>
      have parsed := parseEdges_encoded edges []
      simp only [List.append_nil] at parsed
      simp [decodeGameWords, gameWords, parsed, nonempty]

def decodeGameBits (alphabet : Nat) (bits : List Bool) : Option (Instance alphabet) :=
  decodeWords bits >>= decodeGameWords alphabet

@[simp] theorem decodeGameBits_encoded {q : Nat} (game : Instance q) :
    decodeGameBits q (gameBits game) = some game := by
  simp [decodeGameBits, gameBits]

theorem gameBits_injective {q : Nat} {first second : Instance q}
    (same : gameBits first = gameBits second) : first = second := by
  have parsed := congrArg (decodeGameBits q) same
  simpa only [decodeGameBits_encoded, Option.some.injEq] using parsed

@[simp] theorem edgeWords_length {l r q : Nat} (edge : Edge l r q) :
    (edgeWords edge).length = 2 * q + 2 := by
  simp [edgeWords]

theorem edgesWords_length {l r q : Nat} (edges : List (Edge l r q)) :
    (edges.flatMap edgeWords).length = edges.length * (2 * q + 2) := by
  induction edges with
  | nil => simp
  | cons edge edges ih =>
      simp only [List.flatMap_cons, List.length_append, edgeWords_length,
        List.length_cons, Nat.add_mul, Nat.one_mul, ih]
      omega

@[simp] theorem gameWords_length {q : Nat} (game : Instance q) :
    (gameWords game).length = 4 + game.edges.length * (2 * q + 2) := by
  simp only [gameWords, List.length_append, List.length_cons, List.length_nil,
    edgesWords_length]

theorem gameBits_length {q : Nat} (game : Instance q) :
    (gameBits game).length =
      (gameWords game).sum + 4 + game.edges.length * (2 * q + 2) := by
  simp only [gameBits, encodeWords_length, gameWords_length]
  omega

end PerfectCompleteness.Encoding


namespace PerfectCompleteness.Encoding

theorem tableWords_sum_le {q : Nat} (table : ProjectionTable q) :
    (tableWords table).sum ≤ 2 * q * q := by
  have hsum (labels : List (Fin q)) :
      (labels.map Fin.val).sum ≤ labels.length * q := by
    induction labels with
    | nil => simp
    | cons a labels ih =>
        simp only [List.map_cons, List.sum_cons, List.length_cons,
          Nat.add_mul, Nat.one_mul]
        calc
          _ ≤ q + labels.length * q :=
            Nat.add_le_add (Nat.le_of_lt a.isLt) ih
          _ = labels.length * q + q := Nat.add_comm _ _
  simpa [tableWords] using hsum table.images.toList

theorem edgeWords_sum_le {l r q : Nat} (edge : Edge l r q) :
    (edgeWords edge).sum ≤ l + r + 2 * q * q := by
  calc
    _ = edge.left.val + edge.right.val + (tableWords edge.projection).sum := by
      simp [edgeWords, Nat.add_assoc]
    _ ≤ l + r + 2 * q * q :=
      Nat.add_le_add
        (Nat.add_le_add (Nat.le_of_lt edge.left.isLt) (Nat.le_of_lt edge.right.isLt))
        (tableWords_sum_le edge.projection)

theorem edgesWords_sum_le {l r q : Nat} (edges : List (Edge l r q)) :
    (edges.flatMap edgeWords).sum ≤ edges.length * (l + r + 2 * q * q) := by
  induction edges with
  | nil => simp
  | cons edge edges ih =>
      calc
        _ = (edgeWords edge).sum + (edges.flatMap edgeWords).sum := by
          rw [List.flatMap_cons, List.sum_append]
        _ ≤ (l + r + 2 * q * q) + edges.length * (l + r + 2 * q * q) :=
          Nat.add_le_add (edgeWords_sum_le edge) ih
        _ = (edge :: edges).length * (l + r + 2 * q * q) := by
          simp only [List.length_cons, Nat.add_mul, Nat.one_mul]
          exact Nat.add_comm _ _

theorem gameWords_sum_le {q : Nat} (game : Instance q) :
    (gameWords game).sum ≤
      game.leftVertices + game.rightVertices + q + game.edges.length +
        game.edges.length * (game.leftVertices + game.rightVertices + 2 * q * q) := by
  calc
    _ = (game.leftVertices + game.rightVertices + q + game.edges.length) +
        (game.edges.flatMap edgeWords).sum := by
      simp [gameWords, Nat.add_assoc]
    _ ≤ _ := Nat.add_le_add_left (edgesWords_sum_le game.edges) _

theorem gameBits_length_le {q : Nat} (game : Instance q) :
    (gameBits game).length ≤
      game.leftVertices + game.rightVertices + q + game.edges.length + 4 +
        game.edges.length *
          (game.leftVertices + game.rightVertices + 2 * q * q + 2 * q + 2) := by
  rw [gameBits_length]
  calc
    _ ≤ (game.leftVertices + game.rightVertices + q + game.edges.length +
        game.edges.length * (game.leftVertices + game.rightVertices + 2 * q * q)) +
          4 + game.edges.length * (2 * q + 2) :=
      Nat.add_le_add_right (Nat.add_le_add_right (gameWords_sum_le game) 4) _
    _ = _ := by ring

theorem gameBits_length_le_of_edge_count {q : Nat} (game : Instance q)
    (M : Nat) (hM : game.edges.length ≤ M) :
    (gameBits game).length ≤
      game.leftVertices + game.rightVertices + q + M + 4 +
        M * (game.leftVertices + game.rightVertices + 2 * q * q + 2 * q + 2) := by
  apply (gameBits_length_le game).trans
  exact Nat.add_le_add
    (Nat.add_le_add_right
      (Nat.add_le_add_left hM (game.leftVertices + game.rightVertices + q)) 4)
    (Nat.mul_le_mul_right
      (game.leftVertices + game.rightVertices + 2 * q * q + 2 * q + 2) hM)

end PerfectCompleteness.Encoding

end OAI