import OAI.MathematicalPhysics.NavierStokes.VelocityDetection.ExpandingArray
import OAI.MathematicalPhysics.NavierStokes.VelocityDetection.StacksLookup
import OAI.MathematicalPhysics.NavierStokes.VelocityDetection.CenterPathsSignedCenter

namespace OAI

noncomputable section
namespace VelocityDetection.ExpandingArray
open scoped BigOperators Topology ContDiff
open Set Function Filter
open Set Function Filter MeasureTheory
open scoped Topology BigOperators ContDiff
open scoped Topology ContDiff BigOperators
open Expanding Stacks FiniteAddresses

theorem time_in_stage {ν K D t : ℝ} (hν : 0 < ν) (hK : 0 ≤ K) (hD : 1 ≤ D) (ht : 1 ≤ t) :
    ∃ n, t ∈ Icc (startTime ν K D n) (startTime ν K D (n + 1)) := by
  have hex : ∃ n, t < startTime ν K D (n + 1) := by
    obtain ⟨n, hn⟩ := exists_nat_gt t
    refine ⟨n, ?_⟩
    have hs := startTime_ge hν hK hD (n + 1)
    simp only [Nat.cast_add, Nat.cast_one] at hs
    linarith
  let n := Nat.find hex
  refine ⟨n, ?_, (Nat.find_spec hex).le⟩
  cases hn : n with
  | zero => simpa only [hn, startTime] using ht
  | succ k =>
    have hk : ¬t < startTime ν K D (k + 1) := Nat.find_min hex (by omega : k < Nat.find hex)
    simpa only [hn] using not_lt.mp hk

end VelocityDetection.ExpandingArray
end

noncomputable section
namespace VelocityDetection.ExpandingArray
open scoped BigOperators Topology ContDiff
open Set Function Filter
open Set Function Filter MeasureTheory
open scoped Topology BigOperators ContDiff
open scoped Topology ContDiff BigOperators
open Expanding Stacks FiniteAddresses
variable {N b : ℕ} (hb : 0 < b) (table : Fin N → Fin b → Option (Rule (Fin N) b))
    (terminal : Fin N) (ν : ℝ) (m : ℕ) (c₀ : Configuration (Fin N))

def point (n : ℕ) : Coord 2 :=
  let c := orbit hb table c₀ n
  ![spacing ν (K₀ N b m) (D b) n * address (capacity b m n) c.state c.leftStack c.rightStack,
    sign terminal c.state * spacing ν (K₀ N b m) (D b) n]

def runPath (n : ℕ) : ℝ → Coord 2 :=
  let c := orbit hb table c₀ n
  let d := orbit hb table c₀ (n + 1)
  CenterPaths.signedCenter (startTime ν (K₀ N b m) (D b) n)
    (duration ν (K₀ N b m) (D b) n)
    (spacing ν (K₀ N b m) (D b) n) (spacing ν (K₀ N b m) (D b) (n + 1))
    (sign terminal c.state) (sign terminal d.state)
    (address (capacity b m n) c.state c.leftStack c.rightStack)
    (address (capacity b m (n + 1)) d.state d.leftStack d.rightStack)

@[fun_prop] theorem contDiff_runPath (n : ℕ) : ContDiff ℝ ∞ (runPath hb table terminal ν m c₀ n) :=
  CenterPaths.contDiff_signedCenter _ _ _ _ _ _ _ _

theorem runPath_start (n : ℕ) :
    runPath hb table terminal ν m c₀ n (startTime ν (K₀ N b m) (D b) n) =
      point hb table terminal ν m c₀ n := CenterPaths.signed_start _ _ _ _ _ _ _ _

theorem runPath_end (hν : 0 < ν) (n : ℕ) :
    runPath hb table terminal ν m c₀ n (startTime ν (K₀ N b m) (D b) (n + 1)) =
      point hb table terminal ν m c₀ (n + 1) :=
  CenterPaths.signed_end
    (lt_of_lt_of_le zero_lt_one (duration_ge_one hν (K₀_nonneg N b m) (D_ge_one hb) n)) _ _ _ _ _ _ _

theorem runPath_joins (hν : 0 < ν) (n : ℕ) :
    runPath hb table terminal ν m c₀ n (startTime ν (K₀ N b m) (D b) (n + 1)) =
      runPath hb table terminal ν m c₀ (n + 1) (startTime ν (K₀ N b m) (D b) (n + 1)) := by
  rw [runPath_end hb table terminal ν m c₀ hν, runPath_start]

end VelocityDetection.ExpandingArray
end

noncomputable section
namespace VelocityDetection.ExpandingArray
open scoped BigOperators Topology ContDiff
open Set Function Filter
open Set Function Filter MeasureTheory
open scoped Topology BigOperators ContDiff
open scoped Topology ContDiff BigOperators
open Expanding Stacks FiniteAddresses
variable {N b : ℕ} (hb : 0 < b) (table : Fin N → Fin b → Option (Rule (Fin N) b))
    (terminal : Fin N) (ν : ℝ) (m : ℕ) (c₀ : Configuration (Fin N))
variable (hm : 1 ≤ m)
    (hc₀ : c₀.leftStack < capacity b m 0 ∧ c₀.rightStack < capacity b m 0)

def runBox (n : ℕ) : Box N (capacity b m n) :=
  let c := orbit hb table c₀ n
  ⟨c.state, ⟨c.leftStack, (orbit_fits hb table hm c₀ hc₀ n).1⟩,
    ⟨c.rightStack, (orbit_fits hb table hm c₀ hc₀ n).2⟩⟩

@[simp] theorem runBox_config (n : ℕ) :
    config (runBox hb table m c₀ hm hc₀ n) = orbit hb table c₀ n := by
  cases h : orbit hb table c₀ n
  simp only [config, runBox, h]

def runActive (n : ℕ) (h : (lookup hb table (orbit hb table c₀ n)).isSome) :
    Active hb table (capacity b m n) := ⟨runBox hb table m c₀ hm hc₀ n, h⟩

theorem target_runActive (n : ℕ) (h : (lookup hb table (orbit hb table c₀ n)).isSome) :
    target hb table (runActive hb table m c₀ hm hc₀ n h) = orbit hb table c₀ (n + 1) := by
  rw [target, show (runActive hb table m c₀ hm hc₀ n h).val = runBox hb table m c₀ hm hc₀ n from rfl,
    runBox_config, orbit_succ]
  apply (next_eq_of_lookup hb table _).symm
  exact (Option.some_get h).symm

theorem runPath_eq_installed (hterm : NoOutgoing table terminal) (n : ℕ)
    (h : (lookup hb table (orbit hb table c₀ n)).isSome) :
    runPath hb table terminal ν m c₀ n =
      path hb table terminal ν m n (runActive hb table m c₀ hm hc₀ n h) := by
  have hs : sign terminal (orbit hb table c₀ n).state = -1 :=
    ite_eq_right (lookup_source_nonterminal hb table hterm h)
  dsimp only [runPath]
  rw [hs, CenterPaths.signed_source_negative]
  unfold path
  rw [target_runActive hb table m c₀ hm hc₀ n h]
  congr 1
  simp only [targetAddress, target_runActive hb table m c₀ hm hc₀ n h, capacity_succ]

include hm hc₀

theorem runPath_plateau (hν : 0 < ν) (hdir : IncomingDirection table) (hin : IncomingRule table)
    (hterm : NoOutgoing table terminal) (n : ℕ)
    (h : (lookup hb table (orbit hb table c₀ n)).isSome) {t : ℝ}
    (ht : t ∈ Icc (startTime ν (K₀ N b m) (D b) n) (startTime ν (K₀ N b m) (D b) (n + 1)))
    (X : Coord 2) (hX : ∀ i, |X i - runPath hb table terminal ν m c₀ n t i| ≤
      radius ν (K₀ N b m) (D b) n) :
    field hb table terminal ν m t X = deriv (runPath hb table terminal ν m c₀ n) t := by
  rw [runPath_eq_installed hb table terminal ν m c₀ hm hc₀ hterm n h] at hX ⊢
  exact field_plateau hb table terminal ν m hν hm hdir hin n
    (runActive hb table m c₀ hm hc₀ n h) ht X hX

theorem runPath_negative (hν : 0 < ν) (hterm : NoOutgoing table terminal) (n : ℕ)
    (h : (lookup hb table (orbit hb table c₀ n)).isSome)
    (hn : (orbit hb table c₀ (n + 1)).state ≠ terminal) (t : ℝ) :
    runPath hb table terminal ν m c₀ n t 1 ≤ -spacing ν (K₀ N b m) (D b) n := by
  rw [runPath_eq_installed hb table terminal ν m c₀ hm hc₀ hterm n h]
  apply path_negative hb table terminal ν m hν
  rwa [target_runActive]

end VelocityDetection.ExpandingArray
end

end OAI