import OAI.Geometry.PeriodicTiling.ConfigurationDifferenceReduction
import OAI.Geometry.PeriodicTiling.ForwardDifference
import OAI.Geometry.PeriodicTiling.FiniteMasks
import OAI.Geometry.PeriodicTiling.PlaneLattices
import Mathlib.Topology.Instances.AddCircle.Defs
import Mathlib.Tactic.Choose
import Mathlib.Tactic.Linarith

namespace OAI

universe uB

namespace PeriodicTilingThree

theorem forwardDiff_slice {B : Type uB} [AddCommGroup B]
    (f : Plane → B) (x e : Plane) :
    forwardDiff (fun n : ℤ => f (x + n • e)) =
      fun n => configDiff e f (x + n • e) := by
  ext n
  simp only [forwardDiff_apply, configDiff_apply, add_zsmul, one_zsmul, add_assoc]

theorem forwardDiff_iterate_slice {B : Type uB} [AddCommGroup B]
    (k : ℕ) (f : Plane → B) (x e : Plane) :
    (forwardDiff^[k]) (fun n : ℤ => f (x + n • e)) =
      fun n => ((configDiff e)^[k] f) (x + n • e) := by
  induction k generalizing f with
  | zero => rfl
  | succ k ih =>
      rw [Function.iterate_succ_apply, forwardDiff_slice, ih,
        Function.iterate_succ_apply]

theorem circle_sum_of_indicator_decomposition {m : ℕ} (A : Set Plane)
    (φ : Fin m → Plane → ℝ)
    (hsum : ∀ x, tileIndicator ℝ A x + ∑ j, φ j x = 1) :
    (∑ j, (fun x => (φ j x : AddCircle (1 : ℝ)))) = fun _ => 0 := by
  classical
  ext x
  simp only [Finset.sum_apply]
  change (∑ j, (φ j x : AddCircle (1 : ℝ))) = 0
  have hcast : (∑ j, (φ j x : AddCircle (1 : ℝ))) =
      ((∑ j, φ j x : ℝ) : AddCircle (1 : ℝ)) := by
    exact (map_sum (QuotientAddGroup.mk' (AddSubgroup.zmultiples (1 : ℝ)))
      (fun j => φ j x) Finset.univ).symm
  rw [hcast, show (∑ j, φ j x) = 1 - tileIndicator ℝ A x by linarith [hsum x]]
  by_cases hx : x ∈ A <;> simp [tileIndicator, hx, AddCircle.coe_period]

theorem directional_circle_slice_polynomial {m : ℕ} (hm : 0 < m)
    (A : Set Plane) (v : Fin m → Plane) (φ : Fin m → Plane → ℝ)
    (e : Plane)
    (hspan : ∀ i j, i ≠ j → ∃ a b : ℤ, e = a • v i + b • v j)
    (hp : ∀ j, Function.Periodic (φ j) (v j))
    (hsum : ∀ x, tileIndicator ℝ A x + ∑ j, φ j x = 1)
    (j : Fin m) (x : Plane) :
    (forwardDiff^[m]) (fun n : ℤ =>
      (φ j (x + n • e) : AddCircle (1 : ℝ))) = 0 := by
  classical
  let ψ : Fin m → Plane → AddCircle (1 : ℝ) := fun i y => (φ i y : AddCircle (1 : ℝ))
  have hψ : ∀ i, Function.Periodic (ψ i) (v i) := by
    intro i y
    change (φ i (y + v i) : AddCircle (1 : ℝ)) = (φ i y : AddCircle (1 : ℝ))
    rw [hp i y]
  have hrep : ∀ i : Fin m, ∃ a b : ℤ, i = j ∨ e = a • v i + b • v j := by
    intro i
    by_cases hij : i = j
    · exact ⟨0, 0, Or.inl hij⟩
    · obtain ⟨a, b, hab⟩ := hspan i j hij
      exact ⟨a, b, Or.inr hab⟩
  choose α β hrep using hrep
  let u : Fin m → Plane := fun i => if i = j then e else α i • v i
  let vs : List Plane := Finset.univ.toList.map u
  have hlen : vs.length = m := by simp [vs]
  have hne : vs ≠ [] := by
    intro h
    have hz : m = 0 := by simpa only [h, List.length_nil] using hlen.symm
    exact (Nat.ne_of_gt hm) hz
  have hkill : ∀ i, i ≠ j → ∃ w ∈ vs, Function.Periodic (ψ i) w := by
    intro i hij
    refine ⟨u i, ?_, ?_⟩
    · exact List.mem_map.mpr ⟨i, by simp, rfl⟩
    · simpa only [u, ite_eq_right hij] using (hψ i).zsmul (α i)
  have hz : configDiffs vs (ψ j) = 0 :=
    configDiffs_component_zero j vs hne ψ 0
      (circle_sum_of_indicator_decomposition A φ hsum) hkill
  have hreplace : ∀ w ∈ vs, ∃ k : ℤ, w = e + k • v j := by
    intro w hw
    obtain ⟨i, _hi, rfl⟩ := List.mem_map.mp hw
    by_cases hij : i = j
    · refine ⟨0, ?_⟩
      simp [u, hij]
    · refine ⟨-β i, ?_⟩
      have he := (hrep i).resolve_left hij
      simp only [u, ite_eq_right hij, he, neg_smul]
      abel
  rw [configDiffs_eq_iterate_of_period vs e (v j) (ψ j) (hψ j) hreplace,
    hlen] at hz
  change (forwardDiff^[m]) (fun n : ℤ => ψ j (x + n • e)) = 0
  rw [forwardDiff_iterate_slice, hz]
  rfl

theorem directional_slice_pair_bound {m : ℕ} (A : Set Plane)
    (v : Fin m → Plane) (φ : Fin m → Plane → ℝ) (e : Plane)
    (hspan : ∀ i j, i ≠ j → ∃ a b : ℤ, e = a • v i + b • v j)
    (hφ : ∀ j x, 0 ≤ φ j x)
    (hp : ∀ j, Function.Periodic (φ j) (v j))
    (hsum : ∀ x, tileIndicator ℝ A x + ∑ j, φ j x = 1)
    (x : Plane) (i j : Fin m) (hij : i ≠ j) (n r : ℤ) :
    φ i (x + n • e) + φ j (x + r • e) ≤ 1 := by
  classical
  obtain ⟨a, b, he⟩ := hspan i j hij
  let y : Plane := x + n • e + ((r - n) * a) • v i
  have hy : y = x + r • e + ((n - r) * b) • v j := by
    dsimp [y]
    rw [he]
    simp only [smul_add, mul_smul, sub_smul]
    abel
  have hi : φ i y = φ i (x + n • e) :=
    (hp i).zsmul ((r - n) * a) _
  have hj : φ j y = φ j (x + r • e) := by
    rw [hy]
    exact (hp j).zsmul ((n - r) * b) _
  have hle : φ i y + φ j y ≤ ∑ k, φ k y := by
    have h := Finset.sum_le_sum_of_subset_of_nonneg
      (Finset.subset_univ ({i, j} : Finset (Fin m)))
      (fun k _hk _hnot => hφ k y)
    simpa [hij] using h
  have htotal := hsum y
  have ha := tileIndicator_nonneg A y
  rw [hi, hj] at hle
  linarith

end PeriodicTilingThree

end OAI