import Mathlib
import OAI.Combinatorics.IndependentSets.Encoding.BinaryNameTables

namespace OAI

namespace LargeIndependentSets.GraphPrinter
open IndependentSetsCut.CounterMachine
open IndependentSetsGames.Foundations.Complexity
open scoped Classical
noncomputable section

lemma matrix_eq (G : Graph) :
    (List.finRange G.vertices).flatMap (fun i => (List.finRange G.vertices).map (G.adj i)) =
      List.ofFn (fun i : Fin (G.vertices*G.vertices) => G.adj i.divNat i.modNat) := by
  rw [List.ofFn_mul]
  simp only [List.ofFn_eq_map,List.flatMap_def]
  congr 1
  apply List.map_congr_left
  intro i _
  apply List.map_congr_left
  intro j _
  congr 1
  · apply Fin.ext
    simp only [Fin.divNat]
    rw [Nat.add_comm (i.val * G.vertices),Nat.add_mul_div_right _ _ G.nonempty,Nat.div_eq_of_lt j.isLt,Nat.zero_add]
  · apply Fin.ext
    simp [Fin.modNat,Nat.mod_eq_of_lt j.isLt]

lemma bits_get (G : Graph) (w : ℕ) (hw : w<(graphBits G).length) :
    ((graphBits G)[w]?).getD false=
      if h : w<(nameBits G.vertices).length then ((nameBits G.vertices)[w]?).getD false
      else G.adj
        (⟨w-(nameBits G.vertices).length,by
          apply Nat.sub_lt_left_of_lt_add (Nat.le_of_not_gt h)
          simpa only [graphBits,List.length_append,matrix_eq,List.length_ofFn] using hw⟩ : Fin (G.vertices*G.vertices)).divNat
        (⟨w-(nameBits G.vertices).length,by
          apply Nat.sub_lt_left_of_lt_add (Nat.le_of_not_gt h)
          simpa only [graphBits,List.length_append,matrix_eq,List.length_ofFn] using hw⟩ : Fin (G.vertices*G.vertices)).modNat := by
  simp only [graphBits,matrix_eq]
  split_ifs with h
  · rw [List.getElem?_append_left h]
  · rw [List.getElem?_append_right (Nat.le_of_not_gt h),List.getElem?_ofFn]
    have hb : w-(nameBits G.vertices).length<G.vertices*G.vertices := by
      apply Nat.sub_lt_left_of_lt_add (Nat.le_of_not_gt h)
      simpa only [graphBits,List.length_append,matrix_eq,List.length_ofFn] using hw
    simp only [dite_eq_left hb,Option.getD_some]

def lengthExpr (n : Expr) : Expr := .add (Expr.framedLen n) (.mul n n)
def bitExpr (n adj : Expr) : Expr :=
  Expr.cond (Expr.lt (.arg 0) (Expr.framedLen n)) (Expr.framedBit n (.arg 0))
    (adj.subst (fun _ => .sub (.arg 0) (Expr.framedLen n)))

lemma printer_spec (n adj : Expr) (s : List Bool) (G : Graph)
    (hn : ∀ a, n.eval s a=G.vertices)
    (ha : ∀ i : Fin (G.vertices*G.vertices),
      decide (adj.eval s (fun _ => i.val)≠0)=G.adj i.divNat i.modNat) :
    table (lengthExpr n) (bitExpr n adj) s=graphBits G := by
  have hlen : (lengthExpr n).eval s (fun _ => 0)=(graphBits G).length := by
    simp only [lengthExpr,Expr.eval,Expr.framedLen_eval,hn,graphBits,List.length_append,
      matrix_eq,List.length_ofFn,nameBits,frame_length,Nat.size_eq_bits_len]
  apply List.ext_getElem
  · simpa only [table,List.length_ofFn] using hlen
  · intro w hw hg
    simp only [table,List.getElem_ofFn]
    have hget : ((graphBits G)[w]?).getD false=(graphBits G)[w] := by
      rw [List.getElem?_eq_getElem hg]; rfl
    rw [← hget]
    rw [bits_get G w hg]
    have hheader : (nameBits G.vertices).length=2*G.vertices.size+1 := by
      simp [nameBits,frame_length,Nat.size_eq_bits_len]
    simp only [bitExpr,Expr.cond_eval,Expr.lt_eval,Expr.eval,Expr.framedLen_eval,hn,
      Expr.subst_eval,Expr.framedBit_eval]
    by_cases h : w<2*G.vertices.size+1
    · simp only [hheader,h,ite_true,dite_eq_left]
      rw [ite_eq_left (show (1:ℕ)≠0 by decide)]
      simpa only [nameBits,BinaryNames.frame_eq,Nat.one_ne_zero,ite_true] using (frame_bits_get G.vertices w).symm
    · simp only [hheader,h,ite_false,ne_eq,not_true_eq_false]
      have hb : w-(2*G.vertices.size+1)<G.vertices*G.vertices := by
        have hg' := hg
        simp only [graphBits,List.length_append,matrix_eq,List.length_ofFn,hheader] at hg'
        omega
      exact ha ⟨w-(2*G.vertices.size+1),hb⟩

noncomputable def encodedComputer {α : Type} (ea : α → List Bool) (f : α → Graph)
    (n adj : Expr) (hn : ∀ x a, n.eval (ea x) a=(f x).vertices)
    (ha : ∀ x (i : Fin ((f x).vertices*(f x).vertices)),
      decide (adj.eval (ea x) (fun _ => i.val)≠0)=(f x).adj i.divNat i.modNat) :
    Turing.TM2ComputableInPolyTime ea graphBits f where
  tm := (tableComputer (lengthExpr n) (bitExpr n adj)).tm
  inputAlphabet := (tableComputer (lengthExpr n) (bitExpr n adj)).inputAlphabet
  outputAlphabet := (tableComputer (lengthExpr n) (bitExpr n adj)).outputAlphabet
  time := (tableComputer (lengthExpr n) (bitExpr n adj)).time
  outputsFun x := by
    simpa only [id_eq,printer_spec n adj (ea x) (f x) (hn x) (ha x)] using
      (tableComputer (lengthExpr n) (bitExpr n adj)).outputsFun (ea x)

lemma encodedComputer_finiteAlphabet {α : Type} (ea : α → List Bool) (f : α → Graph)
    (n adj : Expr) (hn) (ha) :
    MachineFiniteAlphabet.FiniteAlphabet (encodedComputer ea f n adj hn ha).tm :=
  tableComputer_finiteAlphabet _ _

end
end LargeIndependentSets.GraphPrinter

end OAI