import OAI.Combinatorics.ContingencyTables.Machines.BinIntervalProgram
import OAI.Combinatorics.ContingencyTables.Machines.DependentWordProgram

namespace OAI

/-! # The executed independent bin-coordinate draws

Each coordinate reserves a width determined by its full range, and
uses only the prefix needed by the selected interval. The implementation
splits one Boolean list and performs binary arithmetic per coordinate.
-/

namespace ContingencyTables.BinVectorProgram

open MatchingFPRAS MatchingFPRAS.TreeTyped DensePrograms ProfilePrograms
open scoped BigOperators

/-- The interval input together with accuracy and dimension allowances. -/
abbrev Frame := BinIntervalProgram.Input×(ℕ×ℕ)

def reservedWidth (z : Frame) : ℕ := Nat.clog 2 (z.1.1.2+1)+4*(z.2.1+z.2.2)
def reservedWidthRealizer : Realizer reservedWidth := by
  let rangeR : Realizer (fun z : Frame => z.1.1.2) :=
    composition (composition first first) second
  let binary := composition (composition rangeR successor) ceilLogTwoRealizer
  let accuracy := composition (f := fun z : Frame => (4,z.2.1+z.2.2))
    (g := fun p : ℕ×ℕ => p.1*p.2)
    (pair (constant 4) (composition second add)) multiply
  exact composition (f := fun z : Frame =>
    (Nat.clog 2 (z.1.1.2+1),4*(z.2.1+z.2.2)))
    (g := fun p : ℕ×ℕ => p.1+p.2) (pair binary accuracy) add
lemma polynomial_reservedWidth : PolynomialTime reservedWidthRealizer := by
  unfold reservedWidthRealizer
  exact polynomial_composition (polynomial_pair
    (polynomial_composition (polynomial_composition
      (polynomial_composition (polynomial_composition polynomial_first polynomial_first)
        polynomial_second) polynomial_successor) polynomial_ceilLogTwo)
    (polynomial_composition (polynomial_pair (polynomial_constant 4)
      (polynomial_composition polynomial_second polynomial_add)) polynomial_multiply)) polynomial_add

def activeWidth (z : Frame) : ℕ :=
  Nat.clog 2 (BinIntervalProgram.intervalSize z.1+1)+4*(z.2.1+z.2.2)
def activeWidthRealizer : Realizer activeWidth := by
  let sizeR : Realizer (fun z : Frame => BinIntervalProgram.intervalSize z.1) :=
    composition (f := fun z : Frame => z.1) (g := BinIntervalProgram.intervalSize)
      first BinIntervalProgram.intervalSizeRealizer
  let binary : Realizer (fun z : Frame => Nat.clog 2 (BinIntervalProgram.intervalSize z.1+1)) :=
    composition (composition sizeR successor) ceilLogTwoRealizer
  let accuracy := composition (f := fun z : Frame => (4,z.2.1+z.2.2))
    (g := fun p : ℕ×ℕ => p.1*p.2)
    (pair (constant 4) (composition second add)) multiply
  exact composition (f := fun z : Frame =>
    (Nat.clog 2 (BinIntervalProgram.intervalSize z.1+1),4*(z.2.1+z.2.2)))
    (g := fun p : ℕ×ℕ => p.1+p.2) (pair binary accuracy) add
lemma polynomial_activeWidth : PolynomialTime activeWidthRealizer := by
  unfold activeWidthRealizer
  exact polynomial_composition (polynomial_pair
    (polynomial_composition (polynomial_composition
      (polynomial_composition polynomial_first BinIntervalProgram.polynomial_intervalSize)
      polynomial_successor) polynomial_ceilLogTwo)
    (polynomial_composition (polynomial_pair (polynomial_constant 4)
      (polynomial_composition polynomial_second polynomial_add)) polynomial_multiply)) polynomial_add

def coordinate (z : Frame×List Bool) : ℕ :=
  BinIntervalProgram.draw (z.1.1,z.2.take (activeWidth z.1))
def coordinateRealizer : Realizer coordinate :=
  composition (f := fun z : Frame×List Bool => (z.1.1,z.2.take (activeWidth z.1)))
    (g := BinIntervalProgram.draw)
    (pair (composition first first)
      (composition (pair second (composition first activeWidthRealizer)) takeFast))
    BinIntervalProgram.drawRealizer
lemma polynomial_coordinate : PolynomialTime coordinateRealizer :=
  polynomial_composition (polynomial_pair (polynomial_composition polynomial_first polynomial_first)
    (polynomial_composition (polynomial_pair polynomial_second
      (polynomial_composition polynomial_first polynomial_activeWidth)) polynomial_takeFast))
    BinIntervalProgram.polynomial_draw

lemma intervalSize_le (K N beta : ℕ) (hK : 0<K) (hN : 0<N) (hb : beta<K) :
    CompanionOracleDensity.intervalSize K N beta ≤ N := by
  have he := FairBits.fiber_card hK hN hb
  have hc : (FairBits.fiber K N beta).card ≤ N :=
    (Finset.card_le_card (Finset.filter_subset _ _)).trans_eq (Finset.card_range N)
  simpa only [he,CompanionOracleDensity.intervalSize] using hc

lemma active_le_reserved (K N beta h d : ℕ) (hK : 0<K) (hN : 0<N) (hb : beta<K) :
    activeWidth (((K,N),beta),(h,d)) ≤ reservedWidth (((K,N),beta),(h,d)) := by
  unfold activeWidth reservedWidth
  rw [BinIntervalProgram.intervalSize_eq]
  exact Nat.add_le_add_right (Nat.clog_mono_right 2
    (Nat.add_le_add_right (intervalSize_le K N beta hK hN hb) 1)) _

lemma take_ofFn_prefix {k N : ℕ} (hk : k ≤ N) (bits : Fin N → Bool) :
    (List.ofFn bits).take k=List.ofFn (FirstSuccess.prefixWord hk bits) := by
  apply List.ext_getElem
  · simp only [List.length_take,List.length_ofFn,min_eq_left hk]
  · intro i hi hj
    simp only [List.getElem_take,List.getElem_ofFn,FirstSuccess.prefixWord,Fin.castLE]

theorem coordinate_ofFn (K N beta h d : ℕ) (hK : 0<K) (hN : 0<N) (hb : beta<K)
    (hsize : 0<CompanionOracleDensity.intervalSize K N beta)
    (bits : Fin (reservedWidth (((K,N),beta),(h,d))) → Bool) :
    coordinate ((((K,N),beta),(h,d)),List.ofFn bits)=
      (CompanionOracleDensity.intervalEquiv K N beta hK hN hb
        (FairBits.scaledBitInteger (CompanionOracleDensity.intervalSize K N beta)
          (activeWidth (((K,N),beta),(h,d))) hsize
          (FirstSuccess.prefixWord (active_le_reserved K N beta h d hK hN hb) bits))).val := by
  unfold coordinate
  rw [take_ofFn_prefix (active_le_reserved K N beta h d hK hN hb)]
  exact BinIntervalProgram.draw_ofFn K N beta _ hK hN hb hsize _

abbrev Input := List Frame×List Bool

def widths (z : Input) : List ℕ := z.1.map reservedWidth
def widthsRealizer : Realizer widths := composition first (map reservedWidthRealizer)
lemma polynomial_widths : PolynomialTime widthsRealizer :=
  polynomial_composition polynomial_first (polynomial_map polynomial_reservedWidth)

def item (z : Input×ℕ) : ℕ := coordinate
  (z.1.1.getD z.2 (((0,0),0),(0,0)),dependentChunk ((widths z.1,z.1.2),z.2))
def itemRealizer : Realizer item :=
  composition (f := fun z : Input×ℕ =>
    (z.1.1.getD z.2 (((0,0),0),(0,0)),dependentChunk ((widths z.1,z.1.2),z.2)))
    (g := coordinate)
    (pair (composition (pair (composition first first) second)
      (getDFast (((0,0),0),(0,0))))
      (composition (pair (pair (composition first widthsRealizer)
        (composition first second)) second) dependentChunkRealizer)) coordinateRealizer
lemma polynomial_item : PolynomialTime itemRealizer :=
  polynomial_composition (polynomial_pair
    (polynomial_composition (polynomial_pair (polynomial_composition polynomial_first polynomial_first)
      polynomial_second) (polynomial_getDFast (((0,0),0),(0,0))))
    (polynomial_composition (polynomial_pair (polynomial_pair
      (polynomial_composition polynomial_first polynomial_widths)
      (polynomial_composition polynomial_first polynomial_second)) polynomial_second)
      polynomial_dependentChunk)) polynomial_coordinate

def indices (z : Input) : List ℕ := List.range z.1.length
def indicesRealizer : Realizer indices := composition (composition first listLength) range
lemma polynomial_indices : PolynomialTime indicesRealizer := by
  apply polynomial_boundedRange (polynomial_composition polynomial_first polynomial_listLength)
    Polynomial.X
  intro z
  simpa only [Function.comp_apply,Polynomial.eval_X] using
    (list_length_le_weight z.1).trans (weight_fst z)

def output (z : Input) : List ℕ := (indices z).map (fun i => item (z,i))
def outputRealizer : Realizer output :=
  composition (pair identity indicesRealizer) (mapWith itemRealizer)
theorem polynomial_output : PolynomialTime outputRealizer :=
  polynomial_composition (polynomial_pair polynomial_identity polynomial_indices)
    (polynomial_mapWith polynomial_item)

theorem output_ofFn {q : ℕ} (frames : Fin q → Frame)
    (bits : Fin (∑ i,reservedWidth (frames i)) → Bool) :
    output (List.ofFn frames,List.ofFn bits)=
      List.ofFn (fun i => coordinate (frames i,List.ofFn (fun j : Fin (reservedWidth (frames i)) =>
        bits (finSigmaFinEquiv ⟨i,j⟩)))) := by
  have hw : widths (List.ofFn frames,List.ofFn bits)=
      List.ofFn (fun i => reservedWidth (frames i)) := by
    simp only [widths,List.map_ofFn,Function.comp_def]
  apply List.ext_getElem
  · simp only [output,indices,List.length_map,List.length_range,List.length_ofFn]
  · intro i hi hj
    have hiq : i<q := by simpa only [List.length_ofFn] using hj
    have hd := dependentChunk_ofFn (fun i => reservedWidth (frames i)) bits (⟨i,hiq⟩ : Fin q)
    simp only [output,indices,List.length_ofFn,List.getElem_map,List.getElem_range,
      List.getElem_ofFn,item,List.getD_eq_getElem?_getD,List.getElem?_ofFn,hiq,dite_true,
      Option.getD_some,hw]
    exact congrArg (fun b => coordinate (frames ⟨i,hiq⟩,b)) hd

end ContingencyTables.BinVectorProgram

end OAI