import OAI.Probability.LatticePassage.Stationarity
import OAI.Probability.LatticePassage.LocalPassage

namespace OAI

namespace CompanionFPP
open MeasureTheory

noncomputable instance encodable_lattice_walk (x y : Vertex) : Encodable (lattice.Walk x y) :=
  Encodable.ofCountable _

noncomputable def enumerateWalk (x y : Vertex) (n : ℕ) : lattice.Walk x y :=
  (Encodable.decode (α := lattice.Walk x y) n).getD (Classical.choice (lattice_walk x y))

lemma enumerateWalk_surjective (x y : Vertex) : Function.Surjective (enumerateWalk x y) := by
  intro p
  exact ⟨Encodable.encode p, by simp [enumerateWalk]⟩

def minimizesLocally (x y : Vertex) (R n : ℕ) (ω : Environment) : Prop :=
  (enumerateWalk x y n).IsPath ∧ (enumerateWalk x y n).length < R ∧
    pathCost ω (enumerateWalk x y n) = localPassageTime ω x y R

lemma exists_minimizesLocally (x y : Vertex) (R : ℕ) (hR : latticeDistance x y < R)
    (ω : Environment) : ∃ n, minimizesLocally x y R n ω := by
  obtain ⟨p,hp,hl,hm⟩ := local_geodesic_exists ω x y R hR
  obtain ⟨n,rfl⟩ := enumerateWalk_surjective x y p
  exact ⟨n,hp,hl,hm⟩

lemma measurableSet_minimizesLocally (x y : Vertex) (R n : ℕ) :
    MeasurableSet {ω : Environment | minimizesLocally x y R n ω} := by
  unfold minimizesLocally
  by_cases hp : (enumerateWalk x y n).IsPath
  · by_cases hl : (enumerateWalk x y n).length < R
    · simpa [hp,hl] using measurableSet_eq_fun (measurable_pathCost (enumerateWalk x y n))
        (measurable_localPassageTime x y R)
    · simp [hl]
  · simp [hp]

noncomputable def localSelectionIndex (x y : Vertex) (R : ℕ)
    (hR : latticeDistance x y < R) (ω : Environment) : ℕ := by
  classical
  exact Nat.find (exists_minimizesLocally x y R hR ω)

@[fun_prop] theorem measurable_localSelectionIndex (x y : Vertex) (R : ℕ)
    (hR : latticeDistance x y < R) : Measurable (localSelectionIndex x y R hR) := by
  classical
  exact measurable_find _ (measurableSet_minimizesLocally x y R)

noncomputable def selectedLocalPath (x y : Vertex) (R : ℕ)
    (hR : latticeDistance x y < R) (ω : Environment) : lattice.Walk x y :=
  enumerateWalk x y (localSelectionIndex x y R hR ω)

theorem selectedLocalPath_spec (x y : Vertex) (R : ℕ)
    (hR : latticeDistance x y < R) (ω : Environment) :
    (selectedLocalPath x y R hR ω).IsPath ∧
    (selectedLocalPath x y R hR ω).length < R ∧
    pathCost ω (selectedLocalPath x y R hR ω) = localPassageTime ω x y R := by
  classical
  exact Nat.find_spec (exists_minimizesLocally x y R hR ω)

theorem measurable_selectedLocalPath_observation (x y : Vertex) (R : ℕ)
    (hR : latticeDistance x y < R) (f : lattice.Walk x y → ℝ) :
    Measurable (fun ω => f (selectedLocalPath x y R hR ω)) := by
  exact (measurable_of_countable (f := fun n : ℕ => f (enumerateWalk x y n))).comp
    (measurable_localSelectionIndex x y R hR)

theorem selectedLocalPath_eq_of_agree (x y : Vertex) (R : ℕ)
    (hR : latticeDistance x y < R) (ω ω' : Environment)
    (h : ∀ e ∈ localEdges x R, ω e = ω' e) :
    selectedLocalPath x y R hR ω = selectedLocalPath x y R hR ω' := by
  classical
  have he : ∀ n, minimizesLocally x y R n ω ↔ minimizesLocally x y R n ω' := by
    intro n
    unfold minimizesLocally
    by_cases hp : (enumerateWalk x y n).IsPath
    · by_cases hl : (enumerateWalk x y n).length < R
      · rw [local_pathCost_eq ω ω' h _ hp hl,
          localPassageTime_eq_of_agree ω ω' x y R h]
      · simp [hl]
    · simp [hp]
  unfold selectedLocalPath localSelectionIndex
  congr 1
  exact Nat.find_congr' (fun {n} => he n)

end CompanionFPP

end OAI