import OAI.Combinatorics.ContingencyTables.Sampling.PaddedResidualProgram
import OAI.Combinatorics.ContingencyTables.Sampling.SmallProfileValidator
import Mathlib.Data.List.NodupEquivFin

namespace OAI

/-! # Computing the large rectangle and its padded margins -/

namespace ContingencyTables.ProfilePrograms
open MatchingFPRAS.TreeTyped

def largeIndexTest (z : (ℕ×List ℕ)×ℕ) : Bool :=
  decide (z.1.1≤z.1.2.getD z.2 0)

def largeIndexTestRealizer : Realizer largeIndexTest :=
  composition (pair (composition first first)
    (composition (pair (composition first second) second) (getDFast 0))) leNat

theorem polynomial_largeIndexTest : PolynomialTime largeIndexTestRealizer :=
  polynomial_composition (polynomial_pair
    (polynomial_composition polynomial_first polynomial_first)
    (polynomial_composition (polynomial_pair
      (polynomial_composition polynomial_first polynomial_second) polynomial_second)
      (polynomial_getDFast 0))) polynomial_leNat

def largeIndices (z : ℕ×List ℕ) : List ℕ :=
  (List.range z.2.length).filter (fun i => largeIndexTest (z,i))

def largeIndicesRealizer : Realizer largeIndices :=
  composition (pair identity (composition (composition second listLength) range))
    (filterWith largeIndexTestRealizer)

theorem polynomial_largeIndices : PolynomialTime largeIndicesRealizer := by
  have hr : PolynomialTime (composition (composition
      (second (A := ℕ) (B := List ℕ)) listLength) range) := by
    apply polynomial_boundedRange (polynomial_composition polynomial_second polynomial_listLength)
      Polynomial.X
    intro z
    simpa only [Function.comp_apply,Polynomial.eval_X] using
      (list_length_le_weight z.2).trans (by rw [weight_prod]; omega)
  exact polynomial_composition (polynomial_pair polynomial_identity hr)
    (polynomial_filterWith polynomial_largeIndexTest)

def selectList {A : Type} (a : A) (z : List ℕ×List A) : List A :=
  z.1.map (fun i => z.2.getD i a)

def selectListRealizer {A : Type} [Codec A] (a : A) : Realizer (selectList a) :=
  composition (pair second first) (mapWith (getDFast a))

theorem polynomial_selectList {A : Type} [Codec A] (a : A) :
    PolynomialTime (selectListRealizer a) :=
  polynomial_composition (polynomial_pair polynomial_second polynomial_first)
    (polynomial_mapWith (polynomial_getDFast a))

def largePaddedMargins (row : Bool) (z : PaddingData) : List ℕ :=
  selectList 0 (largeIndices (z.1.2,marginList row z.1),paddedMargins row z)

def largePaddedMarginsRealizer (row : Bool) : Realizer (largePaddedMargins row) :=
  composition (pair
    (composition (pair (composition first second)
      (composition first (marginListRealizer row))) largeIndicesRealizer)
    (paddedMarginsRealizer row)) (selectListRealizer 0)

theorem polynomial_largePaddedMargins (row : Bool) :
    PolynomialTime (largePaddedMarginsRealizer row) :=
  polynomial_composition (polynomial_pair
    (polynomial_composition (polynomial_pair
      (polynomial_composition polynomial_first polynomial_second)
      (polynomial_composition polynomial_first (polynomial_marginList row)))
      polynomial_largeIndices) (polynomial_paddedMargins row)) (polynomial_selectList 0)

def profilePaddedMargins (row : Bool) (z : ProfileCheckData×ℕ) : List ℕ :=
  largePaddedMargins row
    (((((z.1.1.1.1,if row then z.1.1.1.2.1 else complementValues (z.1.2,z.1.1.1.2.2)),
      z.1.1.2),z.1.2)),z.2)

def profilePaddedMarginsRealizer (row : Bool) : Realizer (profilePaddedMargins row) :=
  composition (pair (composition first (profileLineData row)) second)
    (largePaddedMarginsRealizer row)

theorem polynomial_profilePaddedMargins (row : Bool) :
    PolynomialTime (profilePaddedMarginsRealizer row) :=
  polynomial_composition (polynomial_pair
    (polynomial_composition polynomial_first (polynomial_profileLineData row)) polynomial_second)
    (polynomial_largePaddedMargins row)

lemma mem_largeIndices (U : ℕ) (r : List ℕ) (i : ℕ) :
    i∈largeIndices (U,r) ↔ i<r.length ∧ U≤r.getD i 0 := by
  simp only [largeIndices,List.mem_filter,List.mem_range,largeIndexTest,decide_eq_true_eq]

lemma largeIndices_nodup (U : ℕ) (r : List ℕ) : (largeIndices (U,r)).Nodup :=
  (List.nodup_range (n := r.length)).filter _

lemma largePaddedMargins_eq (row : Bool) (z : PaddingData) :
    largePaddedMargins row z=
      (largeIndices (z.1.2,marginList row z.1)).map (fun i => paddedMarginAt row (z,i)) := by
  change (largeIndices (z.1.2,marginList row z.1)).map
    (fun i => (paddedMargins row z).getD i 0)=_
  apply List.map_congr_left
  intro i hi
  have hi' := (mem_largeIndices _ _ _).mp hi
  rw [List.getD_eq_getElem (l := paddedMargins row z) (n := i) (d := 0)
    (by simpa only [paddedMargins,List.length_map,List.length_range] using hi'.1)]
  simp only [paddedMargins,List.getElem_map,List.getElem_range]

end ContingencyTables.ProfilePrograms

end OAI