import OAI.Dynamics.ConditionalShuffle.CycleEnergy

namespace OAI

noncomputable section
open scoped Classical
namespace Thorp.Conditional.Hybrid

def publicHistory {d t : ℕ} (s : Fin t → Bool) (ω : History d t) : Fin t → Option (Coins d) :=
  fun i => if s i then none else some (ω i)

def raw (d : ℕ) (v : RawState (d+1)) :
    (t : ℕ) → (Fin t → Bool) → History (d+1) t → RawState (d+1)
  | 0, _, _ => v
  | t+1, s, ω =>
      let u := raw d v t (Fin.init s) (Fin.init ω)
      if s (Fin.last t) then rawNext d u (ω (Fin.last t))
      else rawPermute u (step (d+1) (ω (Fin.last t)))

lemma publicHistory_snoc {d t : ℕ} (s : Fin t → Bool) (b : Bool)
    (ω : History d t) (c : Coins d) :
    publicHistory (Fin.snoc s b) (Fin.snoc ω c) =
      Fin.snoc (publicHistory s ω) (if b then none else some c) := by
  funext i
  refine Fin.lastCases ?_ (fun j => ?_) i <;> simp [publicHistory]

lemma raw_snoc (d : ℕ) (v : RawState (d+1)) (t : ℕ) (s : Fin t → Bool) (b : Bool)
    (ω : History (d+1) t) (c : Coins (d+1)) :
    raw d v (t+1) (Fin.snoc s b) (Fin.snoc ω c) =
      if b then rawNext d (raw d v t s ω) c else rawPermute (raw d v t s ω) (step (d+1) c) := by
  simp only [raw, Fin.init_snoc, Fin.snoc_last]

lemma raw_free (d : ℕ) (v : RawState (d+1)) (t : ℕ) (s : Fin t → Bool)
    (ω : History (d+1) t) (y) :
    (raw d v t s ω).free y = v.free ((run (d+1) t ω).symm y) := by
  induction t generalizing y with
  | zero => rfl
  | succ t ih =>
      rw [raw]; split_ifs
      · change (raw d v t (Fin.init s) (Fin.init ω)).free
          ((step (d+1) (ω (Fin.last t))).symm y) = _
        rw [ih, run_succ]
        rfl
      · change (raw d v t (Fin.init s) (Fin.init ω)).free
          ((step (d+1) (ω (Fin.last t))).symm y) = _
        rw [ih, run_succ]
        rfl

lemma raw_energy_le (d : ℕ) (v : RawState (d+1)) (t : ℕ) (s : Fin t → Bool)
    (ω : History (d+1) t) : rawEnergy (raw d v t s ω) ≤ rawEnergy v := by
  induction t with
  | zero => exact le_rfl
  | succ t ih =>
      rw [raw]; split_ifs
      · exact (physicalFlow_energy_le d _ _ _).trans (ih _ _)
      · rw [rawPermute_energy]; exact ih _ _

lemma permute_test {d : ℕ} (v : RawState d) (g : State d) (f : Position d → ℝ) :
    (∑ y, (rawPermute v g).weight y * f y) = ∑ x, v.weight x * f (g x) := by
  change (∑ y, v.weight (g.symm y) * f y) = _
  have h := Equiv.sum_comp g (fun y => v.weight (g.symm y) * f y)
  simpa only [Equiv.symm_apply_apply] using h.symm

theorem flow_joint {ι : Type*} (d : ℕ) (v : RawState (d+1))
    (e : ι → Position (d+1)) (he : ∀ i, v.free (e i) = false)
    (t : ℕ) (s : Fin t → Bool)
    (f : (Fin t → Option (Coins (d+1))) → (Fin (t+1) → ι → Position (d+1)) → Position (d+1) → ℝ) :
    mean (fun ω : History (d+1) t => ∑ x, v.weight x *
      f (publicHistory s ω) (exposedPath (d+1) e t ω) (run (d+1) t ω x)) =
    mean (fun ω : History (d+1) t => ∑ y, (raw d v t s ω).weight y *
      f (publicHistory s ω) (exposedPath (d+1) e t ω) y) := by
  induction t with
  | zero => simp only [run_zero, raw]; rfl
  | succ t ih =>
      let b := s (Fin.last t)
      let s₀ := Fin.init s
      have hs : s = Fin.snoc s₀ b := (Fin.snoc_init_self s).symm
      rw [hs]
      let F (q : Fin t → Option (Coins (d+1))) (p : Fin (t+1) → ι → Position (d+1)) (x : Position (d+1)) :=
        mean (fun c : Coins (d+1) => f (Fin.snoc q (if b then none else some c))
          (Fin.snoc p (step (d+1) c ∘ p (Fin.last t))) (step (d+1) c x))
      have hl : mean (fun ω : History (d+1) (t+1) => ∑ x, v.weight x *
          f (publicHistory (Fin.snoc s₀ b) ω) (exposedPath (d+1) e (t+1) ω) (run (d+1) (t+1) ω x)) =
          mean (fun ω : History (d+1) t => ∑ x, v.weight x *
            F (publicHistory s₀ ω) (exposedPath (d+1) e t ω) (run (d+1) t ω x)) := by
        rw [mean_history_succ]
        apply mean_congr; intro ω
        simp only [publicHistory_snoc, exposedPath_snoc, run_snoc]
        rw [mean_sum]
        simp_rw [mean_const_mul]
        simp only [F, exposedPath_last]
        rfl
      have hr : mean (fun ω : History (d+1) (t+1) => ∑ y,
          (raw d v (t+1) (Fin.snoc s₀ b) ω).weight y *
          f (publicHistory (Fin.snoc s₀ b) ω) (exposedPath (d+1) e (t+1) ω) y) =
          mean (fun ω : History (d+1) t => ∑ y, (raw d v t s₀ ω).weight y *
            F (publicHistory s₀ ω) (exposedPath (d+1) e t ω) y) := by
        rw [mean_history_succ]
        apply mean_congr; intro ω
        simp only [raw_snoc, publicHistory_snoc, exposedPath_snoc]
        cases hb : b
        · simp only [Bool.false_eq_true, ite_false]
          simp_rw [permute_test]
          rw [mean_sum]
          simp_rw [mean_const_mul]
          simp only [F, hb, Bool.false_eq_true, ite_false, exposedPath_last]
          rfl
        · simp only [ite_true]
          change mean (fun c : Position d → Bool => ∑ y,
            physicalFlow d (raw d v t s₀ ω).free (raw d v t s₀ ω).weight c y *
            f (Fin.snoc (publicHistory s₀ ω) none)
              (Fin.snoc (exposedPath (d+1) e t ω) ((step (d+1) c) ∘ ((run (d+1) t ω) ∘ e))) y) = _
          rw [physicalFlow_joint d (raw d v t s₀ ω).free (raw d v t s₀ ω).weight
            ((run (d+1) t ω) ∘ e) (by
              intro i
              simp only [Function.comp_apply, raw_free, Equiv.symm_apply_apply]
              exact he i)
            (fun e' y => f (Fin.snoc (publicHistory s₀ ω) none)
              (Fin.snoc (exposedPath (d+1) e t ω) e') y)]
          rw [mean_sum]
          simp_rw [mean_const_mul]
          simp only [F, hb, ite_true, exposedPath_last]
          rfl
      exact hl.trans ((ih s₀ F).trans hr.symm)

end Thorp.Conditional.Hybrid

end

end OAI