import Mathlib
import OAI.Probability.CriticalPercolation.Clusters.PercolationTail
import OAI.Probability.CriticalPercolation.Gluing.MoveExit
import OAI.Probability.CriticalPercolation.Gluing.MoveWitness
import OAI.Probability.CriticalPercolation.Gluing.RelayMoves
import OAI.Probability.CriticalPercolation.GraphGeometry.GraphBalls
import OAI.Probability.CriticalPercolation.GraphGeometry.OpenGraphIso
import OAI.Probability.CriticalPercolation.ProductMeasure.LevelContactMeasurability

namespace OAI

section
section
noncomputable section
open Set Function MeasureTheory ProbabilityTheory Filter
open scoped Classical Topology ENNReal

namespace CriticalPercolation.BondGraph
variable {V E : Type*} (G : BondGraph V E)

lemma cluster_induced_subset (ω : Set E) (S : Set V) {a : V} (ha : a∈S) :
    G.cluster (ω∩G.inducedEdges S) a⊆S := by
  rintro b ⟨w⟩
  exact G.walk_induced_support w.reverse ha b w.reverse.start_mem_support

lemma infinite_strip_unbounded (u v : V → ℝ) (W L : ℝ) (ω : Set E) (a : V)
    (ha : |v a|≤W)
    (hi : (G.cluster (ω∩G.inducedEdges {x | |v x|≤W}) a).Infinite)
    (hbox : (G.cluster (ω∩G.inducedEdges {x | |u x|≤L ∧ |v x|≤W}) a).Finite) :
    ∃ b∈G.cluster (ω∩G.inducedEdges {x | |v x|≤W}) a, L < |u b| := by
  by_contra hn
  push Not at hn
  apply hi
  apply hbox.subset
  rintro b ⟨w⟩
  let w' := w.mapLe (G.openGraph_mono Set.inter_subset_left)
  apply G.walk_reachable_induced _ ω w'
  intro x hx
  rw [SimpleGraph.Walk.support_mapLe_eq_support] at hx
  have hr : x∈G.cluster (ω∩G.inducedEdges {x | |v x|≤W}) a := (w.takeUntil x hx).reachable
  exact ⟨hn x hr,G.cluster_induced_subset ω _ ha hr⟩

lemma strip_cluster_gives_exit (u v : V → ℝ) (A : Set V) (W L D : ℝ)
    (hD : 0≤D) (hu : ∀ ⦃x y⦄, G.fullGraph.Adj x y → |u x-u y|≤D)
    (hA : ∀ a∈A, |u a|<L ∧ |v a|≤W)
    {ω : Set E} (hi : ∃ a∈A, (G.cluster (ω∩G.inducedEdges {x | |v x|≤W}) a).Infinite)
    (hbox : ∀ a∈A, (G.cluster (ω∩G.inducedEdges {x | |u x|≤L ∧ |v x|≤W}) a).Finite) :
    ω∈G.axisExit u v A L W D true∪G.axisExit u v A L W D false := by
  obtain ⟨a,ha,hi⟩ := hi
  obtain ⟨b,⟨w⟩,hb⟩ := G.infinite_strip_unbounded u v W L ω a (hA a ha).2 hi (hbox a ha)
  apply G.axisExit_of_crossing u v A L W D hD hu ha (hA a ha).1
    (w.mapLe (G.openGraph_mono Set.inter_subset_left)) hb.le
  intro x hx
  rw [SimpleGraph.Walk.support_mapLe_eq_support] at hx
  exact G.cluster_induced_subset ω _ (hA a ha).2 (w.takeUntil x hx).reachable

def stripPercolates (v : V → ℝ) (W : ℝ) : Set (Set E) :=
  {ω | ω∩G.inducedEdges {x | |v x|≤W}∈G.percolates}

def someStripPercolates (v : V → ℝ) : Set (Set E) :=
  ⋃ n : ℕ, G.stripPercolates v n

lemma stripPercolates_measurable [Countable V] [Countable E] (v : V → ℝ) (W : ℝ) :
    MeasurableSet (G.stripPercolates v W) := by
  exact G.measurableSet_percolates.preimage ((BernoulliProduct.measurable_inter_block _).mono (BernoulliProduct.blockSigma_le _) le_rfl)

lemma someStripPercolates_measurable [Countable V] [Countable E] (v : V → ℝ) :
    MeasurableSet (G.someStripPercolates v) :=
  MeasurableSet.iUnion (fun n => G.stripPercolates_measurable v n)

lemma stripPercolates_diff_iff (v : V → ℝ) (W : ℝ) (ω S : Set E) (hS : S.Finite) :
    ω\S∈G.stripPercolates v W ↔ ω∈G.stripPercolates v W := by
  change (ω\S)∩G.inducedEdges {x | |v x|≤W}∈G.percolates ↔ _
  have heq : (ω\S)∩G.inducedEdges {x | |v x|≤W}=
      (ω∩G.inducedEdges {x | |v x|≤W})\S := by ext e; simp only [Set.mem_inter_iff,Set.mem_sdiff]; tauto
  rw [heq]
  exact G.percolates_diff_finite_iff _ S hS

lemma someStripPercolates_zero_one [Countable V] [Countable E]
    (v : V → ℝ) (q : E → unitInterval) :
    BernoulliProduct.law q (G.someStripPercolates v)=0 ∨
      BernoulliProduct.law q (G.someStripPercolates v)=1 := by
  apply BernoulliProduct.zero_one_of_finite_erasure_invariant q _ (G.someStripPercolates_measurable v)
  intro S hS ω
  have heq : BernoulliProduct.forceOn S ∅ ω=ω\S := by
    ext e
    change (if e∈S then False else e∈ω) ↔ e∈ω ∧ e∉S
    split_ifs <;> tauto
  rw [heq]
  simp only [someStripPercolates,Set.mem_iUnion]
  exact exists_congr (fun n => G.stripPercolates_diff_iff v n ω S hS)

def seedStripInfinite (v : V → ℝ) (A : Set V) (W : ℝ) : Set (Set E) :=
  {ω | ∃ a∈A, (G.cluster (ω∩G.inducedEdges {x | |v x|≤W}) a).Infinite}

lemma seedStripInfinite_measurable [Countable V] [Countable E]
    (v : V → ℝ) (A : Set V) (W : ℝ) : MeasurableSet (G.seedStripInfinite v A W) := by
  have hm : Measurable (fun ω : Set E => ω∩G.inducedEdges {x | |v x|≤W}) :=
    (BernoulliProduct.measurable_inter_block _).mono (BernoulliProduct.blockSigma_le _) le_rfl
  have heq : G.seedStripInfinite v A W=⋃ a∈A,
      (fun ω : Set E => ω∩G.inducedEdges {x | |v x|≤W}) ⁻¹' G.infiniteEvent a := by
    ext ω
    simp only [seedStripInfinite,infiniteEvent,Set.mem_ofPred_eq,Set.mem_iUnion,
      Set.mem_preimage,exists_prop]
  rw [heq]
  exact MeasurableSet.biUnion (Set.to_countable _) fun a _ =>
    (G.measurableSet_infiniteEvent a).preimage hm

lemma seedStripInfinite_mono (v : V → ℝ) {A B : Set V} (hAB : A⊆B)
    {W U : ℝ} (hWU : W≤U) : G.seedStripInfinite v A W⊆G.seedStripInfinite v B U := by
  rintro ω ⟨a,ha,hi⟩
  exact ⟨a,hAB ha,hi.mono (G.cluster_mono
    (Set.inter_subset_inter_right _ (G.inducedEdges_mono (fun _ hx => hx.trans hWU))) a)⟩

lemma seedStripInfinite_exhaustion (hc : G.fullGraph.Connected) (v : V → ℝ) (o : V) :
    (⋃ n : ℕ, G.seedStripInfinite v (G.vertexBall o n) n)=G.someStripPercolates v := by
  ext ω
  constructor
  · intro h
    obtain ⟨n,a,_ha,hi⟩ := Set.mem_iUnion.mp h
    exact Set.mem_iUnion.mpr ⟨n,a,hi⟩
  · intro h
    obtain ⟨n,a,hi⟩ := Set.mem_iUnion.mp h
    obtain ⟨r,hr⟩ := G.reachable_mem_vertexBall (hc o a)
    refine Set.mem_iUnion.mpr ⟨max n r,?_⟩
    exact G.seedStripInfinite_mono v (G.vertexBall_mono o (le_max_right n r))
      (by exact_mod_cast le_max_left n r) ⟨a,hr,hi⟩

theorem exists_seed_strip_probability [Countable V] [Countable E]
    (hc : G.fullGraph.Connected) (hl : G.LocallyFinite)
    (v : V → ℝ) (o : V) (q : E → unitInterval)
    (hpos : 0<BernoulliProduct.law q (G.someStripPercolates v))
    (eps : ℝ) (heps : 0<eps) :
    ∃ m : ℕ, ∃ W : ℝ, 0≤W ∧
      (∀ a∈G.vertexBall o m, |v a|≤W) ∧
      1-eps<(BernoulliProduct.law q).real (G.seedStripInfinite v (G.vertexBall o m) W) := by
  have hone := (G.someStripPercolates_zero_one v q).resolve_left (ne_of_gt hpos)
  let A := fun n : ℕ => G.seedStripInfinite v (G.vertexBall o n) n
  have hmono : Monotone A := fun n r hn => G.seedStripInfinite_mono v
    (G.vertexBall_mono o hn) (Nat.cast_le.mpr hn)
  have ht := tendsto_measure_iUnion_atTop (μ := BernoulliProduct.law q) hmono
  have heq : (⋃ n, A n)=G.someStripPercolates v := G.seedStripInfinite_exhaustion hc v o
  rw [heq,hone] at ht
  have hreal := (ENNReal.tendsto_toReal (by simp : (1 : ℝ≥0∞)≠⊤)).comp ht
  have hnear : ∀ᶠ n in atTop, 1-eps<(BernoulliProduct.law q).real (A n) :=
    hreal.eventually (lt_mem_nhds (by simpa using heps : 1-eps<ENNReal.toReal 1))
  obtain ⟨m,hm⟩ := hnear.exists
  obtain ⟨M,hM⟩ := ((G.vertexBall_finite hl o m).image (fun a => |v a|)).bddAbove
  refine ⟨m,max (m : ℝ) M,?_,?_,?_⟩
  · exact (Nat.cast_nonneg m).trans (le_max_left _ _)
  · intro a ha
    exact (hM (Set.mem_image_of_mem _ ha)).trans (le_max_right _ _)
  · apply hm.trans_le
    apply ENNReal.toReal_mono (measure_ne_top _ _)
    exact measure_mono (G.seedStripInfinite_mono v (Set.Subset.refl _) (le_max_left _ _))

end CriticalPercolation.BondGraph
end
end
end

end OAI