import OAI.MeasureTheory.Falconer.Recursion.BranchCounts
import OAI.MeasureTheory.Falconer.Recursion.BranchValidity

namespace OAI

namespace PlanarFalconer

noncomputable def branchCost (A : ℕ → ℝ) (s : BranchState) : BranchLabel → BranchState → ℝ
  | .suffix, u => A u.finish-intervalMin A u.finish s.finish
  | .high, u | .direct, u => height A s.start u.start
  | _, _ => 0

theorem BranchStep.cost_nonneg {A : ℕ → ℝ} {N q : ℕ} {sig : ℝ}
    {s u : BranchState} {label : BranchLabel} (h : BranchStep A N q sig s label u)
    (hq : 0 < q) (hv : s.Valid N sig) : 0 ≤ branchCost A s label u := by
  have hn := h.nested hq hv
  cases h <;> simp only [branchCost]
  · exact sub_nonneg.mpr (intervalMin_le A le_rfl hn.2)
  · exact le_rfl
  · exact height_nonneg A hn.1
  · exact le_rfl
  · exact le_rfl
  · exact height_nonneg A hn.1

theorem BranchStep.paid_width {A : ℕ → ℝ} {N q : ℕ} {sig : ℝ}
    {s u : BranchState} {label : BranchLabel} (h : BranchStep A N q sig s label u)
    (hq : 0 < q) (hv : s.Valid N sig) (hslack : sig*(N:ℝ) ≤ q)
    (hc : label = .suffix ∨ label = .high ∨ label = .direct) : u.start+10*q ≤ u.finish := by
  cases h with
  | suffix hw hs => exact (actual_suffix_policy_payment A hq hv.2 hw hs).1
  | high hw hs hm hg =>
    have hm := Finset.mem_Ioc.mp hm
    exact (actual_prefix_policy_payment A hq hv.2 hw hs hm.2 (high_depth_gap hm.2 hg hslack)).1
  | direct _ he => exact he.width
  | _ => simp at hc

theorem BranchStep.potential_payment {A : ℕ → ℝ} {N q : ℕ} {sig : ℝ}
    {s u : BranchState} {label : BranchLabel} (h : BranchStep A N q sig s label u)
    (hq : 0 < q) (hv : s.Valid N sig) (hslack : sig*(N:ℝ) ≤ q)
    (hu : u.start+10*q ≤ u.finish) :
    potential A s.start s.finish (10*q)+branchCost A s label u ≤
      potential A u.start u.finish (10*q) := by
  have hn := h.nested hq hv
  have hm := potential_mono A (by omega : 0 < 10*q) hu hn.1 hn.2
  cases h with
  | suffix hw hs => exact (actual_suffix_policy_payment A hq hv.2 hw hs).2
  | high hw hs hmem hg =>
    have hmem := Finset.mem_Ioc.mp hmem
    exact (actual_prefix_policy_payment A hq hv.2 hw hs hmem.2 (high_depth_gap hmem.2 hg hslack)).2
  | direct _ he => exact he.payment
  | _ => simpa only [branchCost,add_zero] using hm

theorem BranchStep.short_cost_zero {A : ℕ → ℝ} {N q : ℕ} {sig : ℝ}
    {s u : BranchState} {label : BranchLabel} (h : BranchStep A N q sig s label u)
    (hq : 0 < q) (hv : s.Valid N sig) (hslack : sig*(N:ℝ) ≤ q)
    (hu : u.finish < u.start+10*q) : branchCost A s label u = 0 := by
  have hc : ¬ (label = .suffix ∨ label = .high ∨ label = .direct) := by
    intro hl
    exact (not_le_of_gt hu) (h.paid_width hq hv hslack hl)
  cases label <;> simp_all [branchCost]

def DiscreteProfileLipschitz (A : ℕ → ℝ) (N : ℕ) : Prop :=
  ∀ i ≤ N, ∀ j ≤ N, |A i-A j| ≤ |(i:ℝ)-j|/(N:ℝ)

theorem potential_le_final_start {A : ℕ → ℝ} {N a t f Q : ℕ}
    (hN : 0 < N) (hA : DiscreteProfileLipschitz A N)
    (hQ : 0 < Q) (hw : a+Q ≤ t) (ht : t ≤ N) (haf : a ≤ f) (hft : f ≤ t) :
    potential A a t Q ≤ 2*A f+2*(Q:ℝ)/N := by
  have hNR : (0:ℝ) < N := Nat.cast_pos.mpr hN
  have hb := potential_near_final A hQ hw haf hft (e := (Q:ℝ)/N) ?_
  · simpa only [mul_div_assoc] using hb
  intro j _ hjt hjf hfj
  have hd : |(j:ℝ)-f| ≤ (Q:ℝ) := by
    have hjR : (j:ℝ) ≤ (f:ℝ)+Q := by exact_mod_cast hjf
    have hfR : (f:ℝ) ≤ (j:ℝ)+Q := by exact_mod_cast hfj
    exact abs_le.mpr ⟨by linarith,by linarith⟩
  have hh := (hA j (hjt.trans ht) f (hft.trans ht)).trans (div_le_div_of_nonneg_right hd hNR.le)
  have hh' := (le_abs_self (A j-A f)).trans hh
  linarith

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

theorem costs_le_potential (b : PolicyBranch A N q sig n) (hq : 0 < q)
    (hslack : sig*(N:ℝ) ≤ q) (hfinal : (b.state n).start+10*q ≤ (b.state n).finish) :
    ∑ j ∈ Finset.range n, branchCost A (b.state j) (b.label j) (b.state (j+1)) ≤
      potential A (b.state n).start (b.state n).finish (10*q)-
        potential A (b.state 0).start (b.state 0).finish (10*q) := by
  apply branch_cost_bound (fun j => potential A (b.state j).start (b.state j).finish (10*q))
    (fun j => branchCost A (b.state j) (b.label j) (b.state (j+1))) n
  intro j hj
  apply (b.step j hj).potential_payment hq (b.valid j hj.le) hslack
  by_cases he : j+1 = n
  · simpa only [he] using hfinal
  · have hw := (b.step (j+1) (by omega)).nonterminal
    omega

theorem costs_le_final_start (b : PolicyBranch A N q sig n) (hN : 0 < N) (hq : 0 < q)
    (hslack : sig*(N:ℝ) ≤ q) (hA : DiscreteProfileLipschitz A N)
    (hinit : (b.state 0).start+10*q ≤ (b.state 0).finish) :
    ∑ j ∈ Finset.range n, branchCost A (b.state j) (b.label j) (b.state (j+1)) ≤
      2*A (b.state n).start+20*(q:ℝ)/N-potential A (b.state 0).start (b.state 0).finish (10*q) := by
  have hQ : 0 < 10*q := by omega
  have hfinal := BranchState.valid_depths (b.valid n le_rfl)
  by_cases hw : (b.state n).start+10*q ≤ (b.state n).finish
  · have hc := b.costs_le_potential hq hslack hw
    have hf := potential_le_final_start hN hA hQ hw hfinal.2 (le_refl _) hfinal.1
    norm_num only [Nat.cast_mul,Nat.cast_ofNat] at hf
    linear_combination hc+hf
  · cases n with
    | zero => exact (hw hinit).elim
    | succ n =>
      have hs := b.step n (by omega)
      have hn := hs.nested hq (b.valid n (by omega))
      have hp := hs.nonterminal
      have hpwide : (b.state n).start+10*q ≤ (b.state n).finish := by omega
      have hd := BranchState.valid_depths (b.valid n (by omega))
      have hc := (b.initialSegment n (by omega)).costs_le_potential hq hslack hpwide
      dsimp only [initialSegment] at hc
      have hz := hs.short_cost_zero hq (b.valid n (by omega)) hslack (by omega)
      have hf := potential_le_final_start hN hA hQ hpwide hd.2 hn.1 (hfinal.1.trans hn.2)
      norm_num only [Nat.cast_mul,Nat.cast_ofNat] at hf
      rw [Finset.sum_range_succ,hz,add_zero]
      linear_combination hc+hf

end PolicyBranch

end PlanarFalconer

end OAI