import OAI.NumberTheory.Ostmann.Arithmetic.ArithmeticSpectatorNode
import OAI.NumberTheory.Ostmann.Construction.TransferConjugations
import OAI.NumberTheory.Ostmann.Tree.RationalTreeLeaves

namespace OAI

/-! # From reconstructed integer histories to the spectator tree

The realization conditions record the two child products and the terminal
modulus. They allow composite inserted pivots: division by the compensation
unit gives the giant used by the rational tree. No prime law is assigned to
that composite integer.
-/

namespace Ostmann
open scoped Classical ComplexConjugate

noncomputable def spectatorHistoryLeaf {State : Type*} {q : ℕ} [Fact q.Prime]
    (modulus : State → ℕ) (g : ZMod q → ℂ) (D : (ZMod q)ˣ) (σ : State) (s : ℤ) : ℂ :=
  g ((s : ZMod q) / ((D : ZMod q) * (modulus σ : ZMod q)))

noncomputable def spectatorHistoryCutoff {State : Type*} {q : ℕ} [Fact q.Prime]
    (sys : TransferHistorySystem State) (σ : State) (s v w : ℤ) : ℝ :=
  if (historyPivot sys σ s v w : ZMod q) = 0 then 0 else 1

noncomputable def spectatorHistoryWeight {State : Type*} {q : ℕ} [Fact q.Prime]
    (sys : TransferHistorySystem State) (modulus : State → ℕ)
    (g : ZMod q → ℂ) (D : (ZMod q)ˣ) (n : ℕ) (σ : State) (t : FrequencyTree ℤ n) : ℂ :=
  recursiveTransferWeight sys (spectatorHistoryLeaf modulus g D)
    (spectatorHistoryCutoff (q := q) sys) n σ t

def SpectatorHistoryRealizes {State : Type*} {q : ℕ} [Fact q.Prime]
    (sys : TransferHistorySystem State) (modulus : State → ℕ) :
    {n : ℕ} → {C : (ZMod q)ˣ} → RationalTreeData (ZMod q)ˣ n C →
      State → FrequencyTree ℤ n → (ZMod q)ˣ → (ZMod q)ˣ → TreeLeafTuple (ZMod q)ˣ n → Prop
  | _, _, .leaf s C, σ, t, XL, XR, x =>
      ((frequencyRoot (A := ℤ) 0 t : ℤ) : ZMod q) = s ∧
        (modulus σ : ZMod q) = (XL * XR * C * treeLeafProduct 0 x : (ZMod q)ˣ)
  | n + 1, _, .node s CL CR u left right, σ, t, XL, XR, x =>
      let v := frequencyRoot n t.2.1
      let w := frequencyRoot n t.2.2
      let P := historyPivot sys σ t.1 v w
      ValidTransferNode sys σ t.1 v w P ∧
      (t.1 : ZMod q) = s ∧ (v : ZMod q) = left.frequency ∧ (w : ZMod q) = right.frequency ∧
      (sys.leftProduct σ : ZMod q) = (XL * CL * treeLeafProduct n x.1 : (ZMod q)ˣ) ∧
      (sys.rightProduct σ : ZMod q) = (XR * CR * treeLeafProduct n x.2 : (ZMod q)ˣ) ∧
      ∀ h : (P : ZMod q) ≠ 0,
        SpectatorHistoryRealizes sys modulus left (sys.leftState σ P) t.2.1
          (Units.mk0 (P : ZMod q) h / u) XL x.1 ∧
        SpectatorHistoryRealizes sys modulus right (sys.rightState σ P) t.2.2
          (Units.mk0 (P : ZMod q) h / u) XR x.2

theorem spectatorHistoryWeight_eq_tree {State : Type*} {q : ℕ} [Fact q.Prime]
    (sys : TransferHistorySystem State) (modulus : State → ℕ)
    (g : ZMod q → ℂ) (D : (ZMod q)ˣ)
    {n : ℕ} {C : (ZMod q)ˣ} (T : RationalTreeData (ZMod q)ˣ n C)
    (σ : State) (t : FrequencyTree ℤ n) (XL XR : (ZMod q)ˣ)
    (x : TreeLeafTuple (ZMod q)ˣ n)
    (h : SpectatorHistoryRealizes sys modulus T σ t XL XR x) (b : Bool) :
    (if b then conj (spectatorHistoryWeight sys modulus g D n σ t)
      else spectatorHistoryWeight sys modulus g D n σ t) =
      rationalTreeAmplitude g D T XL XR (transferConjugations n b) x := by
  induction T generalizing σ XL XR b with
  | leaf s C =>
    rcases h with ⟨hs, hM⟩
    have ha : ((frequencyRoot (A := ℤ) 0 t : ℤ) : ZMod q) / ((D : ZMod q) * (modulus σ : ZMod q)) =
        (rationalTreeArgument s C D XL XR x : ZMod q) := by
      rw [hs, hM]
      simp only [rationalTreeArgument, Units.val_div_eq_div_val, Units.val_mul]
      apply congrArg (fun z : ZMod q => (s : ZMod q) / z)
      dsimp only [treeLeafProduct]
      ring
    cases b with
    | false => exact congrArg g ha
    | true => exact congrArg star (congrArg g ha)
  | @node n s CL CR u left right ihL ihR =>
    rcases h with ⟨hvalid, hs, hv, hw, hL, hR, hchild⟩
    let P := historyPivot sys σ t.1 (frequencyRoot n t.2.1) (frequencyRoot n t.2.2)
    let V := reconstructedEntry (s : ZMod q) left.frequency right.frequency u
      ((XL * CL * treeLeafProduct n x.1 : (ZMod q)ˣ) : ZMod q)
      ((XR * CR * treeLeafProduct n x.2 : (ZMod q)ˣ) : ZMod q)
    have hs0 : (t.1 : ZMod q) ≠ 0 := by rw [hs]; exact Units.ne_zero s
    have hV : V = (P : ZMod q) / u := by
      dsimp only [V]
      rw [← hs, ← hv, ← hw, ← hL, ← hR]
      exact hvalid.spectator_composite_reconstruction u hs0
    have hW := recursiveTransferWeight_node sys (spectatorHistoryLeaf modulus g D)
      (spectatorHistoryCutoff (q := q) sys) n σ t P hvalid
    change (if b then conj _ else _) = _
    by_cases hp : (P : ZMod q) = 0
    · have hV0 : V = 0 := by rw [hV, hp, zero_div]
      have hweight : spectatorHistoryWeight sys modulus g D (n + 1) σ t = 0 := by
        unfold spectatorHistoryWeight
        rw [hW]
        simp only [spectatorHistoryCutoff, show (historyPivot sys σ t.1
          (frequencyRoot n t.2.1) (frequencyRoot n t.2.2) : ZMod q) = 0 from hp,
          ↓reduceIte, Complex.ofReal_zero, zero_mul]
      simp only [hweight, map_zero, ite_self, rationalTreeAmplitude, transferConjugations]
      change 0 = if hv : V = 0 then 0 else _
      rw [dite_eq_left hV0]
    · have hV0 : V ≠ 0 := by rw [hV]; exact div_ne_zero hp (Units.ne_zero u)
      have hunit : Units.mk0 V hV0 = Units.mk0 (P : ZMod q) hp / u := by
        apply Units.ext
        simpa only [Units.val_mk0, Units.val_div_eq_div_val] using hV
      have hweight : spectatorHistoryWeight sys modulus g D (n + 1) σ t =
          spectatorHistoryWeight sys modulus g D n (sys.leftState σ P) t.2.1 *
            conj (spectatorHistoryWeight sys modulus g D n (sys.rightState σ P) t.2.2) := by
        unfold spectatorHistoryWeight
        rw [hW]
        simp only [spectatorHistoryCutoff, show (historyPivot sys σ t.1
          (frequencyRoot n t.2.1) (frequencyRoot n t.2.2) : ZMod q) ≠ 0 from hp,
          ↓reduceIte, Complex.ofReal_one, one_mul, Complex.star_def]
      have hl := ihL (sys.leftState σ P) t.2.1
        (Units.mk0 (P : ZMod q) hp / u) XL x.1 (hchild hp).1 b
      have hr := ihR (sys.rightState σ P) t.2.2
        (Units.mk0 (P : ZMod q) hp / u) XR x.2 (hchild hp).2 (!b)
      rw [hweight]
      simp only [rationalTreeAmplitude, transferConjugations]
      change _ = if hv : V = 0 then 0 else _
      rw [dite_eq_right hV0, hunit, ← hl, ← hr]
      cases b <;> simp

end Ostmann

end OAI