import OAI.Geometry.PeriodicTiling.ShiftMultiplicity
import Mathlib.Algebra.BigOperators.Ring.Finset
import Mathlib.Data.Finset.Max
import Mathlib.Data.Fintype.BigOperators
import Mathlib.Tactic.Linarith
import Lean.Elab.Tactic.Omega
import Mathlib.Tactic.Ring
import OAI.Geometry.PeriodicTiling.ActivationTiles
import OAI.Geometry.PeriodicTiling.Dependence
import Mathlib.Logic.Equiv.Prod

namespace OAI

universe uα uJ uC uK uZ

noncomputable section

namespace PeriodicTilingThree

open scoped BigOperators

def MixedDifferenceZero {a b : ℕ} (Q : ZMod a × ZMod b → ℤ) : Prop :=
  ∀ x y, Q (x, y) - Q (x - 1, y) - Q (x, y - 1) + Q (x - 1, y - 1) = 0

private theorem zmod_eq_zero_of_pred_invariant {n : ℕ} [NeZero n] {α : Type uα}
    (f : ZMod n → α) (hf : ∀ x, f x = f (x - 1)) (x : ZMod n) : f x = f 0 := by
  have hnat : ∀ m : ℕ, f (m : ZMod n) = f 0 := by
    intro m
    induction m with
    | zero => simp only [Nat.cast_zero]
    | succ m ih =>
        calc
          f ((m + 1 : ℕ) : ZMod n) = f (m : ZMod n) := by
            simpa only [Nat.cast_add, Nat.cast_one, add_sub_cancel_right] using
              hf ((m : ZMod n) + 1)
          _ = f 0 := ih
  simpa only [ZMod.natCast_zmod_val] using hnat x.val

theorem mixedDifference_rectangle {a b : ℕ} [NeZero a] [NeZero b]
    (Q : ZMod a × ZMod b → ℤ) (hmixed : MixedDifferenceZero Q)
    (x x₀ : ZMod a) (y : ZMod b) :
    Q (x, y) - Q (x₀, y) = Q (x, 0) - Q (x₀, 0) := by
  have hfirst (z : ZMod a) :
      Q (z, y) - Q (z - 1, y) = Q (z, 0) - Q (z - 1, 0) := by
    apply zmod_eq_zero_of_pred_invariant
      (fun w : ZMod b => Q (z, w) - Q (z - 1, w))
    intro w
    have h := hmixed z w
    linarith only [h]
  have hrow (z : ZMod a) :
      Q (z, y) - Q (z, 0) = Q (0, y) - Q (0, 0) := by
    apply zmod_eq_zero_of_pred_invariant
      (fun w : ZMod a => Q (w, y) - Q (w, 0))
    intro w
    have h := hfirst w
    linarith only [h]
  linarith only [hrow x, hrow x₀]

theorem histogram_separable {a b : ℕ} [NeZero a] [NeZero b]
    (Q : ZMod a × ZMod b → ℕ)
    (hmixed : MixedDifferenceZero (fun z => (Q z : ℤ))) :
    ∃ u : ZMod a → ℕ, ∃ v : ZMod b → ℕ, ∀ x y, Q (x, y) = u x + v y := by
  classical
  obtain ⟨x₀, _hx₀, hmin⟩ := Finset.exists_min_image
    (Finset.univ : Finset (ZMod a)) (fun x => Q (x, 0)) Finset.univ_nonempty
  let u : ZMod a → ℕ := fun x => Q (x, 0) - Q (x₀, 0)
  let v : ZMod b → ℕ := fun y => Q (x₀, y)
  refine ⟨u, v, ?_⟩
  intro x y
  have hle : Q (x₀, 0) ≤ Q (x, 0) := hmin x (Finset.mem_univ x)
  have hrectangle := mixedDifference_rectangle
    (fun z => (Q z : ℤ)) hmixed x x₀ y
  dsimp [u, v]
  omega

theorem histogram_mass_eq {a b : ℕ} [NeZero a] [NeZero b]
    (Q : ZMod a × ZMod b → ℕ) (u : ZMod a → ℕ) (v : ZMod b → ℕ)
    (hsep : ∀ x y, Q (x, y) = u x + v y) :
    (∑ z, Q z) = b * (∑ x, u x) + a * (∑ y, v y) := by
  calc
    (∑ z, Q z) = ∑ x : ZMod a, ∑ y : ZMod b, (u x + v y) := by
      rw [Fintype.sum_prod_type]
      apply Finset.sum_congr rfl
      intro x _
      apply Finset.sum_congr rfl
      intro y _
      exact hsep x y
    _ = b * (∑ x, u x) + a * (∑ y, v y) := by
      simp [Finset.sum_add_distrib, ← Finset.mul_sum]

theorem histogram_mass_dvd {a b D : ℕ} [NeZero a] [NeZero b]
    (Q : ZMod a × ZMod b → ℕ)
    (hmixed : MixedDifferenceZero (fun z => (Q z : ℤ)))
    (hmass : (∑ z, Q z) = D) (hlarge : D < b) : a ∣ D := by
  obtain ⟨u, v, hsep⟩ := histogram_separable Q hmixed
  have htotal : D = b * (∑ x, u x) + a * (∑ y, v y) := by
    rw [← hmass]
    exact histogram_mass_eq Q u v hsep
  have hu : (∑ x, u x) = 0 := by
    by_contra hne
    have hone : 1 ≤ ∑ x, u x := Nat.one_le_iff_ne_zero.mpr hne
    have hmul : b ≤ b * (∑ x, u x) := by
      simpa only [Nat.mul_one] using Nat.mul_le_mul_left b hone
    omega
  refine ⟨∑ y, v y, ?_⟩
  simpa only [hu, Nat.mul_zero, Nat.zero_add] using htotal

private theorem sum_histogram_corner {a b : ℕ} [NeZero a] [NeZero b]
    (f : ZMod a × ZMod b → ℤ) (x : ZMod a) (y : ZMod b) :
    (∑ e : ZMod a × ZMod b,
      ((if e.1 = x then (1 : ℤ) else 0) * (if e.2 = y then 1 else 0)) * f e) =
        f (x, y) := by
  classical
  have hterm (e : ZMod a × ZMod b) :
      ((if e.1 = x then (1 : ℤ) else 0) * (if e.2 = y then 1 else 0)) * f e =
        if e = (x, y) then f e else 0 := by
    rcases e with ⟨x', y'⟩
    by_cases hx : x' = x <;> by_cases hy : y' = y <;>
      simp [hx, hy, Prod.mk.injEq]
  simp_rw [hterm]
  simp

theorem sum_shiftOmega_mul {a b : ℕ} [NeZero a] [NeZero b]
    (Q : ZMod a × ZMod b → ℤ) (x : ZMod a) (y : ZMod b) :
    (∑ e : ZMod a × ZMod b, shiftOmega a b e * Q ((x, y) - e)) =
      Q (x, y) - Q (x - 1, y) - Q (x, y - 1) + Q (x - 1, y - 1) := by
  classical
  have hexpand (e : ZMod a × ZMod b) :
      shiftOmega a b e * Q ((x, y) - e) =
        ((if e.1 = 0 then (1 : ℤ) else 0) * (if e.2 = 0 then 1 else 0)) *
            Q ((x, y) - e) -
          ((if e.1 = 1 then (1 : ℤ) else 0) * (if e.2 = 0 then 1 else 0)) *
            Q ((x, y) - e) -
          ((if e.1 = 0 then (1 : ℤ) else 0) * (if e.2 = 1 then 1 else 0)) *
            Q ((x, y) - e) +
          ((if e.1 = 1 then (1 : ℤ) else 0) * (if e.2 = 1 then 1 else 0)) *
            Q ((x, y) - e) := by
    unfold shiftOmega
    ring
  simp_rw [hexpand]
  rw [Finset.sum_add_distrib, Finset.sum_sub_distrib, Finset.sum_sub_distrib]
  simp only [sum_histogram_corner, Prod.mk_sub_mk, sub_zero]

theorem mixedDifferenceZero_of_shift_sum {a b D : ℕ} [NeZero a] [NeZero b]
    (ha : 2 ≤ a) (hb : 2 ≤ b) (Q : ZMod a × ZMod b → ℕ)
    (hmass : (∑ z, Q z) = D)
    (hcoverage : ∀ c : ZMod a × ZMod b,
      (∑ δ : ShiftIndex a b, Q (c - shift a b δ)) = D) :
    MixedDifferenceZero (fun z => (Q z : ℤ)) := by
  classical
  intro x y
  have hcount :
      (∑ δ : ShiftIndex a b, (Q ((x, y) - shift a b δ) : ℤ)) = (D : ℤ) := by
    exact_mod_cast hcoverage (x, y)
  rw [sum_shift (fun e : ZMod a × ZMod b => (Q ((x, y) - e) : ℤ))] at hcount
  simp only [nsmul_eq_mul] at hcount
  simp_rw [shiftMultiplicity_cast ha hb] at hcount
  simp only [add_mul, one_mul, Finset.sum_add_distrib] at hcount
  have hbase : (∑ e : ZMod a × ZMod b, (Q ((x, y) - e) : ℤ)) = (D : ℤ) := by
    have hinv : Function.Involutive (fun e : ZMod a × ZMod b => (x, y) - e) :=
      fun e => sub_sub_cancel (x, y) e
    calc
      (∑ e : ZMod a × ZMod b, (Q ((x, y) - e) : ℤ)) = ∑ e, (Q e : ℤ) :=
        hinv.bijective.sum_comp (fun e => (Q e : ℤ))
      _ = (D : ℤ) := by exact_mod_cast hmass
  rw [hbase, sum_shiftOmega_mul (fun z => (Q z : ℤ)) x y] at hcount
  linarith only [hcount]

theorem histogram_mass_dvd_of_shift_sum {a b D : ℕ} [NeZero a] [NeZero b]
    (ha : 2 ≤ a) (hb : 2 ≤ b) (Q : ZMod a × ZMod b → ℕ)
    (hmass : (∑ z, Q z) = D) (hlarge : D < b)
    (hcoverage : ∀ c : ZMod a × ZMod b,
      (∑ δ : ShiftIndex a b, Q (c - shift a b δ)) = D) : a ∣ D :=
  histogram_mass_dvd Q (mixedDifferenceZero_of_shift_sum ha hb Q hmass hcoverage)
    hmass hlarge

theorem sum_firstCoordinate_of_bijective
    {J : Type uJ} {C : Type uC} {K : Type uK} [Fintype J] [Fintype C] [Fintype K] [DecidableEq C]
    (f : J → C × K) (hf : Function.Bijective f) (c : C) :
    (∑ j, if (f j).1 = c then (1 : ℕ) else 0) = Fintype.card K := by
  calc
    _ = ∑ z : C × K, if z.1 = c then (1 : ℕ) else 0 :=
      hf.sum_comp (fun z => if z.1 = c then (1 : ℕ) else 0)
    _ = _ := by
      rw [Fintype.sum_prod_type, Finset.sum_comm]
      dsimp only
      simp only [Fintype.sum_ite_eq', Finset.sum_const, Finset.card_univ,
        nsmul_eq_mul, mul_one, Nat.cast_id]

theorem card_firstCoordinate_of_bijective
    {J : Type uJ} {C : Type uC} {K : Type uK} [Fintype J] [Fintype C] [Fintype K] [DecidableEq C]
    (f : J → C × K) (hf : Function.Bijective f) (c : C) :
    Fintype.card {j : J // (f j).1 = c} = Fintype.card K := by
  simpa only [Fintype.card_subtype, Finset.card_filter] using
    sum_firstCoordinate_of_bijective f hf c

theorem sum_firstFirstCoordinate_of_bijective
    {J : Type uJ} {C : Type uC} {K : Type uK} {Z : Type uZ}
    [Fintype J] [Fintype C] [Fintype K] [Fintype Z]
    [DecidableEq C] (f : J → (C × K) × Z) (hf : Function.Bijective f) (c : C) :
    (∑ j, if (f j).1.1 = c then (1 : ℕ) else 0) =
      Fintype.card K * Fintype.card Z := by
  have h := sum_firstCoordinate_of_bijective
    (fun j => Equiv.prodAssoc C K Z (f j))
    ((Equiv.prodAssoc C K Z).bijective.comp hf) c
  change (∑ j, if (f j).1.1 = c then (1 : ℕ) else 0) =
    Fintype.card (K × Z) at h
  simpa only [Fintype.card_prod] using h

theorem card_firstFirstCoordinate_of_bijective
    {J : Type uJ} {C : Type uC} {K : Type uK} {Z : Type uZ}
    [Fintype J] [Fintype C] [Fintype K] [Fintype Z]
    [DecidableEq C] (f : J → (C × K) × Z) (hf : Function.Bijective f) (c : C) :
    Fintype.card {j : J // (f j).1.1 = c} =
      Fintype.card K * Fintype.card Z := by
  simpa only [Fintype.card_subtype, Finset.card_filter] using
    sum_firstFirstCoordinate_of_bijective f hf c

def seedHistogram {p : ℕ} [NeZero p] {C : Type uC}
    (q : Residues p → C) (c : C) : ℕ := by
  classical
  exact Fintype.card {s : Residues p // q s = c}

theorem seedHistogram_eq_sum {p : ℕ} [NeZero p] {C : Type uC} [DecidableEq C]
    (q : Residues p → C) (c : C) :
    seedHistogram q c = ∑ s : Residues p, if q s = c then (1 : ℕ) else 0 := by
  simp only [seedHistogram, Fintype.card_subtype, Finset.card_filter]

theorem sum_seedHistogram {p : ℕ} [NeZero p] {C : Type uC} [Fintype C]
    (q : Residues p → C) : (∑ c, seedHistogram q c) = p ^ 4 := by
  classical
  calc
    (∑ c, seedHistogram q c) =
        Fintype.card (Σ c : C, {s : Residues p // q s = c}) := by
      simp only [Fintype.card_sigma, seedHistogram]
    _ = Fintype.card (Residues p) := Fintype.card_congr (Equiv.sigmaFiberEquiv q)
    _ = p ^ 4 := by
      simp only [Residues, Fintype.card_prod, ZMod.card]
      ring

theorem sum_seedHistogram_translate {p : ℕ} [NeZero p]
    {C : Type uC} [AddCommGroup C] [DecidableEq C]
    (q : Residues p → C) (s : Residues p) (e c : C) :
    (∑ τ : Residues p, if q (s - τ) + e = c then (1 : ℕ) else 0) =
      seedHistogram q (c - e) := by
  have hinv : Function.Involutive (fun τ : Residues p => s - τ) :=
    fun τ => sub_sub_cancel s τ
  rw [seedHistogram_eq_sum]
  simpa only [eq_sub_iff_add_eq] using
    hinv.bijective.sum_comp (fun τ => if q τ + e = c then (1 : ℕ) else 0)

variable {p : ℕ} [NeZero p] (E : EncodingParameters p)

theorem ordinary_active_of_tile (o : Outputs E) (hdep : HasDependence E o)
    (n : Column p) (htile : Tiles (ordinaryActivationTile E n) (graph o)) :
    ∀ x, ∃ j, Active E o (.inl n) x j := by
  classical
  intro x
  by_contra hno
  obtain ⟨c₀, hc⟩ := (no_active_iff_constant E o (.inl n) x).mp
    (fun j hj => hno ⟨j, hj⟩)
  have hsource (j : ActivationIndex E (.inl n)) :
      o.c (ordinarySource E n (x, 0) j) (.inl n) = c₀ := by
    calc
      _ = usefulAt E o (.inl n) (ordinarySource E n (x, 0) j).1
          ((ordinarySource E n (x, 0) j).2 (.inl n)) :=
        usefulAt_factor E hdep _ _ _
      _ = usefulAt E o (.inl n) x
          ((ordinarySource E n (x, 0) j).2 (.inl n)) :=
        usefulAt_eq_of_lineValue_eq E hdep n (ordinarySource_lineValue E n (x, 0) j) _
      _ = c₀ := hc _
  have hmap (j : ActivationIndex E (.inl n)) :
      (ordinaryActivationMap E n o (x, 0) j).1 =
        c₀ + shift (E.a (.inl n)) (E.b (.inl n)) j.2 := by
    change o.c (ordinarySource E n (x, 0) j) (.inl n) + _ = _
    rw [hsource]
  have htwo : (∑ δ : ShiftIndex (E.a (.inl n)) (E.b (.inl n)),
      if shift (E.a (.inl n)) (E.b (.inl n)) δ = 0 then (1 : ℕ) else 0) = 2 := by
    calc
      _ = ∑ e : P E (.inl n), shiftMultiplicity (E.a (.inl n)) (E.b (.inl n)) e •
          (if e = 0 then (1 : ℕ) else 0) := sum_shift _
      _ = shiftMultiplicity (E.a (.inl n)) (E.b (.inl n)) (0 : P E (.inl n)) := by
        simp [mul_ite]
      _ = 2 := by
        change shiftMultiplicity (E.a (.inl n)) (E.b (.inl n)) (0, 0) = 2
        exact shiftMultiplicity_zero
  have hcount := sum_firstCoordinate_of_bijective
    (ordinaryActivationMap E n o (x, 0))
    ((ordinaryActivationTile_iff E n o).mp htile (x, 0)) c₀
  simp_rw [hmap, add_eq_left] at hcount
  rw [Fintype.sum_prod_type] at hcount
  have hbad : E.r (.inl n) * 2 = E.r (.inl n) := by
    simpa only [htwo, Finset.sum_const, Finset.card_univ, nsmul_eq_mul, Nat.cast_id, K, ZMod.card]
      using hcount
  have hr := E.r_pos (.inl n)
  omega

theorem seed_active_somewhere_of_tile (o : Outputs E) (hdep : HasDependence E o)
    (t : Fin 2) (htile : Tiles (seedActivationTile E t) (graph o)) :
    ∃ x, Active E o (.inr t) x () := by
  classical
  by_contra hno
  have hinactive (x : Plane) : ¬ Active E o (.inr t) x () :=
    fun hx => hno ⟨x, hx⟩
  let q : Residues p → P E (.inr t) := fun s => seedFactor E o t s 0
  have hconstant (s : Residues p) (w : K E (.inr t)) :
      seedFactor E o t s w = q s := by
    obtain ⟨c, hc⟩ := (no_active_iff_constant E o (.inr t)
      (seedRepresentative p s)).mp (by
        intro j
        cases j
        exact hinactive (seedRepresentative p s))
    exact (hc w).trans (hc 0).symm
  have hfactor (x : Plane) (k : Input E) :
      o.c (x, k) (.inr t) = q (seedResidue p x) :=
    (seedFactor_spec E hdep t x k).trans (hconstant _ _)
  let b₀ : Base E := (0, 0)
  have hmap (j : SeedActivationIndex E t) :
      (seedActivationMap E t o b₀ j).1.1 =
        q (seedResidue p b₀.1 - j.2) +
          shift (E.a (.inr t)) (E.b (.inr t)) j.1.2 := by
    have hf := hfactor (seedSource E t b₀ j).1 (seedSource E t b₀ j).2
    change o.c (seedSource E t b₀ j) (.inr t) = _ at hf
    change o.c (seedSource E t b₀ j) (.inr t) + _ = _
    rw [hf]
    have hs : seedResidue p (seedSource E t b₀ j).1 =
        seedResidue p b₀.1 - j.2 := seedSource_residue E t b₀ j
    rw [hs]
  have hcoverage (c : P E (.inr t)) :
      (∑ δ : ShiftIndex (E.a (.inr t)) (E.b (.inr t)),
        seedHistogram q (c - shift (E.a (.inr t)) (E.b (.inr t)) δ)) = D p := by
    have hcount := sum_firstFirstCoordinate_of_bijective
      (seedActivationMap E t o b₀) ((seedActivationTile_iff E t o).mp htile b₀) c
    simp_rw [hmap] at hcount
    rw [Fintype.sum_prod_type, Fintype.sum_prod_type] at hcount
    simp_rw [sum_seedHistogram_translate] at hcount
    have hmul : E.r (.inr t) *
        (∑ δ : ShiftIndex (E.a (.inr t)) (E.b (.inr t)),
          seedHistogram q (c - shift (E.a (.inr t)) (E.b (.inr t)) δ)) =
        E.r (.inr t) * D p := by
      simpa only [Finset.sum_const, Finset.card_univ, nsmul_eq_mul, Nat.cast_id, K, ZMod.card]
        using hcount
    exact Nat.eq_of_mul_eq_mul_left (E.r_pos (.inr t)) hmul
  have hdiv : E.a (.inr t) ∣ p ^ 4 :=
    histogram_mass_dvd_of_shift_sum (E.a_two_le (.inr t)) (E.b_two_le (.inr t))
      (seedHistogram q) (sum_seedHistogram q) (E.seed_b_large t) hcoverage
  exact E.prime_ne_p (.inl (.inr t))
    (Nat.prime_eq_prime_of_dvd_pow (E.a_prime (.inr t)) E.p_prime hdiv)

end PeriodicTilingThree

end

end OAI