import Mathlib
import OAI.Probability.Ballisticity.Estimates.GlobalProfile

namespace OAI

section

open MeasureTheory ProbabilityTheory TopologicalSpace
open scoped ENNReal NNReal Classical Topology
namespace DirectionalTransience

abbrev UpperRows {d : ℕ} (e : Direction d) := (ℕ×HorizontalSpace e) → Row d

noncomputable def upperEnvironment {d : ℕ} (e : Direction d) (ξ : UpperRows e) : Environment d :=
  fun x => ξ ((signedHeight e x).toNat,horizontalProjection e x)

lemma upperEnvironment_continuous {d : ℕ} (e : Direction d) : Continuous (upperEnvironment e) := by
  unfold upperEnvironment
  fun_prop

lemma upperEnvironment_lift {d : ℕ} (e : Direction d) (ξ : UpperRows e)
    (l : ℕ) (z : HorizontalSpace e) :
    upperEnvironment e ξ (horizontalLift e l z)=ξ (l,z) := by
  simp only [upperEnvironment,signedHeight_horizontalLift,horizontalProjection_lift,Int.toNat_natCast]

lemma continuous_wordWeight {d : ℕ} (x : Lattice d) (w : List (Direction d)) :
    Continuous (fun ω : Environment d => wordWeight ω x w) := by
  induction w generalizing x with
  | nil => exact continuous_const
  | cons u w ih =>
    change Continuous (fun ω : Environment d => ((ω x).1 u:ℝ)*wordWeight ω (x+step u) w)
    exact (NNReal.continuous_coe.comp ((continuous_apply u).comp (continuous_subtype_val.comp (continuous_apply x)))).mul (ih _)

lemma hitKernel_eq_tsum_words {d : ℕ} (ω : Environment d) (x : Lattice d)
    (S T : Set (Lattice d)) (hST : Disjoint S T) (A : Set (Lattice d)) :
    hitKernel S T (ω,x) A =
      ∑' w : {w : HitWord x S T // wordPath x w.val w.val.length∈A},
        ENNReal.ofReal (wordWeight ω x w.val.val) := by
  rw [←successfulWordLaw_endpoint ω x S T hST,
    Measure.map_apply (measurable_of_countable _) (Set.to_countable A).measurableSet,
    successfulWordLaw_apply]
  rfl

lemma hitKernel_lowerSemicontinuous {d : ℕ} (x : Lattice d)
    (S T : Set (Lattice d)) (hST : Disjoint S T) (A : Set (Lattice d)) :
    LowerSemicontinuous (fun ω : Environment d => hitKernel S T (ω,x) A) := by
  simp_rw [hitKernel_eq_tsum_words _ x S T hST A]
  exact lowerSemicontinuous_tsum fun w =>
    (ENNReal.continuous_ofReal.comp (continuous_wordWeight x w.val.val)).lowerSemicontinuous

noncomputable def upperHorizontalKernel {d : ℕ} (e : Direction d) (H : ℕ) (ξ : UpperRows e) :
    Kernel (HorizontalSpace e) (HorizontalSpace e) :=
  Kernel.mk (fun z => (variableHitKernel (realPosition (step e)) H (upperEnvironment e ξ,horizontalLift e 0 z)).map
    (horizontalProjection e)) (measurable_of_countable _)

lemma upperHorizontalKernel_apply {d : ℕ} (e : Direction d) (H : ℕ) (ξ : UpperRows e)
    (z : HorizontalSpace e) (A : Set (HorizontalSpace e)) :
    upperHorizontalKernel e H ξ z A =
      hitKernel (Strip (realPosition (step e)) (horizontalLift e 0 z) H)
        (Upper (realPosition (step e)) (horizontalLift e 0 z) H)
        (upperEnvironment e ξ,horizontalLift e 0 z) (horizontalProjection e ⁻¹' A) := by
  rw [upperHorizontalKernel,Kernel.coe_mk,Measure.map_apply (measurable_of_countable _) (Set.to_countable A).measurableSet]
  rfl

lemma upperHorizontalKernel_lowerSemicontinuous {d : ℕ} (e : Direction d) (H : ℕ)
    (z : HorizontalSpace e) (A : Set (HorizontalSpace e)) :
    LowerSemicontinuous (fun ξ : UpperRows e => upperHorizontalKernel e H ξ z A) := by
  simp_rw [upperHorizontalKernel_apply]
  exact (hitKernel_lowerSemicontinuous _ _ _ (disjoint_strip_upper _ _ _) _).comp
    (upperEnvironment_continuous e)

lemma upperHorizontalKernel_mass_le_one {d : ℕ} (e : Direction d) (H : ℕ) (ξ : UpperRows e)
    (z : HorizontalSpace e) : upperHorizontalKernel e H ξ z Set.univ ≤ 1 := by
  rw [upperHorizontalKernel_apply,Set.preimage_univ]
  exact hitKernel_total_le_one (disjoint_strip_upper _ _ _) _

end DirectionalTransience

end

section

open MeasureTheory ProbabilityTheory
open scoped ENNReal NNReal Classical BigOperators
namespace DirectionalTransience

lemma wordPath_endpoint_sum {d : ℕ} (x : Lattice d) (w : List (Direction d)) :
    wordPath x w w.length=x+(w.map step).sum := by
  induction w generalizing x with
  | nil => simp [wordPath]
  | cons u w ih => simp [wordPath,ih,add_assoc]

lemma wordPath_replicate_min {d : ℕ} (x : Lattice d) (u : Direction d) (k n : ℕ) :
    wordPath x (List.replicate k u) n=x+(min n k:ℕ) • step u := by
  induction k generalizing x n with
  | zero => simp [wordPath]
  | succ k ih =>
    cases n with
    | zero => simp
    | succ n =>
      rw [List.replicate_succ,wordPath,ih,min_add_add_right,succ_nsmul]
      abel

lemma exists_horizontal_word {d : ℕ} (e : Direction d) (z : HorizontalSpace e) :
    ∃ w : List (Direction d), (w.map step).sum=z.val ∧ ∀ u∈w, u.1≠e.1 := by
  have hsingle (i : Fin d) : ∃ w : List (Direction d),
      (w.map step).sum=Pi.single i (z.val i) ∧ ∀ u∈w, u.1≠e.1 := by
    by_cases hi : i=e.1
    · subst i
      refine ⟨[],?_,by simp⟩
      have hz : z.val e.1=0 := z.property
      simp [hz]
    · cases hz : z.val i with
      | ofNat n =>
        refine ⟨List.replicate n (i,true),?_,?_⟩
        · simp only [List.map_replicate,List.sum_replicate]
          funext j
          by_cases hj : j=i
          · subst j; simp [step]
          · simp [step,hj]
        · intro u hu
          have he := List.eq_of_mem_replicate hu
          simpa only [he] using hi
      | negSucc n =>
        refine ⟨List.replicate (n+1) (i,false),?_,?_⟩
        · simp only [List.map_replicate,List.sum_replicate]
          funext j
          by_cases hj : j=i
          · subst j; simp [step]; omega
          · simp [step,hj]
        · intro u hu
          have he := List.eq_of_mem_replicate hu
          simpa only [he] using hi
  have hf (s : Finset (Fin d)) : ∃ w : List (Direction d),
      (w.map step).sum=∑ i∈s, Pi.single i (z.val i) ∧ ∀ u∈w, u.1≠e.1 := by
    induction s using Finset.induction_on with
    | empty => exact ⟨[],by simp,by simp⟩
    | @insert i s hi ih =>
      obtain ⟨v,hv,hve⟩ := hsingle i
      obtain ⟨w,hw,hwe⟩ := ih
      refine ⟨v++w,by simp [hv,hw,hi],?_⟩
      intro u hu
      rcases List.mem_append.mp hu with hu|hu
      · exact hve u hu
      · exact hwe u hu
  obtain ⟨w,hw,hwe⟩ := hf Finset.univ
  refine ⟨w,hw.trans ?_,hwe⟩
  funext j
  simp

lemma wordPath_horizontal {d : ℕ} (e : Direction d) (x : Lattice d)
    (w : List (Direction d)) (hw : ∀ u∈w, u.1≠e.1) (n : ℕ) :
    signedHeight e (wordPath x w n)=signedHeight e x := by
  induction w generalizing x n with
  | nil => rfl
  | cons u w ih =>
    cases n with
    | zero => rfl
    | succ n =>
      rw [wordPath,ih (x+step u) (fun g hg => hw g (by simp [hg]))]
      have hu := hw u (by simp)
      rw [signedHeight_add]
      simp [signedHeight, step,Ne.symm hu]

lemma positive_wordWeight {d : ℕ} (ω : Environment d)
    (hω : ∀ x u, 0<(ω x).val u) (x : Lattice d) (w : List (Direction d)) :
    0<wordWeight ω x w := by
  induction w generalizing x with
  | nil => norm_num [wordWeight]
  | cons u w ih =>
    exact mul_pos (NNReal.coe_pos.mpr (hω x u)) (ih _)

lemma upperHorizontalKernel_pos {d : ℕ} (e : Direction d) (H : ℕ) (hH : 0<H)
    (ξ : UpperRows e) (hξ : ∀ p u, 0<(ξ p).val u) (x y : HorizontalSpace e) :
    0<upperHorizontalKernel e H ξ x {y} := by
  obtain ⟨v,hv,hve⟩ := exists_horizontal_word e (y-x)
  let w := v++List.replicate H e
  have hend : wordPath (horizontalLift e 0 x) v v.length=horizontalLift e 0 y := by
    rw [wordPath_endpoint_sum,hv]
    simp only [horizontalLift,zero_zsmul,add_zero,AddSubgroup.coe_sub]
    abel
  have hy : wordPath (horizontalLift e 0 x) w w.length=horizontalLift e H y := by
    simp only [w,List.length_append,List.length_replicate]
    rw [wordPath_append_suffix,hend,wordPath_replicate_min,Nat.min_self]
    simp [horizontalLift]
  have hh : wordPath (horizontalLift e 0 x) w∈HitAt
      (Strip (realPosition (step e)) (horizontalLift e 0 x) H)
      (Upper (realPosition (step e)) (horizontalLift e 0 x) H) w.length := by
    constructor
    · rw [coordinate_mem_upper_iff,hy,signedHeight_horizontalLift,signedHeight_horizontalLift]
      omega
    · intro n hn
      rw [coordinate_mem_strip_iff,signedHeight_horizontalLift]
      by_cases hnv : n≤v.length
      · have he := wordPath_append_prefix (horizontalLift e 0 x) v (List.replicate H e) hnv
        rw [he,wordPath_horizontal e _ v hve,signedHeight_horizontalLift]
        omega
      · have hn' : n=v.length+(n-v.length) := by omega
        rw [hn',wordPath_append_suffix,hend,wordPath_replicate_min,signedHeight_add,
          signedHeight_horizontalLift]
        have hmin : min (n-v.length) H=n-v.length := by
          have hh : n<v.length+H := by simpa only [w,List.length_append,List.length_replicate] using hn
          omega
        rw [hmin]
        have he : signedHeight e ((n-v.length) • step e)=(n-v.length:ℕ) := by
          exact_mod_cast signedHeight_zsmul_step e (n-v.length:ℕ)
        rw [he]
        have hh : n<v.length+H := by simpa only [w,List.length_append,List.length_replicate] using hn
        omega
  rw [upperHorizontalKernel_apply,hitKernel_eq_tsum_words _ _ _ _ (disjoint_strip_upper _ _ _) _]
  let a : {w : HitWord (horizontalLift e 0 x)
      (Strip (realPosition (step e)) (horizontalLift e 0 x) H)
      (Upper (realPosition (step e)) (horizontalLift e 0 x) H) //
      wordPath (horizontalLift e 0 x) w.val w.val.length∈horizontalProjection e ⁻¹' {y}} :=
    ⟨⟨w,hh⟩,by change horizontalProjection e (wordPath _ w w.length)=y; rw [hy,horizontalProjection_lift]⟩
  exact lt_of_lt_of_le (ENNReal.ofReal_pos.mpr (positive_wordWeight (upperEnvironment e ξ)
    (fun z u => hξ _ u) (horizontalLift e 0 x) w))
    (ENNReal.le_tsum (f := fun term => ENNReal.ofReal
      (wordWeight (upperEnvironment e ξ) (horizontalLift e 0 x) term.val.val)) a)

end DirectionalTransience

end

end OAI