import OAI.Analysis.C0Absorption.Angles

namespace OAI

open Set Filter Topology
open scoped NNReal BigOperators ZeroAtInfty
open NormedSpace

namespace C0Absorption
noncomputable section
open Set Filter Topology
open scoped NNReal BigOperators ZeroAtInfty

abbrev Level := ℕ × ℕ
def levelJ (lev : Level) : ℕ := lev.1+lev.2+2
abbrev Block (lev : Level) := (j : Fin (levelJ lev+1)) × BandGrid j.val

structure Label where
  level : Level
  band : Fin (levelJ level+1)
  tag : BandGrid band.val

instance : Countable Label := by
  apply Function.Injective.countable (f := fun γ : Label => (⟨γ.level,⟨γ.band,γ.tag⟩⟩ : (lev : Level) × Block lev))
  intro a b h
  cases a
  cases b
  cases h
  rfl

instance : TopologicalSpace Label := ⊥
instance : DiscreteTopology Label := ⟨rfl⟩

abbrev InputCoordinate := ℕ ⊕ Label

def coordinateEnumeration : InputCoordinate ≃ ℕ := Classical.choice inferInstance

def rowIndex (i : ℕ) : ℕ := coordinateEnumeration (Sum.inl i)
def labelIndex (γ : Label) : ℕ := coordinateEnumeration (Sum.inr γ)
def blockLabel (lev : Level) (b : Block lev) : Label := ⟨lev,b.1,b.2⟩

@[simp] theorem blockLabel_level (lev : Level) (b : Block lev) : (blockLabel lev b).level=lev := rfl

theorem blockLabel_injective (lev : Level) : Function.Injective (blockLabel lev) := by
  intro a b h
  cases a
  cases b
  cases h
  rfl

theorem labelIndex_injective : Function.Injective labelIndex := by
  intro a b h
  exact Sum.inr.inj (coordinateEnumeration.injective h)

theorem rowIndex_injective : Function.Injective rowIndex := by
  intro a b h
  exact Sum.inl.inj (coordinateEnumeration.injective h)

theorem rowIndex_ne_labelIndex (i : ℕ) (γ : Label) : rowIndex i≠labelIndex γ := by
  intro h
  cases coordinateEnumeration.injective h

def blockCoordinates (lev : Level) : Finset ℕ := by
  classical
  exact Finset.univ.image (fun b : Block lev => labelIndex (blockLabel lev b))

theorem mem_blockCoordinates {lev : Level} {k : ℕ} : k ∈ blockCoordinates lev ↔
    ∃ γ : Label, γ.level=lev ∧ labelIndex γ=k := by
  classical
  constructor
  · intro hk
    obtain ⟨b,_,hb⟩ := Finset.mem_image.mp hk
    exact ⟨blockLabel lev b,rfl,hb⟩
  · rintro ⟨⟨μ,j,ξ⟩,h,rfl⟩
    cases h
    exact Finset.mem_image.mpr ⟨⟨j,ξ⟩,Finset.mem_univ _,rfl⟩

theorem blockCoordinates_nonempty (lev : Level) : (blockCoordinates lev).Nonempty := by
  classical
  let j : Fin (levelJ lev+1) := ⟨0,by omega⟩
  let ξ : BandGrid 0 := Fin.elim0
  exact ⟨labelIndex (⟨lev,j,ξ⟩ : Label),mem_blockCoordinates.mpr ⟨⟨lev,j,ξ⟩,rfl,rfl⟩⟩

def predecessorCoordinates (lev : Level) : Finset ℕ :=
  match lev.2 with
  | 0 => {rowIndex lev.1}
  | n+1 => blockCoordinates (lev.1,n)

def radiusCoordinates (lev : Level) : Finset ℕ := predecessorCoordinates lev ∪ blockCoordinates lev

theorem radiusCoordinates_nonempty (lev : Level) : (radiusCoordinates lev).Nonempty :=
  (blockCoordinates_nonempty lev).mono Finset.subset_union_right

def levelSuccessor (lev : Level) : Level := (lev.1,lev.2+1)

def coordinateLevels (k : ℕ) : Finset Level := by
  classical
  exact match coordinateEnumeration.symm k with
  | Sum.inl i => {(i,0)}
  | Sum.inr γ => {γ.level,levelSuccessor γ.level}

theorem radius_incidence (lev : Level) (k : ℕ) :
    k ∈ radiusCoordinates lev ↔ lev ∈ coordinateLevels k := by
  classical
  obtain ⟨c,rfl⟩ := coordinateEnumeration.surjective k
  cases c with
  | inl i =>
    have hk : ∀ μ, coordinateEnumeration (Sum.inl i) ∉ blockCoordinates μ := by
      intro μ h
      obtain ⟨γ,_,he⟩ := mem_blockCoordinates.mp h
      exact rowIndex_ne_labelIndex i γ he.symm
    simp only [radiusCoordinates,Finset.mem_union,coordinateLevels,Equiv.symm_apply_apply,
      Finset.mem_singleton,hk,or_false]
    rcases lev with ⟨l,n⟩
    cases n with
    | zero => simp only [predecessorCoordinates,Finset.mem_singleton,Prod.mk.injEq,and_true]
              change rowIndex i=rowIndex l ↔ l=i
              rw [rowIndex_injective.eq_iff]
              exact eq_comm
    | succ n => simp only [predecessorCoordinates,hk,Prod.mk.injEq,Nat.succ_ne_zero,and_false]
  | inr γ =>
    have hk (μ : Level) : coordinateEnumeration (Sum.inr γ) ∈ blockCoordinates μ ↔ γ.level=μ := by
      rw [mem_blockCoordinates]
      constructor
      · rintro ⟨δ,hδ,he⟩
        exact (labelIndex_injective he) ▸ hδ
      · intro h
        exact ⟨γ,h,rfl⟩
    simp only [radiusCoordinates,Finset.mem_union,coordinateLevels,Equiv.symm_apply_apply,
      Finset.mem_insert,Finset.mem_singleton,hk]
    rcases lev with ⟨i,n⟩
    rcases hγ : γ.level with ⟨l,m⟩
    cases n with
    | zero =>
      simp only [predecessorCoordinates,Finset.mem_singleton]
      have hn : coordinateEnumeration (Sum.inr γ)≠rowIndex i := (rowIndex_ne_labelIndex i γ).symm
      simp only [hn,false_or,levelSuccessor,Prod.mk.injEq,Nat.zero_ne_add_one,and_false,or_false]
      tauto
    | succ n =>
      simp only [predecessorCoordinates,hk,hγ,levelSuccessor,Prod.mk.injEq]
      omega

theorem radius_finite_exceptions (N : ℕ) :
    {lev : Level | ∃ k≤N, k ∈ radiusCoordinates lev}.Finite := by
  classical
  have he : {lev : Level | ∃ k≤N, k ∈ radiusCoordinates lev} ⊆
      ↑((Finset.range (N+1)).biUnion coordinateLevels) := by
    rintro lev ⟨k,hk,hlev⟩
    exact Finset.mem_biUnion.mpr ⟨k,Finset.mem_range.mpr (by omega),(radius_incidence lev k).mp hlev⟩
  exact (Finset.finite_toSet _).subset he

def finiteProjection (I : Finset ℕ) : C0 →L[ℝ] C0 :=
  LinearMap.mkContinuous
    ({
      toFun := fun s : C0 => extendFinite I (fun k => s k)
      map_add' := by
        intro s t
        ext k
        simp only [extendFinite_apply,ZeroAtInftyContinuousMap.add_apply]
        split_ifs <;> simp
      map_smul' := by
        intro a s
        ext k
        simp only [extendFinite_apply,ZeroAtInftyContinuousMap.smul_apply,smul_eq_mul,RingHom.id_apply]
        split_ifs <;> simp } : C0 →ₗ[ℝ] C0) 1 (fun s => by
      change ‖extendFinite I (fun k => s k)‖ ≤ 1 * ‖s‖
      simpa only [one_mul] using extendFinite_norm_le I (fun k => s k) (norm_nonneg s) (fun k => c0_norm_apply_le s k))

@[simp] theorem finiteProjection_apply (I : Finset ℕ) (s : C0) (k : ℕ) :
    finiteProjection I s k = if k∈I then s k else 0 := by
  classical
  rfl

def finiteRadius (I : Finset ℕ) (s : C0) : ℝ := ‖finiteProjection I s‖
def localRadius (lev : Level) : C0 → ℝ := finiteRadius (radiusCoordinates lev)

theorem finiteRadius_nonneg (I : Finset ℕ) (s : C0) : 0 ≤ finiteRadius I s := norm_nonneg _

theorem finiteRadius_le (I : Finset ℕ) (s : C0) : finiteRadius I s≤‖s‖ := by
  apply c0_norm_le _ (norm_nonneg s)
  intro k
  rw [finiteProjection_apply]
  split_ifs
  · exact c0_norm_apply_le s k
  · simp

theorem coordinate_le_finiteRadius {I : Finset ℕ} (s : C0) {k : ℕ} (hk : k∈I) :
    |s k| ≤ finiteRadius I s := by
  simpa only [finiteRadius,finiteProjection_apply,hk,↓reduceIte] using c0_norm_apply_le (finiteProjection I s) k

theorem finiteRadius_lipschitz (I : Finset ℕ) : LipschitzWith 1 (finiteRadius I) := by
  apply LipschitzWith.of_dist_le_mul
  intro s t
  simp only [finiteRadius,NNReal.coe_one,one_mul,dist_eq_norm]
  refine (abs_norm_sub_norm_le _ _).trans ?_
  rw [← map_sub]
  exact finiteRadius_le I (s-t)

theorem finiteRadius_le_tau {I : Finset ℕ} (N : ℕ) (hI : ∀ k∈I, N<k) (s : C0) :
    finiteRadius I s ≤ tau N s := by
  apply c0_norm_le _ (tau_nonneg _ _)
  intro k
  rw [finiteProjection_apply]
  split_ifs with hk
  · have hh := c0_norm_apply_le (coordinateTail N s) k
    simpa only [tau,coordinateTail_apply,hI k hk,↓reduceIte] using hh
  · simpa using tau_nonneg N s

theorem finiteRadius_smul (I : Finset ℕ) (a : ℝ) (s : C0) :
    finiteRadius I (a • s)=|a| * finiteRadius I s := by
  simp only [finiteRadius,map_smul,norm_smul,Real.norm_eq_abs]

theorem localRadius_tendsto (s : C0) : Tendsto (fun lev => localRadius lev s) cofinite (nhds 0) := by
  have ht := tau_tendsto_zero s
  rw [Metric.tendsto_atTop] at ht
  rw [Metric.tendsto_nhds]
  intro ε hε
  obtain ⟨N,hN⟩ := ht ε hε
  filter_upwards [(radius_finite_exceptions N).eventually_cofinite_notMem] with lev hlev
  have he : ∀ k∈radiusCoordinates lev, N<k := by
    intro k hk
    by_contra hn
    exact hlev ⟨k,by omega,hk⟩
  have hh := finiteRadius_le_tau N he s
  have hτ := hN N le_rfl
  simpa only [Real.dist_eq,sub_zero,localRadius,abs_of_nonneg (finiteRadius_nonneg _ s)] using
    hh.trans_lt (by simpa only [Real.dist_eq,sub_zero,abs_of_nonneg (tau_nonneg _ s)] using hτ)

end
end C0Absorption

end OAI