import OAI.NumberTheory.GaussianMoat.LatticeComponents

namespace OAI

universe uIota

namespace GaussianMoat

def PrimitiveDirection (v : GaussianInt) : Prop := IsCoprime v.re v.im

theorem int_multiple_of_determinant_zero {v w : GaussianInt}
    (hv : PrimitiveDirection v) (hvw : determinant v w = 0) :
    ∃ a : ℤ, w = (a : GaussianInt) * v := by
  obtain ⟨r, s, hrs⟩ := hv
  refine ⟨r * w.re + s * w.im, ?_⟩
  change v.re * w.im - v.im * w.re = 0 at hvw
  ext <;> simp only [Zsqrtd.re_mul, Zsqrtd.im_mul, Zsqrtd.re_intCast,
    Zsqrtd.im_intCast, zero_mul, mul_zero, add_zero]
  · nlinarith [congrArg (fun x : ℤ => x * w.re) hrs,
      congrArg (fun x : ℤ => s * x) hvw]
  · nlinarith [congrArg (fun x : ℤ => x * w.im) hrs,
      congrArg (fun x : ℤ => r * x) hvw]

theorem exists_primitive_direction {w : GaussianInt} (hw : w ≠ 0) :
    ∃ v : GaussianInt, PrimitiveDirection v ∧ v ≠ 0 ∧
      ∃ a : ℤ, a ≠ 0 ∧ w = (a : GaussianInt) * v := by
  have hg := (Zsqrtd.gcd_pos_iff w).mpr hw
  obtain ⟨v, hv, hcop⟩ := Zsqrtd.exists_coprime_of_gcd_pos hg
  refine ⟨v, hcop, ?_, (Int.gcd w.re w.im : ℤ), by exact_mod_cast hg.ne', hv⟩
  intro h
  apply hw
  simp only [h, mul_zero] at hv
  exact hv

theorem norm_dvd_norm {a b : GaussianInt} (h : a ∣ b) : a.norm ∣ b.norm := by
  obtain ⟨u, rfl⟩ := h
  rw [Zsqrtd.norm_mul]
  exact dvd_mul_right _ _

theorem factor_dvd_integer_iff {p : ℕ} {π : GaussianInt} (hp : Nat.Prime p)
    (hπ : π.norm = (p : ℤ)) (a : ℤ) : π ∣ (a : GaussianInt) ↔ (p : ℤ) ∣ a := by
  have hp' : Prime (p : ℤ) := Int.prime_iff_natAbs_prime.mpr (by simpa using hp)
  constructor
  · intro h
    have hn := norm_dvd_norm h
    rw [hπ, Zsqrtd.norm_intCast] at hn
    exact (hp'.dvd_mul.mp hn).elim id id
  · intro h
    have hd : π ∣ (p : GaussianInt) := by
      have he : (p : GaussianInt) = π * star π := by
        rw [← Zsqrtd.norm_eq_mul_conj, hπ]
        simp
      rw [he]
      exact dvd_mul_right _ _
    exact hd.trans (map_dvd (Int.castRingHom GaussianInt) h)

theorem not_both_factors_dvd_primitive {p : ℕ} {π v : GaussianInt}
    (hp : Nat.Prime p) (hpodd : p ≠ 2) (hπ : π.norm = (p : ℤ))
    (hv : PrimitiveDirection v) : ¬ (π ∣ v ∧ star π ∣ v) := by
  rintro ⟨h1, h2⟩
  have hs : π ∣ star v := by
    obtain ⟨u, hu⟩ := h2
    refine ⟨star u, ?_⟩
    simpa only [star_mul, star_star, mul_comm] using congrArg star hu
  have hreal : π ∣ ((2 * v.re : ℤ) : GaussianInt) := by
    have heq : ((2 * v.re : ℤ) : GaussianInt) = v + star v := by
      ext <;> simp
      ring
    rw [heq]
    exact dvd_add h1 hs
  have himag : π ∣ ((2 * v.im : ℤ) : GaussianInt) := by
    have heq : ((2 * v.im : ℤ) : GaussianInt) =
        (⟨0, -1⟩ : GaussianInt) * (v - star v) := by
      ext <;> simp [Zsqrtd.re_mul, Zsqrtd.im_mul]
      ring
    rw [heq]
    exact dvd_mul_of_dvd_right (dvd_sub h1 hs) _
  have hp' : Prime (p : ℤ) := Int.prime_iff_natAbs_prime.mpr (by simpa using hp)
  have hp2 : ¬ (p : ℤ) ∣ 2 := by
    intro h
    have hn : p ∣ 2 := by exact_mod_cast h
    have hh := (Nat.dvd_prime Nat.prime_two).mp hn
    exact hh.elim hp.ne_one hpodd
  have hr : (p : ℤ) ∣ v.re :=
    (hp'.dvd_mul.mp ((factor_dvd_integer_iff hp hπ _).mp hreal)).resolve_left hp2
  have hi : (p : ℤ) ∣ v.im :=
    (hp'.dvd_mul.mp ((factor_dvd_integer_iff hp hπ _).mp himag)).resolve_left hp2
  exact hp'.not_isUnit (hv.isUnit_of_dvd' hr hi)

def signedFactor (π : GaussianInt) (b : Bool) : GaussianInt := if b then π else star π

theorem signedFactor_norm (π : GaussianInt) (b : Bool) : (signedFactor π b).norm = π.norm := by
  cases b <;> simp [signedFactor, Zsqrtd.norm_conj]

theorem signedFactor_irreducible {π : GaussianInt} (hπ : Irreducible π) (b : Bool) :
    Irreducible (signedFactor π b) := by
  cases b
  · exact (MulEquiv.irreducible_iff (starRingAut : RingAut GaussianInt)).mpr hπ
  · exact hπ

theorem coprime_factors_of_norm_primes {p q : ℕ} {π ρ : GaussianInt}
    (hp : Nat.Prime p) (hq : Nat.Prime q) (hpq : p ≠ q)
    (hπ : π.norm = (p : ℤ)) (hρ : ρ.norm = (q : ℤ)) : IsCoprime π ρ := by
  have hc : Nat.Coprime p q := (hp.coprime_iff_not_dvd).mpr (by
    intro hd
    have hh := (Nat.dvd_prime hq).mp hd
    exact hh.elim hp.ne_one hpq)
  have hcz : IsCoprime (p : ℤ) (q : ℤ) := by
    apply Int.isCoprime_iff_gcd_eq_one.mpr
    simpa using hc
  have hcg := hcz.map (Int.castRingHom GaussianInt)
  have hdπ : π ∣ (p : GaussianInt) := (factor_dvd_integer_iff hp hπ _).mpr (dvd_refl _)
  have hdρ : ρ ∣ (q : GaussianInt) := (factor_dvd_integer_iff hq hρ _).mpr (dvd_refl _)
  exact hcg.of_isCoprime_of_dvd_left hdπ |>.of_isCoprime_of_dvd_right hdρ

theorem norm_finset_prod {ι : Type uIota} (s : Finset ι) (f : ι → GaussianInt) :
    (∏ i ∈ s, f i).norm = ∏ i ∈ s, (f i).norm := by
  classical
  induction s using Finset.induction_on with
  | empty => simp
  | @insert i s hi ih => simp [hi, Zsqrtd.norm_mul, ih]

theorem SplitSieve.prod_factors_dvd (s : SplitSieve) (t : Finset ℕ) (ht : t ⊆ s.primes)
    (σ : ℕ → Bool) {v : GaussianInt}
    (hd : ∀ p ∈ t, signedFactor (s.factor p) (σ p) ∣ v) :
    (∏ p ∈ t, signedFactor (s.factor p) (σ p)) ∣ v := by
  apply Finset.prod_dvd_of_coprime _ hd
  intro p hp q hq hpq
  exact coprime_factors_of_norm_primes (s.prime_mem p (ht hp)) (s.prime_mem q (ht hq)) hpq
    ((signedFactor_norm _ _).trans (s.factor_norm p (ht hp)))
    ((signedFactor_norm _ _).trans (s.factor_norm q (ht hq)))

theorem SplitSieve.eligible_product_le_norm (s : SplitSieve) (t : Finset ℕ)
    (ht : t ⊆ s.primes) (σ : ℕ → Bool) {v : GaussianInt} (hv : v ≠ 0)
    (hd : ∀ p ∈ t, signedFactor (s.factor p) (σ p) ∣ v) :
    (∏ p ∈ t, (p : ℤ)) ≤ v.norm := by
  have hle := norm_le_of_dvd hv (s.prod_factors_dvd t ht σ hd)
  rw [norm_finset_prod] at hle
  convert hle using 1
  apply Finset.prod_congr rfl
  intro p hp
  exact ((signedFactor_norm _ _).trans (s.factor_norm p (ht hp))).symm

open scoped Classical in

theorem SplitSieve.uneligible_product_dvd_coefficient (s : SplitSieve)
    (t : Finset ℕ) (ht : t ⊆ s.primes) (σ : ℕ → Bool) (v : GaussianInt) (a : ℤ)
    (hw : (∏ p ∈ t, signedFactor (s.factor p) (σ p)) ∣ (a : GaussianInt) * v) :
    (∏ p ∈ t.filter (fun p => ¬ signedFactor (s.factor p) (σ p) ∣ v), (p : ℤ)) ∣ a := by
  classical
  apply Finset.prod_dvd_of_coprime
  · intro p hp q hq hpq
    have hp' := s.prime_mem p (ht (Finset.mem_filter.mp hp).1)
    have hq' := s.prime_mem q (ht (Finset.mem_filter.mp hq).1)
    apply Int.isCoprime_iff_gcd_eq_one.mpr
    change Nat.Coprime p q
    exact (hp'.coprime_iff_not_dvd).mpr (fun h =>
      ((Nat.dvd_prime hq').mp h).elim hp'.ne_one hpq)
  · intro p hp
    obtain ⟨hpt, hpv⟩ := Finset.mem_filter.mp hp
    have hpp := ht hpt
    have hd : signedFactor (s.factor p) (σ p) ∣ (a : GaussianInt) * v :=
      (Finset.dvd_prod_of_mem _ hpt).trans hw
    have ha := ((signedFactor_irreducible (s.factor_irreducible p hpp) (σ p)).prime.dvd_mul.mp hd).resolve_right hpv
    exact (factor_dvd_integer_iff (s.prime_mem p hpp)
      ((signedFactor_norm _ _).trans (s.factor_norm p hpp)) a).mp ha

open scoped Classical in

theorem SplitSieve.line_witness_norm_lower (s : SplitSieve)
    (t : Finset ℕ) (ht : t ⊆ s.primes) (σ : ℕ → Bool)
    {v w : GaussianInt} (hv : PrimitiveDirection v) (hw : w ≠ 0)
    (hline : determinant v w = 0)
    (hdiv : (∏ p ∈ t, signedFactor (s.factor p) (σ p)) ∣ w) :
    v.norm * (∏ p ∈ t.filter (fun p => ¬ signedFactor (s.factor p) (σ p) ∣ v), (p : ℤ)) ^ 2
      ≤ w.norm := by
  classical
  obtain ⟨a, rfl⟩ := int_multiple_of_determinant_zero hv hline
  have ha : a ≠ 0 := by intro h; simp [h] at hw
  have hd := s.uneligible_product_dvd_coefficient t ht σ v a hdiv
  have habs : 0 < |a| := abs_pos.mpr ha
  have hle := Int.le_of_dvd habs ((dvd_abs _ _).mpr hd)
  have hprod : 0 ≤ ∏ p ∈ t.filter (fun p => ¬ signedFactor (s.factor p) (σ p) ∣ v), (p : ℤ) :=
    Finset.prod_nonneg (fun _ _ => Int.natCast_nonneg _)
  have hs : (∏ p ∈ t.filter (fun p => ¬ signedFactor (s.factor p) (σ p) ∣ v), (p : ℤ)) ^ 2 ≤ a ^ 2 := by
    nlinarith [sq_abs a]
  rw [Zsqrtd.norm_mul, Zsqrtd.norm_intCast]
  nlinarith [mul_le_mul_of_nonneg_left hs (GaussianInt.norm_nonneg v)]

end GaussianMoat

end OAI