import OAI.MeasureTheory.Falconer.Recursion.BranchTransitions

namespace OAI

namespace PlanarFalconer

def branchCount (label : ℕ → BranchLabel) (n : ℕ) (kind : BranchLabel) : ℕ :=
  ∑ j ∈ Finset.range n, if label j = kind then 1 else 0

theorem branchCount_card (label : ℕ → BranchLabel) (n : ℕ) (kind : BranchLabel) :
    branchCount label n kind = ((Finset.range n).filter fun j => label j = kind).card := by
  simp [branchCount]

theorem branchCount_succ (label : ℕ → BranchLabel) (n : ℕ) (kind : BranchLabel) :
    branchCount label (n+1) kind = branchCount label n kind + if label n = kind then 1 else 0 := by
  simp only [branchCount,Finset.sum_range_succ]

structure PolicyBranch (A : ℕ → ℝ) (N q : ℕ) (sig : ℝ) (n : ℕ) where
  state : ℕ → BranchState
  label : ℕ → BranchLabel
  valid : ∀ j ≤ n, (state j).Valid N sig
  step : ∀ j < n, BranchStep A N q sig (state j) (label j) (state (j+1))

namespace PolicyBranch
variable {A : ℕ → ℝ} {N q n : ℕ} {sig : ℝ}

def initialSegment (b : PolicyBranch A N q sig n) (m : ℕ) (hm : m ≤ n) : PolicyBranch A N q sig m :=
  ⟨b.state,b.label,fun j hj => b.valid j (hj.trans hm),fun j hj => b.step j (hj.trans_le hm)⟩

theorem nested (b : PolicyBranch A N q sig n) (hq : 0 < q) :
    MonotoneOn (fun j => (b.state j).start) (Set.Icc 0 n) ∧
    AntitoneOn (fun j => (b.state j).finish) (Set.Icc 0 n) := by
  have hpair : ∀ j k, j ≤ k → k ≤ n →
      (b.state j).start ≤ (b.state k).start ∧ (b.state k).finish ≤ (b.state j).finish := by
    intro j k hjk hkn
    induction k, hjk using Nat.le_induction with
    | base => exact ⟨le_rfl,le_rfl⟩
    | succ k hjk ih =>
      have hp := ih (by omega)
      have hs := (b.step k (by omega)).nested hq (b.valid k (by omega))
      exact ⟨hp.1.trans hs.1,hs.2.trans hp.2⟩
  exact ⟨fun _ _ _ hk hjk => (hpair _ _ hjk hk.2).1,
    fun _ _ _ hk hjk => (hpair _ _ hjk hk.2).2⟩

noncomputable def chargedNear (b : PolicyBranch A N q sig n) : Finset ℕ := by
  classical
  exact (Finset.range n).filter fun j => b.label j = .near ∧ ChargedNear A N q (b.state j) (b.state (j+1))

noncomputable def charges (b : PolicyBranch A N q sig n) : Finset ℕ := by
  classical
  exact (Finset.range n).filter fun j => b.label j = .high ∨ b.label j = .direct ∨
    b.label j = .near ∧ ChargedNear A N q (b.state j) (b.state (j+1))

theorem charges_card (b : PolicyBranch A N q sig n) :
    b.charges.card = branchCount b.label n .high + branchCount b.label n .direct + b.chargedNear.card := by
  classical
  simp only [charges,chargedNear,Finset.card_filter,branchCount,← Finset.sum_add_distrib]
  apply Finset.sum_congr rfl
  intro j _
  cases b.label j <;> simp

theorem charges_have_representatives (b : PolicyBranch A N q sig n) (hq : 0 < q)
    {j : ℕ} (hj : j ∈ b.charges) :
    ∃ p ∈ policyRepresentatives A N q, (b.state j).start < p ∧ p ≤ (b.state (j+1)).start := by
  classical
  obtain ⟨hj,hlabel⟩ := Finset.mem_filter.mp hj
  have hjn := Finset.mem_range.mp hj
  rcases hlabel with hh | hd | ⟨hn,he⟩
  · have hg := (b.step j hjn).graph_charge hq (b.valid j hjn.le) (Or.inl hh)
    exact ⟨_,hg.2,hg.1,le_rfl⟩
  · have hg := (b.step j hjn).graph_charge hq (b.valid j hjn.le) (Or.inr hd)
    exact ⟨_,hg.2,hg.1,le_rfl⟩
  · obtain ⟨_,e,he,_,ha,hp⟩ := he
    have hr : descriptorAnchor e ∈ policyRepresentatives A N q := by
      cases hs : b.state j <;> rw [hs] at he
      · exact policyDescriptor_anchor_mem A hq he
      · exact policyDescriptor_anchor_mem A hq (Finset.mem_filter.mp he).1
    exact ⟨descriptorAnchor e,hr,ha,hp⟩

theorem representative_counts (b : PolicyBranch A N q sig n) (hq : 0 < q) :
    branchCount b.label n .high + branchCount b.label n .direct + b.chargedNear.card ≤
        (policyRepresentatives A N q).card ∧
      (policyRepresentatives A N q).card ≤ N/q+1 := by
  classical
  let charge := fun j => if hj : j ∈ b.charges then
    Classical.choose (b.charges_have_representatives hq hj) else 0
  have hspec (j : ℕ) (hj : j ∈ b.charges) :
      charge j ∈ policyRepresentatives A N q ∧
      (b.state j).start < charge j ∧ charge j ≤ (b.state (j+1)).start := by
    simpa only [charge,dite_eq_left hj] using Classical.choose_spec (b.charges_have_representatives hq hj)
  have hb := branch_representative_charges_bound A N q n (fun j => (b.state j).start)
    charge b.charges (Finset.filter_subset _ _) (b.nested hq).1
    (fun j hj => (hspec j hj).2) (fun j hj => (hspec j hj).1)
  exact ⟨by rw [← b.charges_card]; exact hb.1,policy_representatives_card A N q⟩

theorem near_count (b : PolicyBranch A N q sig n) (hq : 0 < q)
    (hceil : ⌈10*sig*(N:ℝ)⌉₊ < q) :
    branchCount b.label n .near ≤ b.chargedNear.card + branchCount b.label n .direct + 1 := by
  classical
  let U := (Finset.range n).filter fun j => b.label j = .near ∧
    ¬ ChargedNear A N q (b.state j) (b.state (j+1))
  have hpartition : branchCount b.label n .near = b.chargedNear.card+U.card := by
    simp only [chargedNear,U,Finset.card_filter,branchCount,← Finset.sum_add_distrib]
    apply Finset.sum_congr rfl
    intro j _
    by_cases hl : b.label j = .near <;>
      by_cases hc : ChargedNear A N q (b.state j) (b.state (j+1)) <;> simp [hl,hc]
  have hu : U.card ≤ branchCount b.label n .direct+1 := by
    rw [branchCount_card]
    let D := ((Finset.range n).filter fun j => b.label j = .direct)
    have hmap : U.image Nat.succ ⊆ insert n D := by
      intro k hk
      obtain ⟨j,hj,rfl⟩ := Finset.mem_image.mp hk
      obtain ⟨hjn,hn,hc⟩ := Finset.mem_filter.mp hj
      have hjn := Finset.mem_range.mp hjn
      by_cases he : j+1 = n
      · exact Finset.mem_insert.mpr (Or.inl he)
      · apply Finset.mem_insert.mpr
        apply Or.inr
        have hnext := near_uncharged_next_direct hq hceil
          (by simpa only [hn] using b.step j hjn) hc (b.step (j+1) (by omega))
        exact Finset.mem_filter.mpr ⟨Finset.mem_range.mpr (by omega),hnext⟩
    calc
      U.card = (U.image Nat.succ).card := (Finset.card_image_of_injective _ Nat.succ_injective).symm
      _ ≤ (insert n D).card := Finset.card_le_card hmap
      _ ≤ D.card+1 := Finset.card_insert_le _ _
  omega

theorem episode_identity (b : PolicyBranch A N q sig n) :
    (b.state n).angular + branchCount b.label n .far =
      (b.state 0).angular + branchCount b.label n .high := by
  induction n with
  | zero => simp [branchCount]
  | succ n ih =>
    have hp := ih (b.initialSegment n (by omega))
    have hs := (b.step n (by omega)).episode_balance
    dsimp only [initialSegment] at hp
    rw [branchCount_succ,branchCount_succ]
    omega

theorem far_count (b : PolicyBranch A N q sig n) :
    branchCount b.label n .far ≤ branchCount b.label n .high+1 := by
  have hi := b.episode_identity
  have hzero : (b.state 0).angular ≤ 1 := by cases b.state 0 <;> simp [BranchState.angular]
  omega

theorem suffix_total_decrease (b : PolicyBranch A N q sig n) (hq : 0 < q) :
    (b.state n).finish + branchCount b.label n .suffix*q ≤ (b.state 0).finish := by
  induction n with
  | zero => simp [branchCount]
  | succ n ih =>
    have hp := ih (b.initialSegment n (by omega))
    dsimp only [initialSegment] at hp
    have hs := (b.step n (by omega)).nested hq (b.valid n (by omega))
    rw [branchCount_succ,Nat.add_mul]
    by_cases hl : b.label n = .suffix
    · have hd := BranchStep.suffix_decrease (by simpa only [hl] using b.step n (by omega)) hq
        (b.valid n (by omega))
      simp only [hl,ite_true,one_mul]
      omega
    · simp only [hl,ite_false,zero_mul]
      omega

theorem low_total_decrease (b : PolicyBranch A N q sig n) (hq : 0 < q) :
    ((b.state n).finish:ℝ) + (branchCount b.label n .low:ℝ)*(sig*N) ≤ (b.state 0).finish := by
  induction n with
  | zero => simp [branchCount]
  | succ n ih =>
    have hp := ih (b.initialSegment n (by omega))
    dsimp only [initialSegment] at hp
    have hs := (b.step n (by omega)).nested hq (b.valid n (by omega))
    have hsR : ((b.state (n+1)).finish:ℝ) ≤ (b.state n).finish := Nat.cast_le.mpr hs.2
    rw [branchCount_succ]
    by_cases hl : b.label n = .low
    · have hd := BranchStep.low_decrease (by simpa only [hl] using b.step n (by omega))
      simp only [hl,ite_true,Nat.cast_add,Nat.cast_one]
      nlinarith
    · simp only [hl,ite_false,add_zero]
      linarith

theorem index_identity (b : PolicyBranch A N q sig n) :
    (b.state n).index = (b.state 0).index + branchCount b.label n .suffix +
      branchCount b.label n .low + branchCount b.label n .far := by
  induction n with
  | zero => simp [branchCount]
  | succ n ih =>
    have hp := ih (b.initialSegment n (by omega))
    dsimp only [initialSegment] at hp
    have hs := (b.step n (by omega)).index_change
    rw [branchCount_succ,branchCount_succ,branchCount_succ,hs,hp]
    cases b.label n <;> simp <;> omega

end PolicyBranch

end PlanarFalconer

end OAI