import Mathlib
import OAI.Probability.LatticeSurface.Coercivity.GridTrace
import OAI.Probability.LatticeSurface.Coercivity.GridTraceGeometry

namespace OAI

noncomputable section

open scoped BigOperators

namespace GridTrace.NatGrid

def dist₁ (x y : Vertex) : ℝ := |(x.1:ℝ)-y.1|+|(x.2:ℝ)-y.2|

def ball (N : ℕ) (x : Vertex) (r : ℝ) : Finset Vertex :=
  (square N).filter (fun y => dist₁ x y ≤ r)

def localKernel (N : ℕ) (ν : Vertex → ℝ) (s : ℕ) (e : Edge) : ℝ :=
  (4/(s:ℝ)) * ∑ x ∈ square N,
    if e ∈ edges (lo x (2*s-1)) (hi N x (2*s-1)) then ν x else 0

lemma local_mem_dist {N r : ℕ} {x : Vertex} {e : Edge}
    (he : e ∈ edges (lo x r) (hi N x r)) : dist₁ (anchor e) x ≤ 2*r := by
  have h := mem_box_iff.mp (anchor_mem_rect he)
  have h1 : |((anchor e).1:ℝ)-x.1| ≤ r := by
    rw [abs_le]
    constructor <;> linarith [show ((anchor e).1:ℝ) ≤ x.1+r by exact_mod_cast h.2.2.1,
      show (x.1:ℝ) ≤ (anchor e).1+r by exact_mod_cast h.2.2.2.1]
  have h2 : |((anchor e).2:ℝ)-x.2| ≤ r := by
    rw [abs_le]
    constructor <;> linarith [show ((anchor e).2:ℝ) ≤ x.2+r by exact_mod_cast h.2.2.2.2.1,
      show (x.2:ℝ) ≤ (anchor e).2+r by exact_mod_cast h.2.2.2.2.2]
  exact (add_le_add h1 h2).trans_eq (by ring)

lemma square_dist {N : ℕ} {x y : Vertex} (hx : x ∈ square N) (hy : y ∈ square N) :
    dist₁ x y ≤ 2*N := by
  have hx := square_mem.mp hx
  have hy := square_mem.mp hy
  have h1 : |(x.1:ℝ)-y.1| ≤ N := by
    rw [abs_le]
    have hx : (x.1:ℝ) ≤ N := by exact_mod_cast hx.1
    have hy : (y.1:ℝ) ≤ N := by exact_mod_cast hy.1
    constructor <;> linarith [Nat.cast_nonneg (α := ℝ) x.1,Nat.cast_nonneg (α := ℝ) y.1]
  have h2 : |(x.2:ℝ)-y.2| ≤ N := by
    rw [abs_le]
    have hx : (x.2:ℝ) ≤ N := by exact_mod_cast hx.2
    have hy : (y.2:ℝ) ≤ N := by exact_mod_cast hy.2
    constructor <;> linarith [Nat.cast_nonneg (α := ℝ) x.2,Nat.cast_nonneg (α := ℝ) y.2]
  exact (add_le_add h1 h2).trans_eq (by ring)

lemma localKernel_nonneg {N s : ℕ} {ν : Vertex → ℝ}
    (hν : ∀ x ∈ square N, 0 ≤ ν x) (e : Edge) : 0 ≤ localKernel N ν s e := by
  apply mul_nonneg (by positivity)
  exact Finset.sum_nonneg (fun x hx => by split_ifs <;> simp [hν x hx])

lemma localKernel_sup {N s : ℕ} (hN : 1 ≤ N) (hs : 1 ≤ s) {ν : Vertex → ℝ} {α C : ℝ}
    (hα : 0 ≤ α) (hC : 0 ≤ C) (hν : ∀ x ∈ square N, 0 ≤ ν x)
    (hspread : ∀ x ∈ square N, ∀ r : ℝ, 0 ≤ r → r ≤ 2*(N:ℝ) →
      (∑ y ∈ ball N x r, ν y) ≤ C*((r+1)/(N:ℝ))^α)
    {e : Edge} (he : e ∈ edges (0,0) (N,N)) :
    localKernel N ν s e ≤ (4/(s:ℝ))*C*((5*s)/(N:ℝ))^α := by
  have hanc : anchor e ∈ square N := anchor_mem_rect he
  have hnp : (0:ℝ) < N := by exact_mod_cast hN
  have hn : (0:ℝ) ≤ N := hnp.le
  have hs1 : (1:ℝ) ≤ s := by exact_mod_cast hs
  let R : ℝ := min (4*s) (2*N)
  have hr : 0 ≤ R := le_min (by positivity) (by positivity)
  have hrN : R ≤ 2*N := min_le_right _ _
  have hsum : (∑ x ∈ square N, if e ∈ edges (lo x (2*s-1)) (hi N x (2*s-1)) then ν x else 0) ≤
      ∑ x ∈ ball N (anchor e) R, ν x := by
    rw [ball,Finset.sum_filter]
    apply Finset.sum_le_sum
    intro x hx
    by_cases hm : e ∈ edges (lo x (2*s-1)) (hi N x (2*s-1))
    · have hd := local_mem_dist hm
      have dd : (2*(2*s-1):ℕ) ≤ 4*s := by omega
      have hd4 : dist₁ (anchor e) x ≤ 4*s := hd.trans (by exact_mod_cast dd)
      have hdR : dist₁ (anchor e) x ≤ R := le_min hd4 (square_dist hanc hx)
      simp [hm,hdR]
    · simp only [ite_eq_right hm]
      split_ifs <;> simp [hν x hx]
  calc
    _ ≤ (4/(s:ℝ))*(∑ x ∈ ball N (anchor e) R, ν x) := mul_le_mul_of_nonneg_left hsum (by positivity)
    _ ≤ (4/(s:ℝ))*(C*((R+1)/(N:ℝ))^α) :=
      mul_le_mul_of_nonneg_left (hspread (anchor e) hanc R hr hrN) (by positivity)
    _ ≤ (4/(s:ℝ))*C*((5*s)/(N:ℝ))^α := by
      rw [mul_assoc]
      apply mul_le_mul_of_nonneg_left _ (by positivity)
      apply mul_le_mul_of_nonneg_left _ hC
      apply Real.rpow_le_rpow (by positivity) _ hα
      exact div_le_div_of_nonneg_right (by have := min_le_left (4*(s:ℝ)) (2*N);dsimp [R];linarith) hn

lemma localKernel_sum {N s : ℕ} (hs : 1 ≤ s) {ν : Vertex → ℝ} {C : ℝ}
    (hν : ∀ x ∈ square N, 0 ≤ ν x) (hmass : (∑ x ∈ square N, ν x) ≤ C) :
    (∑ e ∈ edges (0,0) (N,N), localKernel N ν s e) ≤ 128*C*s := by
  have hsp : (0:ℝ) < s := by exact_mod_cast hs
  have hcards (x : Vertex) : ((edges (lo x (2*s-1)) (hi N x (2*s-1))).card:ℝ) ≤ 32*(s:ℝ)^2 := by
    have h := edges_card_bound N x (2*s-1)
    have ha : 2*(2*s-1)+1 ≤ 4*s := by omega
    have hb : 2*(2*(2*s-1)+1)^2 ≤ 32*s^2 := by nlinarith [Nat.pow_le_pow_left ha 2]
    exact_mod_cast h.trans hb
  have hid (x : Vertex) : (∑ e ∈ edges (0,0) (N,N),
      if e ∈ edges (lo x (2*s-1)) (hi N x (2*s-1)) then ν x else 0) =
      (edges (lo x (2*s-1)) (hi N x (2*s-1))).card*ν x := by
    rw [← Finset.sum_filter]
    have hf : (edges (0,0) (N,N)).filter
        (fun e => e ∈ edges (lo x (2*s-1)) (hi N x (2*s-1))) =
        edges (lo x (2*s-1)) (hi N x (2*s-1)) := by
      ext e
      simp only [Finset.mem_filter]
      exact ⟨fun h => h.2,fun h => ⟨box_edges_subset N x _ h,h⟩⟩
    rw [hf,Finset.sum_const,nsmul_eq_mul]
  simp only [localKernel,← Finset.mul_sum]
  rw [Finset.sum_comm]
  simp_rw [hid]
  calc
    _ ≤ (4/(s:ℝ))*∑ x ∈ square N, (32*(s:ℝ)^2)*ν x :=
      mul_le_mul_of_nonneg_left (Finset.sum_le_sum (fun x hx => mul_le_mul_of_nonneg_right (hcards x) (hν x hx))) (by positivity)
    _ = (4/(s:ℝ))*(32*(s:ℝ)^2)*(∑ x ∈ square N, ν x) := by
      rw [← Finset.mul_sum, ← mul_assoc]
    _ ≤ (4/(s:ℝ))*(32*(s:ℝ)^2)*C := mul_le_mul_of_nonneg_left hmass (by positivity)
    _ = _ := by field_simp;ring

end GridTrace.NatGrid

end

end OAI