import OAI.Analysis.IrrationalRotation.Rotation.CircleParameterBlocks
import Mathlib.Topology.Algebra.InfiniteSum.Real
import Mathlib.Analysis.PSeries

namespace OAI

noncomputable section
open scoped BigOperators

namespace Invariant233
namespace CircleParameterLaws

variable {θ : ℝ} {p : CircleParameterData} (hp : CircleParameterLaws θ p)
include hp

private def budgetBlocks (p : CircleParameterData) (s : ℕ) : Finset ℕ :=
  if s = 0 then {0} else p.block s

private theorem budgetBlocks_partition :
    ∀ i : ℕ, ∃! s : ℕ, i ∈ budgetBlocks p s := by
  intro i
  by_cases hi : i = 0
  · subst i
    refine ⟨0, by simp [budgetBlocks], ?_⟩
    intro s hs
    by_contra h
    have hb : 0 ∈ p.block s := by simpa [budgetBlocks, h] using hs
    have hb' := (p.mem_block_iff s 0).mp hb
    omega
  · obtain ⟨s, hs, his⟩ := p.exists_mem_block hp.m_pos i (by omega)
    have hs0 : s ≠ 0 := by omega
    refine ⟨s, by simpa [budgetBlocks, hs0] using his, ?_⟩
    intro t hit
    have ht0 : t ≠ 0 := by
      intro ht
      subst t
      simp [budgetBlocks, hi] at hit
    have ht : i ∈ p.block t := by simpa [budgetBlocks, ht0] using hit
    exact p.block_index_unique hp.m_pos ht his

theorem normalized_block_budget (a : ℕ → ℝ) (ha : ∀ s, 0 ≤ a s)
    (has : Summable a) :
    Summable (fun i : ℕ => if i = 0 then 0 else
      a (p.blockIndex i) / (p.m (p.blockIndex i) : ℝ)) ∧
    (∑' i : ℕ, if i = 0 then 0 else
      a (p.blockIndex i) / (p.m (p.blockIndex i) : ℝ)) ≤ ∑' s, a s := by
  classical
  let f : ℕ → ℝ := fun i => if i = 0 then 0 else
    a (p.blockIndex i) / (p.m (p.blockIndex i) : ℝ)
  have hfnonneg : ∀ i, 0 ≤ f i := by
    intro i
    simp only [f]
    split_ifs
    · exact le_rfl
    · exact div_nonneg (ha _) (Nat.cast_nonneg _)
  have hblock (s : ℕ) :
      (∑' i : budgetBlocks p s, f i) = if s = 0 then 0 else a s := by
    rw [Finset.tsum_subtype]
    by_cases hs : s = 0
    · subst s
      simp [budgetBlocks, f]
    · have hspos : 1 ≤ s := by omega
      rw [ite_eq_right hs]
      simp only [budgetBlocks, ite_eq_right hs]
      have hm : (p.m s : ℝ) ≠ 0 := by exact_mod_cast (hp.m_pos s hspos).ne'
      calc
        (∑ i ∈ p.block s, f i) = ∑ _i ∈ p.block s, a s / (p.m s : ℝ) := by
          apply Finset.sum_congr rfl
          intro i hi
          have hi0 : i ≠ 0 := by
            have := (p.mem_block_iff s i).mp hi
            omega
          simp only [f, ite_eq_right hi0, p.blockIndex_eq_of_mem hp.m_pos hi]
        _ = a s := by
          simp only [Finset.sum_const, nsmul_eq_mul, p.card_block s hspos]
          field_simp
  have hgnonneg : ∀ s, 0 ≤ (if s = 0 then 0 else a s) := by
    intro s
    split_ifs
    · exact le_rfl
    · exact ha s
  have hgle : ∀ s, (if s = 0 then 0 else a s) ≤ a s := by
    intro s
    split_ifs
    · exact ha s
    · exact le_rfl
  have hgs : Summable (fun s : ℕ => if s = 0 then 0 else a s) :=
    Summable.of_nonneg_of_le hgnonneg hgle has
  have hfs : Summable f := by
    apply (summable_partition hfnonneg hp.budgetBlocks_partition).mpr
    constructor
    · intro s
      exact (hasSum_fintype _).summable
    · apply hgs.congr
      intro s
      exact (hblock s).symm
  refine ⟨hfs, ?_⟩
  let e := Set.sigmaEquiv (fun s => (budgetBlocks p s : Set ℕ)) hp.budgetBlocks_partition
  have he (z : Σ s, (budgetBlocks p s : Set ℕ)) : e z = z.2 := rfl
  have hsig : Summable (fun z : Σ s, (budgetBlocks p s : Set ℕ) => f z.2) := by
    apply (e.summable_iff.mpr hfs).congr
    intro z
    change f (e z) = f z.2
    rw [he]
  calc
    (∑' i, f i) = ∑' z : Σ s, (budgetBlocks p s : Set ℕ), f z.2 :=
      by simpa only [he] using (e.tsum_eq f).symm
    _ = ∑' s, ∑' i : budgetBlocks p s, f i := hsig.tsum_sigma
    _ = ∑' s, if s = 0 then 0 else a s := tsum_congr hblock
    _ ≤ ∑' s, a s := hgs.tsum_le_tsum hgle has

end CircleParameterLaws

namespace CircleParameterData

theorem summable_kappa_sq : Summable (fun s : ℕ => kappa s ^ 2) := by
  have h : Summable (fun s : ℕ => 1 / (s : ℝ) ^ 2) :=
    Real.summable_one_div_nat_pow.mpr (by norm_num)
  apply (h.mul_left ((1 / 100 : ℝ) ^ 2)).congr
  intro s
  simp only [kappa, div_pow, mul_pow]
  ring

end CircleParameterData

namespace CircleParameterLaws

variable {θ : ℝ} {p : CircleParameterData} (hp : CircleParameterLaws θ p)
include hp

theorem circle_marginal_budget (j : ℕ) :
    Summable (fun i : ℕ => if i = 0 then 0 else
      50 * (CircleParameterData.kappa (p.blockIndex i) ^ 2 /
        (p.m (p.blockIndex i) : ℝ) +
        (if p.blockIndex i = j then 1 else 0) / (p.m (p.blockIndex i) : ℝ))) ∧
    (∑' i : ℕ, if i = 0 then 0 else
      50 * (CircleParameterData.kappa (p.blockIndex i) ^ 2 /
        (p.m (p.blockIndex i) : ℝ) +
        (if p.blockIndex i = j then 1 else 0) / (p.m (p.blockIndex i) : ℝ))) ≤
      50 * ((∑' s : ℕ, CircleParameterData.kappa s ^ 2) + 1) := by
  let a : ℕ → ℝ := fun s => 50 *
    (CircleParameterData.kappa s ^ 2 + if s = j then 1 else 0)
  have ha : ∀ s, 0 ≤ a s := by
    intro s
    dsimp [a]
    positivity
  have hs : Summable a :=
    (CircleParameterData.summable_kappa_sq.add (hasSum_ite_eq j (1 : ℝ)).summable).mul_left 50
  have heq : (fun i : ℕ => if i = 0 then 0 else
      50 * (CircleParameterData.kappa (p.blockIndex i) ^ 2 /
        (p.m (p.blockIndex i) : ℝ) +
        (if p.blockIndex i = j then 1 else 0) / (p.m (p.blockIndex i) : ℝ))) =
      (fun i : ℕ => if i = 0 then 0 else
        a (p.blockIndex i) / (p.m (p.blockIndex i) : ℝ)) := by
    funext i
    dsimp [a]
    split_ifs <;> ring
  rw [heq]
  obtain ⟨hsum, hle⟩ := hp.normalized_block_budget a ha hs
  refine ⟨hsum, hle.trans_eq ?_⟩
  simp only [a, tsum_mul_left, Summable.tsum_add CircleParameterData.summable_kappa_sq
    (hasSum_ite_eq j (1 : ℝ)).summable, tsum_ite_eq]

end CircleParameterLaws
end Invariant233

end

end OAI