import OAI.Probability.MatroidProphet.SeedLaw
import OAI.Probability.MatroidProphet.Algorithm.Rule
import Mathlib.MeasureTheory.Integral.Prod

namespace OAI

namespace MatroidProphet

open MeasureTheory Finset

abbrev MainSeedBlocks (n : ℕ) := Seed n × (Seed n × (Seed n × (Seed n × Seed 2)))

noncomputable def encodeMainSeed {n : ℕ} (b : MainSeedBlocks n) : Seed (mainSeedBits n) :=
  fun i => if hi : i.val < 4*n then
    let e : Fin n := ⟨i.val / 4, by omega⟩
    if i.val % 4 = 0 then b.1 e else
    if i.val % 4 = 1 then b.2.1 e else
    if i.val % 4 = 2 then b.2.2.1 e else b.2.2.2.1 e
  else b.2.2.2.2 ⟨i.val-4*n, by have := i.isLt; dsimp [mainSeedBits] at this; omega⟩

lemma encodeMainSeed_mask {n : ℕ} (b : MainSeedBlocks n) :
    seedMask (encodeMainSeed b) 0 = seedSet b.1 ∧
    seedMask (encodeMainSeed b) 1 = seedSet b.2.1 ∧
    seedMask (encodeMainSeed b) 2 = seedSet b.2.2.1 ∧
    seedMask (encodeMainSeed b) 3 = seedSet b.2.2.2.1 := by
  have h0 : ∀ e : Fin n, 4*e.val+0 < 4*n := fun e => by omega
  have h1 : ∀ e : Fin n, 4*e.val+1 < 4*n := fun e => by omega
  have h2 : ∀ e : Fin n, 4*e.val+2 < 4*n := fun e => by omega
  have h3 : ∀ e : Fin n, 4*e.val+3 < 4*n := fun e => by omega
  repeat' constructor
  all_goals
    ext e
    simp_all [seedMask, seedSet, encodeMainSeed, Nat.add_mod, Nat.mul_add_div]

lemma encodeMainSeed_branch {n : ℕ} (b : MainSeedBlocks n) :
    mainBranch (encodeMainSeed b) = b.2.2.2.2 0 := by
  simp [mainBranch, encodeMainSeed]

lemma encodeMainSeed_odd {n : ℕ} (b : MainSeedBlocks n) :
    (mainMasks (encodeMainSeed b)).odd = b.2.2.2.2 1 := by
  have h : ¬ 4*n+1 < 4*n := by omega
  simp [mainMasks, encodeMainSeed, h]

noncomputable def maskCoinLaw (n : ℕ) (p : ℝ) (h0 : 0 ≤ p) (h1 : p ≤ 1) : Measure (Seed n) :=
  bernoulliSeedLaw (fun _ => p) (fun _ => h0) (fun _ => h1)

instance maskCoinLaw_probability (n : ℕ) (p : ℝ) (h0 : 0 ≤ p) (h1 : p ≤ 1) :
    IsProbabilityMeasure (maskCoinLaw n p h0 h1) := by
  unfold maskCoinLaw
  infer_instance

noncomputable def mainBlockLaw (n : ℕ) (q : Fin 5 → ℝ)
    (h0 : ∀ j, 0 ≤ q j) (h1 : ∀ j, q j ≤ 1) : Measure (MainSeedBlocks n) :=
  (maskCoinLaw n (q 0) (h0 0) (h1 0)).prod
    ((maskCoinLaw n (q 1) (h0 1) (h1 1)).prod
      ((maskCoinLaw n (q 2) (h0 2) (h1 2)).prod
        ((maskCoinLaw n (q 3) (h0 3) (h1 3)).prod
          (maskCoinLaw 2 (q 4) (h0 4) (h1 4)))))

instance mainBlockLaw_probability (n : ℕ) (q : Fin 5 → ℝ)
    (h0 : ∀ j, 0 ≤ q j) (h1 : ∀ j, q j ≤ 1) :
    IsProbabilityMeasure (mainBlockLaw n q h0 h1) := by
  unfold mainBlockLaw
  infer_instance

noncomputable def mainSeedLaw (n : ℕ) (q : Fin 5 → ℝ)
    (h0 : ∀ j, 0 ≤ q j) (h1 : ∀ j, q j ≤ 1) : Measure (Seed (mainSeedBits n)) :=
  (mainBlockLaw n q h0 h1).map encodeMainSeed

instance mainSeedLaw_probability (n : ℕ) (q : Fin 5 → ℝ)
    (h0 : ∀ j, 0 ≤ q j) (h1 : ∀ j, q j ≤ 1) :
    IsProbabilityMeasure (mainSeedLaw n q h0 h1) :=
  inferInstanceAs (IsProbabilityMeasure ((mainBlockLaw n q h0 h1).map encodeMainSeed))

lemma integral_mainSeedLaw (n : ℕ) (q : Fin 5 → ℝ)
    (h0 : ∀ j, 0 ≤ q j) (h1 : ∀ j, q j ≤ 1) (f : Seed (mainSeedBits n) → ℝ) :
    (∫ r, f r ∂mainSeedLaw n q h0 h1) =
      ∫ H, ∫ D, ∫ C, ∫ T, ∫ b, f (encodeMainSeed (H, D, C, T, b))
        ∂maskCoinLaw 2 (q 4) (h0 4) (h1 4)
        ∂maskCoinLaw n (q 3) (h0 3) (h1 3)
        ∂maskCoinLaw n (q 2) (h0 2) (h1 2)
        ∂maskCoinLaw n (q 1) (h0 1) (h1 1)
        ∂maskCoinLaw n (q 0) (h0 0) (h1 0) := by
  rw [mainSeedLaw, integral_map_of_stronglyMeasurable (measurable_of_countable _)
    (measurable_of_countable f).stronglyMeasurable]
  simp only [mainBlockLaw]
  rw [integral_prod _ Integrable.of_finite]
  apply integral_congr_ae
  exact ae_of_all _ fun H => by
    dsimp only
    rw [integral_prod _ Integrable.of_finite]
    apply integral_congr_ae
    exact ae_of_all _ fun D => by
      dsimp only
      rw [integral_prod _ Integrable.of_finite]
      apply integral_congr_ae
      exact ae_of_all _ fun C => by
        dsimp only
        rw [integral_prod _ Integrable.of_finite]

lemma mainSeedLaw_expectation (n : ℕ) (q : Fin 5 → ℝ)
    (h0 : ∀ j, 0 ≤ q j) (h1 : ∀ j, q j ≤ 1) (f : Seed (mainSeedBits n) → ℝ) :
    (∫ r, f r ∂mainSeedLaw n q h0 h1) =
      bitsExpectation (fun _ : Fin n => q 0) Finset.univ (fun H =>
        bitsExpectation (fun _ : Fin n => q 1) Finset.univ (fun D =>
          bitsExpectation (fun _ : Fin n => q 2) Finset.univ (fun C =>
            bitsExpectation (fun _ : Fin n => q 3) Finset.univ (fun T =>
              bitsExpectation (fun _ : Fin 2 => q 4) Finset.univ (fun b =>
                f (encodeMainSeed (setSeed H, setSeed D, setSeed C, setSeed T, setSeed b))))))) := by
  rw [integral_mainSeedLaw]
  simp only [maskCoinLaw, integral_bernoulliSeedLaw]

end MatroidProphet

end OAI