import OAI.Dynamics.TriangleBilliards.CollisionEscape

namespace OAI

universe uAlpha

open MeasureTheory Set
open scoped ENNReal symmDiff
noncomputable section
namespace TriangularBilliards
open Filter
open scoped Topology

/-! Borel realization of full chains.  Countable collision data, rather than
an uncountable trajectory selector, permit a standard-Borel inverse. -/
namespace Triangle

lemma side_coords_nonneg (Q : Triangle) {x : ℂ} {i : Fin 3}
    (hx : x ∈ Q.side i) (k : Fin 3) : 0 ≤ Q.basis.coord k x := by
  rw [side, openSegment_eq_image_lineMap] at hx
  obtain ⟨t, ht, rfl⟩ := hx
  change 0 ≤ Q.basis.coord k (AffineMap.lineMap (Q.basis i) (Q.basis (i + 1)) t)
  rw [AffineMap.apply_lineMap, Q.basis.coord_apply, Q.basis.coord_apply,
    AffineMap.lineMap_apply_module]
  split_ifs <;> simp only [smul_eq_mul] <;> nlinarith [ht.1, ht.2]

lemma measurableSet_side (Q : Triangle) (i : Fin 3) : MeasurableSet (Q.side i) := by
  rw [side, openSegment_eq_image_lineMap]
  have hne : Q.vertex i ≠ Q.vertex (i + 1) :=
    Q.nondegenerate.injective.ne (by decide +revert)
  have hc : Continuous (fun t : ℝ => AffineMap.lineMap (Q.vertex i) (Q.vertex (i + 1)) t) := by
    fun_prop
  exact (hc.measurableEmbedding (AffineMap.lineMap_injective ℝ hne)).measurableSet_image.mpr
    measurableSet_Ioo

lemma inside_of_midpoint (Q : Triangle) {x v : ℂ} {a b : ℝ} {i j : Fin 3}
    (ha : x ∈ Q.side i) (hb : x + (b - a) • v ∈ Q.side j)
    (hm : x + ((a + b) / 2 - a) • v ∈ Q.table)
    {t : ℝ} (hat : a < t) (htb : t < b) : x + (t - a) • v ∈ Q.table := by
  rw [Q.table_iff_coords] at hm ⊢
  intro k
  have h0 := Q.side_coords_nonneg ha k
  have h1 := Q.side_coords_nonneg hb k
  have hmid := hm k
  rw [Q.coord_shift] at h1 hmid ⊢
  by_cases hd : 0 ≤ Q.slope k v
  · by_cases hz : Q.slope k v = 0
    · simp only [hz, mul_zero, add_zero] at hmid ⊢
      exact hmid
    · exact add_pos_of_nonneg_of_pos h0 (mul_pos (sub_pos.mpr hat) (lt_of_le_of_ne hd (Ne.symm hz)))
  · have hp : 0 < (b - t) * (-Q.slope k v) :=
      mul_pos (sub_pos.mpr htb) (neg_pos.mpr (lt_of_not_ge hd))
    nlinarith

end Triangle

abbrev ChainData := (ℤ → ℝ) × (ℤ → ℂ) × (ℤ → Circle) × (ℤ → Fin 3)

namespace ChainData

def time (c : ChainData) := c.1
def point (c : ChainData) := c.2.1
def direction (c : ChainData) := c.2.2.1
def wall (c : ChainData) := c.2.2.2

/-- Every predicate is a countable combination of Borel coordinate predicates.
Midpoint membership entails the entire open-flight condition by convexity. -/
def Valid (Q : Triangle) (z : Phase) (c : ChainData) : Prop :=
  (∀ n : ℤ, c.time n < c.time (n + 1)) ∧
  (∀ k : ℤ, ∃ n : ℤ, c.time n < k) ∧
  (∀ k : ℤ, ∃ n : ℤ, (k : ℝ) < c.time n) ∧
  c.time 0 < 0 ∧ 0 < c.time 1 ∧
  (∀ n : ℤ, c.point n ∈ Q.side (c.wall n)) ∧
  (∀ n : ℤ, c.point (n + 1) = c.point n +
    (c.time (n + 1) - c.time n) • (c.direction n : ℂ)) ∧
  (∀ n : ℤ, c.point n + ((c.time n + c.time (n + 1)) / 2 - c.time n) •
    (c.direction n : ℂ) ∈ Q.table) ∧
  z.1 = c.point 0 + (-c.time 0) • (c.direction 0 : ℂ) ∧
  z.2 = c.direction 0 ∧
  (∀ n : ℤ, (c.direction n : ℂ) = reflect (Q.tangent (c.wall n))
    (c.direction (n - 1) : ℂ))

def toChain {Q : Triangle} {z : Phase} {c : ChainData} (h : c.Valid Q z) : FlightChain Q z where
  time := c.time
  point := c.point
  direction := c.direction
  wall := c.wall
  increasing := strictMono_int_of_lt_succ h.1
  unbounded_below := fun t => by
    obtain ⟨k, hk⟩ := exists_int_lt t
    obtain ⟨n, hn⟩ := h.2.1 k
    exact ⟨n, hn.trans hk⟩
  unbounded_above := fun t => by
    obtain ⟨k, hk⟩ := exists_int_gt t
    obtain ⟨n, hn⟩ := h.2.2.1 k
    exact ⟨n, hk.trans hn⟩
  zero_before := h.2.2.2.1
  zero_after := h.2.2.2.2.1
  on_side := h.2.2.2.2.2.1
  flight := h.2.2.2.2.2.2.1
  inside := fun n t ht ht' => by
    apply Q.inside_of_midpoint (j := c.wall (n + 1))
      (h.2.2.2.2.2.1 n) _ (h.2.2.2.2.2.2.2.1 n) ht ht'
    rw [← h.2.2.2.2.2.2.1 n]
    exact h.2.2.2.2.2.1 (n + 1)
  start_point := h.2.2.2.2.2.2.2.2.1
  start_direction := h.2.2.2.2.2.2.2.2.2.1
  specular := h.2.2.2.2.2.2.2.2.2.2

end ChainData

namespace FlightChain

def data {Q : Triangle} {z : Phase} (c : FlightChain Q z) : ChainData :=
  (c.time, c.point, c.direction, c.wall)

lemma data_valid {Q : Triangle} {z : Phase} (c : FlightChain Q z) : c.data.Valid Q z := by
  refine ⟨fun n => c.increasing (by omega), fun k => c.unbounded_below k,
    fun k => c.unbounded_above k, c.zero_before, c.zero_after, c.on_side,
    c.flight, ?_, c.start_point, c.start_direction, c.specular⟩
  intro n
  have h := c.increasing (show n < n + 1 by omega)
  exact c.inside n ((c.time n + c.time (n + 1)) / 2) (by linarith) (by linarith)

end FlightChain

namespace ChainData

@[fun_prop] lemma continuous_time (n : ℤ) : Continuous (fun c : ChainData => c.time n) := by
  unfold time
  fun_prop

@[fun_prop] lemma continuous_point (n : ℤ) : Continuous (fun c : ChainData => c.point n) := by
  unfold point
  fun_prop

@[fun_prop] lemma continuous_direction (n : ℤ) : Continuous (fun c : ChainData => c.direction n) := by
  unfold direction
  fun_prop

@[fun_prop] lemma continuous_wall (n : ℤ) : Continuous (fun c : ChainData => c.wall n) := by
  unfold wall
  fun_prop

lemma measurableSet_side_mem {α : Type uAlpha} [MeasurableSpace α] (Q : Triangle)
    {p : α → ℂ} {w : α → Fin 3} (hp : Measurable p) (hw : Measurable w) :
    MeasurableSet {a | p a ∈ Q.side (w a)} := by
  have he : {a | p a ∈ Q.side (w a)} =
      ⋃ i : Fin 3, {a | w a = i} ∩ p ⁻¹' Q.side i := by
    ext a
    simp only [mem_ofPred_eq, mem_iUnion, mem_inter_iff, mem_preimage]
    exact ⟨fun h => ⟨w a, rfl, h⟩, fun ⟨i, hi, hs⟩ => hi ▸ hs⟩
  rw [he]
  exact MeasurableSet.iUnion fun i =>
    (measurableSet_eq_fun hw measurable_const).inter ((Q.measurableSet_side i).preimage hp)

lemma measurableSet_valid (Q : Triangle) :
    MeasurableSet {a : Phase × ChainData | a.2.Valid Q a.1} := by
  have ht (n : ℤ) : Measurable (fun a : Phase × ChainData => a.2.time n) :=
    (continuous_time n).measurable.comp measurable_snd
  have hp (n : ℤ) : Measurable (fun a : Phase × ChainData => a.2.point n) :=
    (continuous_point n).measurable.comp measurable_snd
  have hd (n : ℤ) : Measurable (fun a : Phase × ChainData => a.2.direction n) :=
    (continuous_direction n).measurable.comp measurable_snd
  have hv (n : ℤ) : Measurable (fun a : Phase × ChainData => (a.2.direction n : ℂ)) := by
    exact (show Continuous (fun z : Circle => (z : ℂ)) by fun_prop).measurable.comp (hd n)
  have hw (n : ℤ) : Measurable (fun a : Phase × ChainData => a.2.wall n) :=
    (continuous_wall n).measurable.comp measurable_snd
  simp only [Valid, ofPred_and, ofPred_forall, ofPred_exists]
  refine (MeasurableSet.iInter fun n => measurableSet_lt (ht n) (ht (n + 1))).inter ?_
  refine (MeasurableSet.iInter fun k : ℤ => MeasurableSet.iUnion fun n =>
    measurableSet_lt (ht n) measurable_const).inter ?_
  refine (MeasurableSet.iInter fun k : ℤ => MeasurableSet.iUnion fun n =>
    measurableSet_lt measurable_const (ht n)).inter ?_
  refine (measurableSet_lt (ht 0) measurable_const).inter ?_
  refine (measurableSet_lt measurable_const (ht 1)).inter ?_
  refine (MeasurableSet.iInter fun n => measurableSet_side_mem Q (hp n) (hw n)).inter ?_
  refine (MeasurableSet.iInter fun n => measurableSet_eq_fun (hp (n + 1))
    ((hp n).add (((ht (n + 1)).sub (ht n)).smul (hv n)))).inter ?_
  refine (MeasurableSet.iInter fun n => Q.measurableSet_table.preimage
    ((hp n).add (((((ht n).add (ht (n + 1))).div_const 2).sub (ht n)).smul (hv n)))).inter ?_
  refine (measurableSet_eq_fun (measurable_fst.comp measurable_fst)
    ((hp 0).add ((ht 0).neg.smul (hv 0)))).inter ?_
  refine (measurableSet_eq_fun (measurable_snd.comp measurable_fst) (hd 0)).inter ?_
  apply MeasurableSet.iInter
  intro n
  have he : Measurable (fun a : Phase × ChainData => Q.tangent (a.2.wall n)) :=
    (measurable_of_countable Q.tangent).comp (hw n)
  exact measurableSet_eq_fun (hv n) ((he.div (Complex.continuous_conj.measurable.comp he)).mul
    (Complex.continuous_conj.measurable.comp (hv (n - 1))))

end ChainData

/-- Standard-Borel coding of the exact complete trajectories. -/
abbrev CodedChain (Q : Triangle) := {a : Phase × ChainData // a.2.Valid Q a.1}

namespace CodedChain

instance standardBorel (Q : Triangle) : StandardBorelSpace (CodedChain Q) :=
  (ChainData.measurableSet_valid Q).standardBorel

def initial {Q : Triangle} (c : CodedChain Q) : Phase := c.val.1

def chain {Q : Triangle} (c : CodedChain Q) : FlightChain Q c.initial := ChainData.toChain c.property

instance nonempty (Q : Triangle) : Nonempty (CodedChain Q) := by
  obtain ⟨z, ⟨c⟩⟩ := (ae_exists_chain Q).exists
  exact ⟨⟨(z, c.data), c.data_valid⟩⟩

lemma initial_injective (Q : Triangle) : Function.Injective (initial (Q := Q)) := by
  rintro ⟨⟨z, c⟩, hc⟩ ⟨⟨w, d⟩, hd⟩ h
  change z = w at h
  subst w
  have he := congrArg FlightChain.data (FlightChain.unique (ChainData.toChain hc) (ChainData.toChain hd))
  apply Subtype.ext
  change c = d at he
  exact congrArg (fun x : ChainData => (z, x)) he

lemma initial_embedding (Q : Triangle) : MeasurableEmbedding (initial (Q := Q)) :=
  (measurable_fst.comp measurable_subtype_coe).measurableEmbedding (initial_injective Q)

lemma range_initial (Q : Triangle) :
    range (initial (Q := Q)) = {z | Nonempty (FlightChain Q z)} := by
  ext z
  constructor
  · rintro ⟨c, rfl⟩
    exact ⟨c.chain⟩
  · rintro ⟨c⟩
    exact ⟨⟨(z, c.data), c.data_valid⟩, rfl⟩

lemma measurableSet_regular (Q : Triangle) : MeasurableSet {z | Nonempty (FlightChain Q z)} := by
  rw [← range_initial]
  exact (initial_embedding Q).measurableSet_range

/-- The inverse is Borel by Lusin--Souslin, not by choice of arbitrary
unmeasurable representatives. It agrees with every exact chain at its initial state. -/
def fromPhase (Q : Triangle) : Phase → CodedChain Q := (initial_embedding Q).invFun

@[fun_prop] lemma measurable_fromPhase (Q : Triangle) : Measurable (fromPhase Q) :=
  (initial_embedding Q).measurable_invFun

lemma fromPhase_initial (Q : Triangle) (c : CodedChain Q) : fromPhase Q c.initial = c :=
  (initial_embedding Q).leftInverse_invFun c

def index {Q : Triangle} (a : CodedChain Q × ℝ) : ℤ :=
  Classical.choose (a.1.chain.exists_flight a.2)

lemma index_spec {Q : Triangle} (a : CodedChain Q × ℝ) :
    a.1.chain.time (index a) ≤ a.2 ∧ a.2 < a.1.chain.time (index a + 1) :=
  Classical.choose_spec (a.1.chain.exists_flight a.2)

lemma index_eq_iff {Q : Triangle} (a : CodedChain Q × ℝ) (n : ℤ) :
    index a = n ↔ a.1.chain.time n ≤ a.2 ∧ a.2 < a.1.chain.time (n + 1) := by
  constructor
  · rintro rfl
    exact index_spec a
  · intro h
    exact a.1.chain.flight_index_unique (index_spec a) h

@[fun_prop] lemma measurable_time (Q : Triangle) (n : ℤ) :
    Measurable (fun c : CodedChain Q => c.chain.time n) :=
  (ChainData.continuous_time n).measurable.comp (measurable_snd.comp measurable_subtype_coe)

@[fun_prop] lemma measurable_point (Q : Triangle) (n : ℤ) :
    Measurable (fun c : CodedChain Q => c.chain.point n) :=
  (ChainData.continuous_point n).measurable.comp (measurable_snd.comp measurable_subtype_coe)

@[fun_prop] lemma measurable_direction (Q : Triangle) (n : ℤ) :
    Measurable (fun c : CodedChain Q => c.chain.direction n) :=
  (ChainData.continuous_direction n).measurable.comp (measurable_snd.comp measurable_subtype_coe)

@[fun_prop] lemma measurable_index (Q : Triangle) : Measurable (index (Q := Q)) := by
  apply measurable_to_countable
  intro a
  have he : index ⁻¹' {index a} =
      {b : CodedChain Q × ℝ | b.1.chain.time (index a) ≤ b.2} ∩
      {b : CodedChain Q × ℝ | b.2 < b.1.chain.time (index a + 1)} := by
    ext b
    exact index_eq_iff b (index a)
  rw [he]
  exact (measurableSet_le ((measurable_time Q _).comp measurable_fst) measurable_snd).inter
    (measurableSet_lt measurable_snd ((measurable_time Q _).comp measurable_fst))

@[fun_prop] lemma measurable_at (Q : Triangle) :
    Measurable (fun a : CodedChain Q × ℝ => a.1.chain.at a.2) := by
  have hf (n : ℤ) : Measurable (fun a : CodedChain Q × ℝ =>
      (a.1.chain.point n + (a.2 - a.1.chain.time n) • (a.1.chain.direction n : ℂ),
        a.1.chain.direction n)) := by
    have hv : Measurable (fun a : CodedChain Q × ℝ => (a.1.chain.direction n : ℂ)) :=
      (show Continuous (fun v : Circle => (v : ℂ)) by fun_prop).measurable.comp
        ((measurable_direction Q n).comp measurable_fst)
    exact (((measurable_point Q n).comp measurable_fst).add
      ((measurable_snd.sub ((measurable_time Q n).comp measurable_fst)).smul hv)).prodMk
        ((measurable_direction Q n).comp measurable_fst)
  have heval : Measurable (fun b : (CodedChain Q × ℝ) × ℤ =>
      (b.1.1.chain.point b.2 + (b.1.2 - b.1.1.chain.time b.2) •
        (b.1.1.chain.direction b.2 : ℂ), b.1.1.chain.direction b.2)) :=
    measurable_from_prod_countable_left hf
  convert heval.comp (measurable_id.prodMk (measurable_index Q)) using 1
  funext a
  exact a.1.chain.at_of_flight (index_spec a)

lemma fromPhase_at {Q : Triangle} {z : Phase} (c : FlightChain Q z) (t : ℝ) :
    (fromPhase Q z).chain.at t = c.at t := by
  let d : CodedChain Q := ⟨(z, c.data), c.data_valid⟩
  have hd : fromPhase Q z = d := fromPhase_initial Q d
  rw [hd]
  have hc : d.chain = c := FlightChain.unique _ _
  exact congrArg (fun e : FlightChain Q z => e.at t) hc

end CodedChain

/-- Joint Borel measurability of the actual chosen billiard flow, obtained
from the unique exact chain, including the singular-set identity convention. -/
lemma measurable_billiardFlow (Q : Triangle) :
    Measurable (fun a : ℝ × Phase => billiardFlow Q a.1 a.2) := by
  classical
  have hm : Measurable (fun a : ℝ × Phase =>
      (CodedChain.fromPhase Q a.2).chain.at a.1) :=
    (CodedChain.measurable_at Q).comp
      (((CodedChain.measurable_fromPhase Q).comp measurable_snd).prodMk measurable_fst)
  have hr : MeasurableSet {a : ℝ × Phase | Nonempty (FlightChain Q a.2)} :=
    (CodedChain.measurableSet_regular Q).preimage measurable_snd
  have he : (fun a : ℝ × Phase => billiardFlow Q a.1 a.2) =
      (fun a : ℝ × Phase => if Nonempty (FlightChain Q a.2) then
        (CodedChain.fromPhase Q a.2).chain.at a.1 else a.2) := by
    funext ⟨t, z⟩
    change billiardFlow Q t z = if Nonempty (FlightChain Q z) then
      (CodedChain.fromPhase Q z).chain.at t else z
    by_cases h : Nonempty (FlightChain Q z)
    · simp only [ite_eq_left h]
      rw [billiardFlow_eq_chain (Classical.choice h), CodedChain.fromPhase_at]
    · simp only [billiardFlow, dite_eq_right h, ite_eq_right h]
  rw [he]
  exact Measurable.ite hr hm measurable_snd

lemma measurable_billiardFlow_time (Q : Triangle) (t : ℝ) : Measurable (billiardFlow Q t) :=
  (measurable_billiardFlow Q).comp (measurable_const.prodMk measurable_id)

end TriangularBilliards

end

end OAI