import Mathlib
import OAI.Computability.MaxCut.Encoding.AdjacencyBits

namespace OAI

noncomputable section
namespace OptimalMaxCut
open scoped BigOperators
open LongCode.InstanceAdapter CounterMachine
attribute [local instance] Classical.propDecidable

@[simp] theorem nameBits_length_exact (n : ℕ) :
    (MaxCutGames.BinaryEncoding.nameBits n).length = 2*n.size+1 := by
  exact MaxCutGames.BinaryEncoding.nameBits_length n

theorem nameBits_getD (n i : ℕ) :
    ((MaxCutGames.BinaryEncoding.nameBits n)[i]?).getD false =
      decide (RawGrid.frameValue n i ≠ 0) := by
  have he (s : List Bool) : MaxCutGames.BinaryEncoding.frame s = CounterMachine.frame s := by
    induction s with
    | nil => rfl
    | cons b s ih => simp only [MaxCutGames.BinaryEncoding.frame,CounterMachine.frame,ih]
  unfold MaxCutGames.BinaryEncoding.nameBits
  rw [he]
  exact CounterMachine.frame_bits_get n i

@[simp] theorem Graph.table_length (G : Graph) :
    ((List.finRange G.vertices).flatMap (fun u =>
      (List.finRange G.vertices).map (fun v => G.adj u v))).length = G.vertices^2 := by
  simp [List.length_flatMap, pow_two]

theorem Graph.table_getD (G : Graph) (i j : ℕ) (hi : i<G.vertices) (hj : j<G.vertices) :
    (((List.finRange G.vertices).flatMap (fun u =>
      (List.finRange G.vertices).map (fun v => G.adj u v)))[i*G.vertices+j]?).getD false =
      G.adj ⟨i,hi⟩ ⟨j,hj⟩ := by
  have h := flatMap_getD (List.finRange G.vertices)
    (fun u => (List.finRange G.vertices).map (fun v => G.adj u v)) false G.vertices
    (by intros; simp) ⟨i,by simpa using hi⟩ j hj
  simpa [Fin.getElem_fin, List.getElem?_eq_getElem, hj] using h

@[simp] theorem ScaledGraph.bits_length_exact (G : ScaledGraph) :
    G.bits.length = (2*G.graph.vertices.size+1)+(2*G.scale.size+1)+G.graph.vertices^2 := by
  simp only [ScaledGraph.bits,List.length_append,nameBits_length_exact,Graph.table_length]

namespace LongCode.InstanceAdapter
open MaxCutGames.Foundations.Target

def anchor {q : ℕ} (g : Instance q) : Fin (g.vertices*2^q) :=
  vertexEquiv g.vertices q (g.constraints[0]'(g.constraintCount_positive) |>.source, fun _ => false)

noncomputable def gridGraph {q : ℕ} (g : Instance q) (t : ℚ)
    (ht : t ∈ Set.Icc (-1:ℚ) 1) (K : ℕ) : ScaledGraph :=
  (ofInstance g).gridOutput t ht (vertexEquiv g.vertices q) (anchor g) K
end LongCode.InstanceAdapter

namespace RawGrid
open LongCode.InstanceAdapter MaxCutGames.Foundations.Target
@[simp] theorem size_bits {q : ℕ} (g : Instance q) (L : ℕ) :
    size q L (bits g) = g.vertices*2^q*(Unweighted.searchPrime (L*(g.vertices*2^q+1)^2))^6 := by
  simp [size,param]

 theorem graph_size {q : ℕ} (g : Instance q) (t : ℚ) (ht : t ∈ Set.Icc (-1:ℚ) 1) (K : ℕ) :
    (gridGraph g t ht K).graph.vertices = size q (K+1) (bits g) := by
  simp [gridGraph,LongCode.Game.gridOutput,Unweighted.deterministicOutput,
    Unweighted.blowupOutput,Unweighted.blowupGraph]

 theorem graph_scale {q : ℕ} (g : Instance q) (t : ℚ) (ht : t ∈ Set.Icc (-1:ℚ) 1) (K : ℕ) :
    (gridGraph g t ht K).scale = scale q (K+1) (bits g) := by
  simp [gridGraph,LongCode.Game.gridOutput,Unweighted.deterministicOutput,
    Unweighted.blowupOutput,scale,param]

 theorem bits_length {q : ℕ} (g : Instance q) (t : ℚ) (ht : t ∈ Set.Icc (-1:ℚ) 1) (K : ℕ) :
    (gridGraph g t ht K).bits.length = length q (K+1) (bits g) := by
  rw [ScaledGraph.bits_length_exact, graph_size, graph_scale]; rfl

 theorem graph_adj {q : ℕ} (g : Instance q) (t : ℚ) (ht : t ∈ Set.Icc (-1:ℚ) 1) (K : ℕ)
    (i j : Fin (gridGraph g t ht K).graph.vertices) :
    (gridGraph g t ht K).graph.adj i j =
      decide (adjacency q t ht K (K+1) (bits g) i.val j.val ≠ 0) :=
  adjacency_bits g t ht K (K+1) (anchor g) i j

 theorem bits_getD {q : ℕ} (g : Instance q) (t : ℚ) (ht : t ∈ Set.Icc (-1:ℚ) 1) (K : ℕ)
    (i : ℕ) (hi : i<length q (K+1) (bits g)) :
    (((gridGraph g t ht K).bits)[i]?).getD false =
      decide (entry q t ht K (K+1) (bits g) i ≠ 0) := by
  let G := gridGraph g t ht K
  let d := 2*(size q (K+1) (bits g)).size+1
  let e := 2*(scale q (K+1) (bits g)).size+1
  have hd : (MaxCutGames.BinaryEncoding.nameBits G.graph.vertices).length = d := by
    rw [nameBits_length_exact,graph_size]
  have he : (MaxCutGames.BinaryEncoding.nameBits G.scale).length = e := by
    rw [nameBits_length_exact,graph_scale]
  simp only [ScaledGraph.bits, List.append_assoc]
  unfold entry
  by_cases hid : i<d
  · rw [List.getElem?_append_left (by rwa [hd]), nameBits_getD, graph_size]
    simp only [show i<2*(size q (K+1) (bits g)).size+1 from hid,↓reduceIte]
  · rw [List.getElem?_append_right (by rw [hd]; omega),hd]
    by_cases hie : i<d+e
    · rw [List.getElem?_append_left (by rw [he]; omega),nameBits_getD,graph_scale]
      simp only [show ¬i<2*(size q (K+1) (bits g)).size+1 from hid,↓reduceIte,
        show i<(2*(size q (K+1) (bits g)).size+1)+(2*(scale q (K+1) (bits g)).size+1) from hie,↓reduceIte]
      rfl
    · rw [List.getElem?_append_right (by rw [he]; omega),he]
      simp only [show ¬i<2*(size q (K+1) (bits g)).size+1 from hid,↓reduceIte,
        show ¬i<(2*(size q (K+1) (bits g)).size+1)+(2*(scale q (K+1) (bits g)).size+1) from hie,↓reduceIte]
      have hlen : i-d-e < G.graph.vertices^2 := by
        rw [graph_size]; dsimp [length,d,e] at *; omega
      have hn : 0<G.graph.vertices := by nlinarith
      have hij : i-d-e < G.graph.vertices*G.graph.vertices := by simpa only [pow_two] using hlen
      have hrow := (Nat.div_lt_iff_lt_mul hn).mpr hij
      have hcol := Nat.mod_lt (i-d-e) hn
      have h := G.graph.table_getD ((i-d-e)/G.graph.vertices) ((i-d-e)%G.graph.vertices) hrow hcol
      rw [Nat.mul_comm ((i-d-e)/G.graph.vertices) _, Nat.div_add_mod] at h
      rw [h,graph_adj]
      simp only [G,graph_size,d,e]
end RawGrid
end OptimalMaxCut

end

end OAI