import OAI.MathematicalPhysics.NavierStokes.VelocityDetection.PathBounds
import OAI.MathematicalPhysics.NavierStokes.VelocityDetection.StageCounts
import OAI.MathematicalPhysics.NavierStokes.VelocityDetection.SpatialSlices
import OAI.MathematicalPhysics.NavierStokes.VelocityDetection.FiniteAddresses

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

def K₀ (N b m : ℕ) : ℝ := N * (capacity b m 0 : ℝ) ^ 2

def D (b : ℕ) : ℝ := (b : ℝ) ^ 2

theorem K₀_nonneg (N b m : ℕ) : 0 ≤ K₀ N b m := by unfold K₀; positivity

theorem D_ge_one {b : ℕ} (hb : 0 < b) : 1 ≤ D b := by
  have : (1 : ℝ) ≤ b := by exact_mod_cast hb
  dsimp [D]
  nlinarith

theorem count_eq (N b m n : ℕ) : count (K₀ N b m) (D b) n = N * (capacity b m n : ℝ) ^ 2 := by
  have h := congrArg (fun q : ℕ => (q : ℝ)) (address_count_geometric N b m n)
  simpa only [Nat.cast_mul, Nat.cast_pow, count, K₀, D] using h.symm

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)

def sign (i : Fin N) : ℝ := if i = terminal then 1 else -1

@[simp] theorem abs_sign (i : Fin N) : |sign terminal i| = 1 := by
  unfold sign
  split_ifs <;> norm_num

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)
variable (ν : ℝ) (m : ℕ)

def path (n : ℕ) (c : Active hb table (capacity b m n)) : ℝ → Coord 2 :=
  CenterPaths.center (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 (target hb table c).state) (sourceAddress c.val) (targetAddress hb table c)

def stage (n : ℕ) : VectorField 2 := fun t X =>
  ∑ c : Active hb table (capacity b m n), TranslationGates.field
    (radius ν (K₀ N b m) (D b) n) (path hb table terminal ν m n c t)
    (deriv (path hb table terminal ν m n c) t) X

@[fun_prop] theorem contDiff_path (n : ℕ) (c : Active hb table (capacity b m n)) :
    ContDiff ℝ ∞ (path hb table terminal ν m n c) := by unfold path; fun_prop

@[fun_prop] theorem contDiff_stage (n : ℕ) :
    ContDiff ℝ ∞ (fun q : ℝ × Coord 2 => stage hb table terminal ν m n q.1 q.2) := by
  dsimp [stage]
  apply ContDiff.sum
  intro c _
  exact TranslationGates.contDiff_movingField _ (contDiff_path hb table terminal ν m n c)
    ((contDiff_infty_iff_deriv.mp (contDiff_path hb table terminal ν m n c)).2)

theorem divergence_stage (n : ℕ) (t : ℝ) (X : Coord 2) :
    divergence (stage hb table terminal ν m n) t X = 0 := by
  change divergence (fun t X => ∑ c : Active hb table (capacity b m n),
    TranslationGates.field (radius ν (K₀ N b m) (D b) n)
      (path hb table terminal ν m n c t) (deriv (path hb table terminal ν m n c) t) X) t X = 0
  rw [SpatialCalculus.divergence_sum]
  · apply Finset.sum_eq_zero
    intro c _
    exact TranslationGates.divergence_field (radius ν (K₀ N b m) (D b) n)
      (path hb table terminal ν m n c t) (deriv (path hb table terminal ν m n c) t) X
  · intro c _ s
    exact TranslationGates.contDiff_field _ _ _

theorem stage_zero_before (hν : 0 < ν) (n : ℕ) {t : ℝ}
    (ht : t ≤ startTime ν (K₀ N b m) (D b) n) (X : Coord 2) :
    stage hb table terminal ν m n t X = 0 := by
  apply Finset.sum_eq_zero
  intro c _
  change CenterPaths.gate _ _ _ _ _ _ _ _ t X = 0
  exact CenterPaths.gate_zero_before
    (lt_of_lt_of_le (by norm_num) (duration_ge_one hν (K₀_nonneg N b m) (D_ge_one hb) n))
    _ _ _ _ _ _ _ ht X

theorem stage_zero_after (hν : 0 < ν) (n : ℕ) {t : ℝ}
    (ht : startTime ν (K₀ N b m) (D b) (n + 1) ≤ t) (X : Coord 2) :
    stage hb table terminal ν m n t X = 0 := by
  apply Finset.sum_eq_zero
  intro c _
  change CenterPaths.gate _ _ _ _ _ _ _ _ t X = 0
  exact CenterPaths.gate_zero_after
    (lt_of_lt_of_le (by norm_num) (duration_ge_one hν (K₀_nonneg N b m) (D_ge_one hb) n))
    _ _ _ _ _ _ _ ht X

theorem compactSupport_stage (hν : 0 < ν) (n : ℕ) :
    HasCompactSupport (fun q : ℝ × Coord 2 => stage hb table terminal ν m n q.1 q.2) := by
  have h (c : Active hb table (capacity b m n)) : HasCompactSupport
      (fun q : ℝ × Coord 2 => TranslationGates.field
        (radius ν (K₀ N b m) (D b) n) (path hb table terminal ν m n c q.1)
        (deriv (path hb table terminal ν m n c) q.1) q.2) := by
    apply CenterPaths.compactSupport_gate
    · linarith [radius_ge_one hν (K₀_nonneg N b m) (D_ge_one hb) n]
    · linarith [duration_ge_one hν (K₀_nonneg N b m) (D_ge_one hb) n]
  simpa only [stage, Finset.sum_fn] using HasCompactSupport.finset_sum
    (s := Finset.univ) (fun c _ => h c)

def field : VectorField 2 := fun t X => ∑' n : ℕ, stage hb table terminal ν m n t X

theorem field_eq_finite (hν : 0 < ν) {Q : ℕ} {t : ℝ} (ht : t < Q) (X : Coord 2) :
    field hb table terminal ν m t X = ∑ n ∈ Finset.range Q, stage hb table terminal ν m n t X := by
  apply tsum_eq_sum
  intro n hn
  apply stage_zero_before hb table terminal ν m hν n _ X
  have hn' : Q ≤ n := by simpa using hn
  have hc : (Q : ℝ) ≤ n := by exact_mod_cast hn'
  linarith [startTime_ge hν (K₀_nonneg N b m) (D_ge_one hb) n]

@[fun_prop] theorem contDiff_field (hν : 0 < ν) :
    ContDiff ℝ ∞ (fun q : ℝ × Coord 2 => field hb table terminal ν m q.1 q.2) := by
  apply contDiff_iff_contDiffAt.mpr
  intro q
  obtain ⟨Q, hQ⟩ := exists_nat_gt q.1
  have hs : ContDiff ℝ ∞ (fun p : ℝ × Coord 2 =>
      ∑ n ∈ Finset.range Q, stage hb table terminal ν m n p.1 p.2) :=
    ContDiff.sum (fun n _ => contDiff_stage hb table terminal ν m n)
  apply hs.contDiffAt.congr_of_eventuallyEq
  have hev : ∀ᶠ p : ℝ × Coord 2 in 𝓝 q, p.1 < Q :=
    (isOpen_lt continuous_fst continuous_const).mem_nhds hQ
  exact hev.mono (fun p hp => field_eq_finite hb table terminal ν m hν hp p.2)

theorem field_at_rest (hν : 0 < ν) {t : ℝ} (ht : t ≤ 1) (X : Coord 2) :
    field hb table terminal ν m t X = 0 := by
  change (∑' n : ℕ, stage hb table terminal ν m n t X) = 0
  calc
    _ = ∑' n : ℕ, (0 : Coord 2) := by
      apply tsum_congr
      intro n
      apply stage_zero_before hb table terminal ν m hν n _ X
      linarith [startTime_ge hν (K₀_nonneg N b m) (D_ge_one hb) n, Nat.cast_nonneg (α := ℝ) n]
    _ = _ := tsum_zero

theorem field_eq_stage (hν : 0 < ν) (n : ℕ) {t : ℝ}
    (ht : t ∈ Icc (startTime ν (K₀ N b m) (D b) n) (startTime ν (K₀ N b m) (D b) (n + 1)))
    (X : Coord 2) : field hb table terminal ν m t X = stage hb table terminal ν m n t X := by
  apply tsum_eq_single n
  intro k hk
  have hm := (startTime_strictMono hν (K₀_nonneg N b m) (D_ge_one hb)).monotone
  rcases lt_or_gt_of_ne hk with h | h
  · exact stage_zero_after hb table terminal ν m hν k ((hm (by omega)).trans ht.1) X
  · exact stage_zero_before hb table terminal ν m hν k (ht.2.trans (hm (by omega))) X

theorem divergence_field (hν : 0 < ν) (t : ℝ) (X : Coord 2) :
    divergence (field hb table terminal ν m) t X = 0 := by
  obtain ⟨Q, hQ⟩ := exists_nat_gt t
  have heq := funext (field_eq_finite hb table terminal ν m hν hQ)
  rw [SpatialCalculus.divergence_congr_at
    (v := fun s X => ∑ n ∈ Finset.range Q, stage hb table terminal ν m n s X) t X heq]
  have hs (n : ℕ) (_ : n ∈ Finset.range Q) (s : ℝ) :
      ContDiff ℝ ∞ (stage hb table terminal ν m n s) :=
    SpatialCalculus.contDiff_slice (contDiff_stage hb table terminal ν m n) s
  exact (SpatialCalculus.divergence_sum (Finset.range Q) (stage hb table terminal ν m) hs t X).trans
    (by simp only [divergence_stage, Finset.sum_const_zero])

theorem finiteCylinderSupport (hν : 0 < ν) (T : ℝ) :
    ∃ K : Set (Coord 2), IsCompact K ∧ ∀ t, 0 ≤ t → t ≤ T →
      ∀ X, X ∉ K → field hb table terminal ν m t X = 0 := by
  obtain ⟨Q, hQ⟩ := exists_nat_gt T
  let f : ℝ × Coord 2 → Coord 2 :=
    fun q => ∑ n ∈ Finset.range Q, stage hb table terminal ν m n q.1 q.2
  have hf : HasCompactSupport f := by
    simpa only [Finset.sum_fn, f] using HasCompactSupport.finset_sum
      (fun n (_ : n ∈ Finset.range Q) => compactSupport_stage hb table terminal ν m hν n)
  refine ⟨Prod.snd '' tsupport f, hf.image continuous_snd, ?_⟩
  intro t _ ht X hX
  rw [field_eq_finite hb table terminal ν m hν (ht.trans_lt hQ)]
  change f (t, X) = 0
  apply image_eq_zero_of_notMem_tsupport
  intro hp
  exact hX ⟨(t, X), hp, rfl⟩

theorem paths_separated (hν : 0 < ν) (hm : 1 ≤ m)
    (hdir : IncomingDirection table) (hin : IncomingRule table) (n : ℕ)
    (c d : Active hb table (capacity b m n)) (hcd : c ≠ d) (t : ℝ) :
    ∃ i : Fin 2, 16 * radius ν (K₀ N b m) (D b) n ≤
      |path hb table terminal ν m n c t i - path hb table terminal ν m n d t i| := by
  have hB : 0 < capacity b m n := pow_pos hb _
  have hc : sourceAddress c.val ≠ sourceAddress d.val := by
    intro h
    exact hcd (Subtype.ext (sourceAddress_injective hB h))
  have hd : targetAddress hb table c ≠ targetAddress hb table d :=
    (targetAddress_injective hb table hB (capacity_dvd hm) hdir hin).ne hcd
  exact CenterPaths.separated (spacing_pos hν (K₀_nonneg N b m) (D_ge_one hb) n).le
    (spacing_next_ge hν (K₀_nonneg N b m) (D_ge_one hb) n) _ _ _ _ t hc hd

theorem stage_plateau (hν : 0 < ν) (hm : 1 ≤ m)
    (hdir : IncomingDirection table) (hin : IncomingRule table) (n : ℕ)
    (c : Active hb table (capacity b m n)) (t : ℝ) (X : Coord 2)
    (hX : ∀ i, |X i - path hb table terminal ν m n c t i| ≤ radius ν (K₀ N b m) (D b) n) :
    stage hb table terminal ν m n t X = deriv (path hb table terminal ν m n c) t := by
  apply TranslationGates.array_plateau
    (lt_of_lt_of_le (by norm_num) (radius_ge_one hν (K₀_nonneg N b m) (D_ge_one hb) n))
    (fun d => path hb table terminal ν m n d t)
    (fun d => deriv (path hb table terminal ν m n d) t)
    (fun d _ e _ h => paths_separated hb table terminal ν m hν hm hdir hin n d e h t)
    (Finset.mem_univ c) X hX

theorem field_plateau (hν : 0 < ν) (hm : 1 ≤ m)
    (hdir : IncomingDirection table) (hin : IncomingRule table) (n : ℕ)
    (c : Active hb table (capacity b m n)) {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 - path hb table terminal ν m n c t i| ≤ radius ν (K₀ N b m) (D b) n) :
    field hb table terminal ν m t X = deriv (path hb table terminal ν m n c) t := by
  rw [field_eq_stage hb table terminal ν m hν n ht]
  exact stage_plateau hb table terminal ν m hν hm hdir hin n c t X hX

theorem path_negative (hν : 0 < ν) (n : ℕ)
    (c : Active hb table (capacity b m n))
    (hc : (target hb table c).state ≠ terminal) (t : ℝ) :
    path hb table terminal ν m n c t 1 ≤ -spacing ν (K₀ N b m) (D b) n := by
  unfold path
  rw [sign, ite_eq_right hc]
  exact CenterPaths.negative_height (spacing_pos hν (K₀_nonneg N b m) (D_ge_one hb) n).le
    (spacing_next_ge hν (K₀_nonneg N b m) (D_ge_one hb) n) _ _ _ _ _

theorem path_end (hν : 0 < ν) (n : ℕ) (c : Active hb table (capacity b m n)) :
    path hb table terminal ν m n c (startTime ν (K₀ N b m) (D b) (n + 1)) =
      ![spacing ν (K₀ N b m) (D b) (n + 1) * targetAddress hb table c,
        sign terminal (target hb table c).state * spacing ν (K₀ N b m) (D b) (n + 1)] :=
  CenterPaths.center_end
    (lt_of_lt_of_le (by norm_num) (duration_ge_one hν (K₀_nonneg N b m) (D_ge_one hb) n))
    _ _ _ _ _ _

theorem path_coordinate_bounds (hν : 0 < ν) (hm : 1 ≤ m) (n : ℕ)
    (c : Active hb table (capacity b m n)) :
    |spacing ν (K₀ N b m) (D b) n| ≤ duration ν (K₀ N b m) (D b) n ∧
    |spacing ν (K₀ N b m) (D b) n * sourceAddress c.val| ≤ duration ν (K₀ N b m) (D b) n ∧
    |spacing ν (K₀ N b m) (D b) (n + 1) * targetAddress hb table c| ≤ duration ν (K₀ N b m) (D b) n ∧
    |CenterPaths.privateRow (spacing ν (K₀ N b m) (D b) n) (sourceAddress c.val)| ≤
      duration ν (K₀ N b m) (D b) n ∧
    |sign terminal (target hb table c).state * spacing ν (K₀ N b m) (D b) (n + 1)| ≤
      duration ν (K₀ N b m) (D b) n := by
  apply Expanding.path_coordinate_bounds hν (K₀_nonneg N b m) (D_ge_one hb) n
  · rw [count_eq]
    exact_mod_cast sourceAddress_count c.val
  · rw [count_eq, capacity_succ]
    exact_mod_cast targetAddress_count hb table (capacity_dvd hm) c
  · simp

theorem path_derivative_bounds (hν : 0 < ν) (hm : 1 ≤ m) (j : ℕ) :
    ∃ C : ℝ, 0 ≤ C ∧ ∀ (n : ℕ) (c : Active hb table (capacity b m n)) (t : ℝ) (i : Fin 2),
      |iteratedDeriv (j + 1) (fun s => path hb table terminal ν m n c s i) t| ≤
        C / duration ν (K₀ N b m) (D b) n ^ j := by
  obtain ⟨C, hC, hc⟩ := CenterPaths.center_derivative_bound j
  refine ⟨C, hC, ?_⟩
  intro n c t i
  obtain ⟨hS, hSk, hSl, hY, hσ⟩ := path_coordinate_bounds hb table terminal ν m hν hm n c
  exact hc _ _ _ _ _ _ _
    (lt_of_lt_of_le (by norm_num) (duration_ge_one hν (K₀_nonneg N b m) (D_ge_one hb) n))
    hS hSk hSl hY hσ t i

end VelocityDetection.ExpandingArray
end

end OAI