import OAI.Probability.DirectionalWalk.FreshPaths

namespace OAI

open MeasureTheory ProbabilityTheory Filter Preorder
open scoped ENNReal BigOperators Topology

namespace DirectionalZeroOne

open scoped Classical

noncomputable def wordEndpointCoordinate {d ι : ℕ} (P : Measure (Path d))
    (E : Fin ι → Set (Path d)) (q : Fin ι) (a : Word d) : ℝ :=
  runningMax (endpointPosterior P E q) a.1 (wordPath a)

lemma sum_wordEndpointCoordinate {d ι : ℕ} (P : Measure (Path d))
    (E : Fin ι → Set (Path d)) (a : Word d) :
    ∑ q, wordEndpointCoordinate P E q a = wordEndpointMax P E a := rfl

lemma wordPosterior_le_stoppedCoordinate {d ι : ℕ} (P : Measure (Path d))
    (E : Fin ι → Set (Path d)) (q : Fin ι) (K : Set (Site d)) (a : Word d)
    (ha : ∀ j < a.1, wordPath a j ∉ K) (X : Path d) (hX : X ∈ wordCylinder a)
    (hex : ∃ n, X n ∈ K) :
    wordPosterior P E q a ≤ wordEndpointCoordinate P E q (firstVisitWord K X) := by
  classical
  have hle : a.1 ≤ firstVisitIndex K X := by
    by_contra h
    have hj : firstVisitIndex K X < a.1 := by omega
    apply ha _ hj
    rw [← hX _ hj.le,firstVisitIndex_eq K X hex]
    exact Nat.find_spec hex
  have hc : X ∈ wordCylinder (firstVisitWord K X) := (firstVisitWord_spec K X hex).2
  have he : endpointPosterior P E q a.1 X = wordPosterior P E q a := by
    unfold endpointPosterior
    rw [(prefixWord_eq_iff a.1 X a).mpr ⟨rfl,hX⟩]
  rw [← he,endpointPosterior_prefix P E q (firstVisitWord K X) X hc hle]
  exact Finset.le_sup' (fun i => endpointPosterior P E q i (wordPath (firstVisitWord K X)))
    (Finset.mem_range.mpr (Nat.lt_succ_of_le hle))

def upperContactWord {d : ℕ} (z : Site d) (R K : Set (Site d)) (a : Word d) : Prop :=
  wordPath a 0 = z ∧ (∃ j ≤ a.1, wordPath a j ∈ R) ∧ ∀ j ≤ a.1, wordPath a j ∉ K

def contactBinWords {d : ℕ} (e : Step d) (z : Site d) (r N : ℕ) (a : ℝ≥0∞)
    (ω : Environment d) : Set (Word d) :=
  {b | upperContactWord z (axisUpper e r) (axisLower e 0 ∪ axisUpper e N) b ∧
    wordEnd b ∈ returnBin e 0 N a ω}

lemma upperContactWord_visit {d : ℕ} (z : Site d) (R K A : Set (Site d)) (b : Word d)
    (hb : upperContactWord z R K b) (hA : wordEnd b ∈ A) :
    wordCylinder b ⊆ visitAfter R A K := by
  intro X hX
  refine ⟨b.1,?_,?_,?_⟩
  · rw [hX _ le_rfl];exact hA
  · obtain ⟨j,hj,hR⟩ := hb.2.1
    exact ⟨j,hj,by rw [hX _ hj];exact hR⟩
  · intro j hj
    rw [hX _ hj]
    exact hb.2.2 j hj

lemma posterior_contact_bin_quenched {d ι : ℕ} (P : Measure (Path d)) [IsProbabilityMeasure P]
    (E : Fin ι → Set (Path d)) (hE : ∀ q, MeasurableSet (E q))
    (hdis : Pairwise (fun i j => Disjoint (E i) (E j))) (e : Step d)
    (ω : Environment d) (z : Site d) (start : Fin ι → Site d) (r N : ℕ) (a : ℝ≥0∞)
    (hex : ∀ᵐ X ∂quenchedKernel d (ω,z), ∃ n, X n ∈ axisLower e 0 ∪ axisUpper e N)
    (hneg : ∀ x : Site d, quenchedKernel d (ω,x)
      (avoids (axisUpper e N) ∩ {B | ∃ n, B n ∈ returnBin e 0 N a ω}) ≤ 2*a) :
    (∑ q, ∑' b : contactBinWords e z r N a ω,
      ENNReal.ofReal (wordPosterior P E q b) *
        (quenchedKernel d (ω,z) (wordCylinder b) *
          quenchedKernel d (ω,start q) (avoids (axisUpper e N) ∩ contactAvoid b))) ≤
      (2*a) * ∫⁻ X in visitAfter (axisUpper e r) (returnAtLeast e 0 N a ω)
        (axisLower e 0 ∪ axisUpper e N),
        ENNReal.ofReal (wordEndpointMax P E (firstVisitWord (axisLower e 0 ∪ axisUpper e N) X))
        ∂quenchedKernel d (ω,z) := by
  classical
  let K := axisLower e 0 ∪ axisUpper e N
  let V := visitAfter (axisUpper e r) (returnAtLeast e 0 N a ω) K
  let M := fun q X => ENNReal.ofReal (wordEndpointCoordinate P E q (firstVisitWord K X))
  have hM (q : Fin ι) : Measurable (M q) :=
    ((measurable_of_countable (wordEndpointCoordinate P E q)).comp (measurable_firstVisitWord K)).ennreal_ofReal
  have hq (q : Fin ι) : (∑' b : contactBinWords e z r N a ω,
      ENNReal.ofReal (wordPosterior P E q b) *
        (quenchedKernel d (ω,z) (wordCylinder b) *
          quenchedKernel d (ω,start q) (avoids (axisUpper e N) ∩ contactAvoid b))) ≤
        (2*a) * ∫⁻ X in V, M q X ∂quenchedKernel d (ω,z) := by
    apply weighted_contact_bin_bound_ae _ _ (contactBinWords e z r N a ω)
      (avoids (axisUpper e N)) V (returnBin e 0 N a ω) (measurableSet_avoids _)
      (fun b => ENNReal.ofReal (wordPosterior P E q b)) (M q) (hM q)
      (fun _ hb => hb.2)
    · intro b hb
      exact upperContactWord_visit z _ _ _ b hb.1 hb.2.1
    · intro b hb
      filter_upwards [hex] with X hx
      exact fun hX => ENNReal.ofReal_le_ofReal (wordPosterior_le_stoppedCoordinate P E q K b
        (fun j hj => hb.1.2.2 j hj.le) X hX hx)
    · exact hneg _
  calc
    _ ≤ ∑ q, (2*a) * ∫⁻ X in V, M q X ∂quenchedKernel d (ω,z) := Finset.sum_le_sum (fun q _ => hq q)
    _ = (2*a) * ∫⁻ X in V, (∑ q, M q X) ∂quenchedKernel d (ω,z) := by
      rw [lintegral_finsetSum _ (fun q _ => hM q),Finset.mul_sum]
    _ = _ := by
      congr 1
      apply lintegral_congr
      intro X
      change (∑ q, ENNReal.ofReal (wordEndpointCoordinate P E q (firstVisitWord K X))) = _
      rw [← ENNReal.ofReal_sum_of_nonneg (fun q _ => show 0 ≤ wordEndpointCoordinate P E q (firstVisitWord K X) from
        runningMax_nonneg _ ((endpointPosterior_bounds P E hE hdis).1 q) _ _),sum_wordEndpointCoordinate]

lemma posterior_contact_bin_joint {d ι : ℕ} (μ : Measure (Row d)) [IsProbabilityMeasure μ]
    (hell : StrictEllipticity μ) (P : Measure (Path d)) [IsProbabilityMeasure P]
    (E : Fin ι → Set (Path d)) (hE : ∀ q, MeasurableSet (E q))
    (hdis : Pairwise (fun i j => Disjoint (E i) (E j))) (e : Step d)
    (z : Site d) (start : Fin ι → Site d) (r N : ℕ) (a : ℝ≥0∞) (ha : a ≠ ∞) :
    (∫⁻ ω, ∑ q, ∑' b : contactBinWords e z r N a ω,
      ENNReal.ofReal (wordPosterior P E q b) *
        (quenchedKernel d (ω,z) (wordCylinder b) *
          quenchedKernel d (ω,start q) (avoids (axisUpper e N) ∩ contactAvoid b)) ∂environmentLaw μ) ≤
    (2*a) * ∫⁻ ξ in {ξ | ξ.2 ∈ visitAfter (axisUpper e r) (returnAtLeast e 0 N a ξ.1)
      (axisLower e 0 ∪ axisUpper e N)},
      ENNReal.ofReal (wordEndpointMax P E (firstVisitWord (axisLower e 0 ∪ axisUpper e N) ξ.2))
      ∂freshJoint μ z := by
  let K := axisLower e 0 ∪ axisUpper e N
  let V : Set (Environment d × Path d) := {ξ | ξ.2 ∈ visitAfter (axisUpper e r) (returnAtLeast e 0 N a ξ.1) K}
  let f : Environment d × Path d → ℝ≥0∞ := fun ξ => ENNReal.ofReal (wordEndpointMax P E (firstVisitWord K ξ.2))
  have hf : Measurable f := ((measurable_of_countable (wordEndpointMax P E)).comp
    ((measurable_firstVisitWord K).comp measurable_snd)).ennreal_ofReal
  have hV : MeasurableSet V := measurable_random_visitAfter _ _ _ (measurableSet_returnAtLeast e 0 N a)
  have hex : ∀ᵐ ω ∂environmentLaw μ, ∀ᵐ X ∂quenchedKernel d (ω,z), ∃ n, X n ∈ K := by
    apply annealed_ae_quenched μ z
    · have hh : (fun X : Path d => ∃ n, X n ∈ K) = ⋃ n : ℕ, {X : Path d | X n ∈ K} := by
        funext X
        apply propext
        change (∃ n, X n ∈ K) ↔ X ∈ ⋃ n : ℕ, {X : Path d | X n ∈ K}
        constructor
        · rintro ⟨n, hn⟩
          exact Set.mem_iUnion.mpr ⟨n, hn⟩
        · intro h
          exact Set.mem_iUnion.mp h
      rw [hh]
      exact MeasurableSet.iUnion (fun n => (Set.to_countable K).measurableSet.preimage (measurable_pi_apply n))
    · exact annealed_axis_exit μ hell e z 0 N
  have hinner : (∫⁻ ξ in V, f ξ ∂freshJoint μ z) =
      ∫⁻ ω, ∫⁻ X in visitAfter (axisUpper e r) (returnAtLeast e 0 N a ω) K,
        ENNReal.ofReal (wordEndpointMax P E (firstVisitWord K X)) ∂quenchedKernel d (ω,z) ∂environmentLaw μ := by
    rw [← lintegral_indicator hV,freshJoint_lintegral μ z _ (hf.indicator hV)]
    apply lintegral_congr
    intro ω
    rw [← lintegral_indicator (measurableSet_visitAfter _ _ _)]
    rfl
  change _ ≤ (2*a) * ∫⁻ ξ in V, f ξ ∂freshJoint μ z
  rw [hinner,← lintegral_const_mul' _ _ (ENNReal.mul_ne_top (by norm_num) ha)]
  apply lintegral_mono_ae
  filter_upwards [hex,quenched_negative_bins μ hell e] with ω hω hn
  apply posterior_contact_bin_quenched P E hE hdis e ω z start r N a hω
  intro x
  exact hn x 0 N (returnBin e 0 N a ω) (2*a) (fun y hy => hy.2.le)

lemma axisHeight_axialRay {d : ℕ} (e f : Step d) (x : Site d) (n : ℕ) :
    axisHeight e (axialRay x f n) = axisHeight e x + n * axisHeight e (stepVector f) := by
  induction n with
  | zero => simp [axialRay_zero]
  | succ n ih => rw [axialRay_succ,axisHeight_add,ih,Nat.cast_add,Nat.cast_one];ring

lemma axisHeight_step_opposite {d : ℕ} (e : Step d) :
    axisHeight e (stepVector (oppositeStep e)) = -1 := by
  have h := axisHeight_step_self (oppositeStep e)
  rw [axisHeight_opposite] at h
  omega

lemma quenchedReturn_pos_lt_one {d : ℕ} (e : Step d) (k N : ℤ)
    (ω : Environment d) (hω : ∀ x f, 0 < (ω x).val f) (y : Site d)
    (hy : k ≤ axisHeight e y ∧ axisHeight e y < N) :
    0 < quenchedReturn e k N ω y ∧ quenchedReturn e k N ω y < 1 := by
  let down := (axisHeight e y-k+1).toNat
  let up := (N-axisHeight e y).toNat
  have hd : (down : ℤ) = axisHeight e y-k+1 := Int.toNat_of_nonneg (by omega)
  have hu : (up : ℤ) = N-axisHeight e y := Int.toNat_of_nonneg (by omega)
  have hdown : pathCylinder down (axialRay y (oppositeStep e)) ⊆ hitBefore (axisLower e k) (axisUpper e N) := by
    intro X hX
    refine ⟨down,?_,?_⟩
    · rw [hX _ le_rfl]
      change axisHeight e (axialRay y (oppositeStep e) down) < k
      rw [axisHeight_axialRay,axisHeight_step_opposite,hd]
      omega
    · intro i hi
      rw [hX _ hi]
      change ¬N ≤ axisHeight e (axialRay y (oppositeStep e) i)
      rw [axisHeight_axialRay,axisHeight_step_opposite]
      omega
  have hup : pathCylinder up (axialRay y e) ⊆ hitBefore (axisUpper e N) (axisLower e k) := by
    intro X hX
    refine ⟨up,?_,?_⟩
    · rw [hX _ le_rfl]
      change N ≤ axisHeight e (axialRay y e up)
      rw [axisHeight_axialRay,axisHeight_step_self,hu]
      omega
    · intro i hi
      rw [hX _ hi]
      change ¬axisHeight e (axialRay y e i) < k
      rw [axisHeight_axialRay,axisHeight_step_self]
      omega
  have hdp : 0 < quenchedReturn e k N ω y :=
    (quenched_axialRay_pos ω hω y (oppositeStep e) down).trans_le (measure_mono hdown)
  have hup' : 0 < quenchedKernel d (ω,y) (hitBefore (axisUpper e N) (axisLower e k)) :=
    (quenched_axialRay_pos ω hω y e up).trans_le (measure_mono hup)
  refine ⟨hdp,lt_of_le_of_ne prob_le_one ?_⟩
  intro he
  have hb : quenchedReturn e k N ω y + quenchedKernel d (ω,y) (hitBefore (axisUpper e N) (axisLower e k)) ≤ 1 := by
    rw [quenchedReturn,← measure_union (hitBefore_disjoint _ _) (measurableSet_hitBefore _ _)]
    exact prob_le_one
  rw [he] at hb
  have hz : quenchedKernel d (ω,y) (hitBefore (axisUpper e N) (axisLower e k)) ≤ 0 := by
    apply (ENNReal.add_le_add_iff_left (by norm_num : (1 : ℝ≥0∞) ≠ ∞)).mp
    simpa using hb
  exact (not_le_of_gt hup') hz

end DirectionalZeroOne

end OAI