import Mathlib.Data.ZMod.Basic
import Mathlib.Tactic.Abel
import Mathlib.Tactic.NormNum
import Mathlib.Tactic.Positivity

namespace OAI

namespace PeriodicTilingThree.CyclicShear

noncomputable section

def low (r : ℕ) : ZMod (r ^ 2) →+ ZMod r :=
  (ZMod.castHom (dvd_pow_self r (by decide : 2 ≠ 0)) (ZMod r)).toAddMonoidHom

@[simp] theorem low_natCast (r m : ℕ) : low r (m : ZMod (r ^ 2)) = (m : ZMod r) := by
  simp [low]

@[simp] theorem low_intCast (r : ℕ) (m : ℤ) :
    low r (m : ZMod (r ^ 2)) = (m : ZMod r) := by
  simp [low]

private def highInteger (r : ℕ) : ℤ →+ ZMod (r ^ 2) where
  toFun z := (r : ZMod (r ^ 2)) * (z : ZMod (r ^ 2))
  map_zero' := by simp
  map_add' x y := by simp [mul_add]

private theorem highInteger_modulus (r : ℕ) : highInteger r r = 0 := by
  dsimp only [highInteger]
  change (r : ZMod (r ^ 2)) * ((r : ℤ) : ZMod (r ^ 2)) = 0
  rw [Int.cast_natCast, ← pow_two, ← Nat.cast_pow]
  exact ZMod.natCast_self (r ^ 2)

def highMul (r : ℕ) : ZMod r →+ ZMod (r ^ 2) :=
  ZMod.lift r ⟨highInteger r, highInteger_modulus r⟩

@[simp] theorem highMul_intCast (r : ℕ) (m : ℤ) :
    highMul r (m : ZMod r) = (r : ZMod (r ^ 2)) * (m : ZMod (r ^ 2)) := by
  exact ZMod.lift_coe r ⟨highInteger r, highInteger_modulus r⟩ m

@[simp] theorem highMul_natCast (r m : ℕ) :
    highMul r (m : ZMod r) = (r : ZMod (r ^ 2)) * (m : ZMod (r ^ 2)) := by
  simpa using highMul_intCast r (m : ℤ)

theorem highMul_apply (r : ℕ) [NeZero r] (b : ZMod r) :
    highMul r b = (r : ZMod (r ^ 2)) * (b.val : ZMod (r ^ 2)) := by
  simpa using highMul_natCast r b.val

theorem highMul_val (r : ℕ) [NeZero r] (b : ZMod r) :
    (highMul r b).val = r * b.val := by
  rw [highMul_apply, ← Nat.cast_mul]
  apply ZMod.val_natCast_of_lt
  have hr : 0 < r := Nat.pos_of_ne_zero (NeZero.ne r)
  simpa [pow_two] using Nat.mul_lt_mul_of_pos_left (ZMod.val_lt b) hr

theorem highMul_injective (r : ℕ) [NeZero r] : Function.Injective (highMul r) := by
  intro b c h
  have hv := congrArg ZMod.val h
  rw [highMul_val, highMul_val] at hv
  have hv' : b.val = c.val := Nat.eq_of_mul_eq_mul_left
    (Nat.pos_of_ne_zero (NeZero.ne r)) hv
  exact ZMod.val_injective r hv'

@[simp] theorem low_highMul (r : ℕ) (b : ZMod r) : low r (highMul r b) = 0 := by
  obtain ⟨m, rfl⟩ := ZMod.intCast_surjective b
  rw [highMul_intCast]
  change (ZMod.castHom (dvd_pow_self r (by decide : 2 ≠ 0)) (ZMod r))
    ((r : ZMod (r ^ 2)) * (m : ZMod (r ^ 2))) = 0
  simp only [map_mul, map_natCast, map_intCast, ZMod.natCast_self, zero_mul]

theorem mem_range_highMul_iff (r : ℕ) [NeZero r] (v : ZMod (r ^ 2)) :
    v ∈ Set.range (highMul r) ↔ low r v = 0 := by
  constructor
  · rintro ⟨b, rfl⟩
    exact low_highMul r b
  · intro h
    have hcast : (v.val : ZMod r) = 0 := by
      have hv := congrArg (low r) (ZMod.natCast_zmod_val v)
      simpa only [low_natCast, h] using hv
    obtain ⟨m, hm⟩ := (ZMod.natCast_eq_zero_iff v.val r).mp hcast
    refine ⟨(m : ZMod r), ?_⟩
    rw [highMul_natCast, ← Nat.cast_mul, ← hm]
    exact ZMod.natCast_zmod_val v

theorem range_highMul (r : ℕ) [NeZero r] :
    Set.range (highMul r) = ((low r).ker : Set (ZMod (r ^ 2))) := by
  ext v
  exact mem_range_highMul_iff r v

def highEquiv (r : ℕ) [NeZero r] : ZMod r ≃ (low r).ker :=
  Equiv.ofBijective (fun b => ⟨highMul r b, low_highMul r b⟩)
    ⟨fun _ _ h => highMul_injective r (congrArg Subtype.val h), by
      intro v
      obtain ⟨b, hb⟩ := (mem_range_highMul_iff r v).mpr v.property
      exact ⟨b, Subtype.ext hb⟩⟩

@[simp] theorem highEquiv_apply (r : ℕ) [NeZero r] (b : ZMod r) :
    (highEquiv r b : ZMod (r ^ 2)) = highMul r b := rfl

def shear (r : ℕ) (x : ℤ) (k b : ZMod r) : ZMod (r ^ 2) :=
  (x : ZMod (r ^ 2)) + ((k - (x : ZMod r)).val : ZMod (r ^ 2)) + highMul r b

@[simp] theorem low_shear (r : ℕ) [NeZero r] (x : ℤ) (k b : ZMod r) :
    low r (shear r x k b) = k := by
  simp only [shear, map_add, low_intCast, low_natCast, low_highMul, add_zero,
    ZMod.natCast_zmod_val]
  abel

theorem shear_injective (r : ℕ) [NeZero r] (x : ℤ) (k : ZMod r) :
    Function.Injective (shear r x k) := by
  intro b c h
  apply highMul_injective r
  exact add_left_cancel h

theorem shear_eq_zero_add (r : ℕ) (x : ℤ) (k b : ZMod r) :
    shear r x k b = shear r x k 0 + highMul r b := by
  simp [shear]

theorem shear_surjective_fiber (r : ℕ) [NeZero r] (x : ℤ) (k : ZMod r) :
    Function.Surjective (fun b : ZMod r =>
      (⟨shear r x k b, low_shear r x k b⟩ : {v : ZMod (r ^ 2) // low r v = k})) := by
  intro v
  have hz : low r (v.val - shear r x k 0) = 0 := by
    rw [map_sub, v.property, low_shear, sub_self]
  obtain ⟨b, hb⟩ := (mem_range_highMul_iff r _).mpr hz
  refine ⟨b, Subtype.ext ?_⟩
  change shear r x k b = v.val
  rw [shear_eq_zero_add, hb]
  abel

def shearEquiv (r : ℕ) [NeZero r] (x : ℤ) (k : ZMod r) :
    ZMod r ≃ {v : ZMod (r ^ 2) // low r v = k} :=
  Equiv.ofBijective (fun b => ⟨shear r x k b, low_shear r x k b⟩)
    ⟨fun _ _ h => shear_injective r x k (congrArg Subtype.val h),
      shear_surjective_fiber r x k⟩

@[simp] theorem shearEquiv_apply (r : ℕ) [NeZero r] (x : ℤ) (k b : ZMod r) :
    (shearEquiv r x k b : ZMod (r ^ 2)) = shear r x k b := rfl

theorem shear_add (r : ℕ) (x h : ℤ) (k b : ZMod r) :
    shear r (x + h) (k + (h : ZMod r)) b = shear r x k b + (h : ZMod (r ^ 2)) := by
  simp only [shear, Int.cast_add]
  abel_nf

theorem shear_source_add (r : ℕ) (x h : ℤ) (k l b : ZMod r)
    (hl : (h : ZMod r) = l) :
    shear r (x - h) (k - l) b + (h : ZMod (r ^ 2)) = shear r x k b := by
  simpa [hl] using (shear_add r (x - h) h (k - l) b).symm

end

end PeriodicTilingThree.CyclicShear

end OAI