import Mathlib
import OAI.AlgebraicGeometry.NumericalDimension.AmpleAbsorption

namespace OAI

/-! Ample Generation. -/

open AlgebraicGeometry CategoryTheory
open scoped TensorProduct nonZeroDivisors
open scoped TensorProduct
open AlgebraicGeometry CategoryTheory TopologicalSpace
open CategoryTheory Opposite AlgebraicGeometry TopologicalSpace

namespace NumericalDimensionOne
open AlgebraicGeometry CategoryTheory TopologicalSpace

lemma divisorSupport_add_of_nonneg {X : Scheme} {D E : WeilDivisor X}
    (hD : 0 ≤ D) (hE : 0 ≤ E) :
    divisorSupport (D+E) = divisorSupport D ∪ divisorSupport E := by
  apply Set.Subset.antisymm
  · intro x hx
    obtain ⟨p,hp,hpx⟩ := Set.mem_iUnion₂.mp hx
    have hp' : D p ≠ 0 ∨ E p ≠ 0 := by
      by_contra h
      push Not at h
      exact (Finsupp.mem_support_iff.mp hp) (by simp [h.1,h.2])
    rcases hp' with hp' | hp'
    · exact Or.inl (Set.mem_iUnion₂.mpr ⟨p,Finsupp.mem_support_iff.mpr hp',hpx⟩)
    · exact Or.inr (Set.mem_iUnion₂.mpr ⟨p,Finsupp.mem_support_iff.mpr hp',hpx⟩)
  · exact Set.union_subset
      (divisorSupport_mono_nonnegative hD (le_add_of_nonneg_right hE))
      (divisorSupport_mono_nonnegative hE (le_add_of_nonneg_left hD))

section Generation
variable {X : Scheme} [IsIntegral X] [IsLocallyNoetherian X] [CompactSpace X]

lemma sectionNonvanishing_mul {D E : WeilDivisor X} {s t : X.functionField}
    (hs : s ≠ 0) (ht : t ≠ 0)
    (hsD : IsDivisorSection D s) (htE : IsDivisorSection E t) :
    sectionNonvanishing (D+E) (s*t) =
      sectionNonvanishing D s ⊓ sectionNonvanishing E t := by
  have he : principalWeilDivisor (s*t)+(D+E) =
      (principalWeilDivisor s+D)+(principalWeilDivisor t+E) := by
    rw [principalWeilDivisor_mul hs ht]
    abel
  simp only [sectionNonvanishing,he,divisorComplement,
    divisorSupport_add_of_nonneg ((divisorSection_iff_effective hs).mp hsD)
      ((divisorSection_iff_effective ht).mp htE)]
  ext x
  exact not_or

lemma IsGeneratedAt.add {D E : WeilDivisor X} {x : X}
    (hD : IsGeneratedAt D x) (hE : IsGeneratedAt E x) : IsGeneratedAt (D+E) x := by
  obtain ⟨s,hs,hsD,hxs⟩ := hD
  obtain ⟨t,ht,htE,hxt⟩ := hE
  refine ⟨s*t,mul_ne_zero hs ht,?_,?_⟩
  · rw [divisorSection_iff_effective (mul_ne_zero hs ht),principalWeilDivisor_mul hs ht]
    intro p
    have h1 := (divisorSection_iff_effective hs).mp hsD p
    have h2 := (divisorSection_iff_effective ht).mp htE p
    simp only [Finsupp.add_apply] at *
    linarith
  · rw [sectionNonvanishing_mul hs ht hsD htE]
    exact ⟨hxs,hxt⟩

lemma isGeneratedAt_zero (x : X) : IsGeneratedAt (0 : WeilDivisor X) x := by
  refine ⟨1,one_ne_zero,?_,?_⟩
  · rw [divisorSection_iff_effective one_ne_zero]
    simp only [principalWeilDivisor_one,add_zero]
    intro p
    exact le_refl _
  · simp [sectionNonvanishing,principalWeilDivisor_one,divisorComplement,divisorSupport]

lemma IsGeneratedAt.nsmul {D : WeilDivisor X} {x : X}
    (hD : IsGeneratedAt D x) (n : ℕ) : IsGeneratedAt (n • D) x := by
  induction n with
  | zero => simpa using isGeneratedAt_zero x
  | succ n hn => simpa only [succ_nsmul] using hn.add hD

lemma isOpen_isGeneratedAt (D : WeilDivisor X) : IsOpen {x : X | IsGeneratedAt D x} := by
  have he : {x : X | IsGeneratedAt D x} =
      ⋃ s : {s : X.functionField // s ≠ 0 ∧ IsDivisorSection D s},
        (sectionNonvanishing D s.1 : Set X) := by
    ext x
    simp only [Set.mem_ofPred_eq,Set.mem_iUnion,IsGeneratedAt]
    exact ⟨fun ⟨s,hs,hsD,hx⟩ => ⟨⟨s,hs,hsD⟩,hx⟩,
      fun ⟨s,hx⟩ => ⟨s.1,s.2.1,s.2.2,hx⟩⟩
  rw [he]
  exact isOpen_iUnion (fun s => (sectionNonvanishing D s.1).isOpen)

lemma ample_has_generated_power {H : WeilDivisor X} (hH : IsAmpleDivisor H) :
    ∃ r : ℕ, 0 < r ∧ ∀ x : X, IsGeneratedAt (r • H) x := by
  classical
  choose m hm s hs hsec ha hx hsub using (fun x : X => hH.2 x ⊤ (by trivial))
  obtain ⟨V,hV⟩ := isCompact_univ.elim_finite_subcover
    (fun x : X => (sectionNonvanishing (m x • H) (s x) : Set X))
    (fun x => (sectionNonvanishing (m x • H) (s x)).isOpen)
    (fun x _ => Set.mem_iUnion.mpr ⟨x,hx x⟩)
  let r := ∏ x ∈ V, m x
  have hr : 0 < r := Finset.prod_pos (fun x _ => hm x)
  refine ⟨r,hr,?_⟩
  intro x
  obtain ⟨y,hyV,hyx⟩ := Set.mem_iUnion₂.mp (hV (Set.mem_univ x))
  have hdiv : m y ∣ r := Finset.dvd_prod_of_mem m hyV
  have hgen : IsGeneratedAt (m y • H) x := ⟨s y,hs y,hsec y,hyx⟩
  have he : (r / m y) • (m y • H) = r • H := by
    rw [smul_smul,Nat.div_mul_cancel hdiv]
  exact he ▸ hgen.nsmul (r / m y)

lemma ample_add_generated {H D : WeilDivisor X} (hH : IsAmpleDivisor H)
    (hD : IsCartierDivisor D) (hgen : ∀ x : X, IsGeneratedAt D x) :
    IsAmpleDivisor (H+D) := by
  refine ⟨isCartierDivisor_add hH.1 hD,?_⟩
  intro x U hx
  obtain ⟨t,ht,htD,hxt⟩ := hgen x
  obtain ⟨m,hm,s,hs,hsH,ha,hxs,hsub⟩ :=
    hH.2 x (U ⊓ sectionNonvanishing D t) ⟨hx,hxt⟩
  have htD' : IsDivisorSection (m • D) (t^m) := by
    rw [divisorSection_iff_effective (pow_ne_zero _ ht),principalWeilDivisor_pow ht,
      ← nsmul_add]
    intro p
    simpa only [Finsupp.smul_apply,nsmul_eq_mul] using
      mul_nonneg (Int.natCast_nonneg m) ((divisorSection_iff_effective ht).mp htD p)
  have he : sectionNonvanishing (m • (H+D)) (s*t^m) =
      sectionNonvanishing (m • H) s := by
    rw [nsmul_add,sectionNonvanishing_mul hs (pow_ne_zero _ ht) hsH htD',
      sectionNonvanishing_pow _ ht hm]
    exact inf_eq_left.mpr (le_trans hsub inf_le_right)
  refine ⟨m,hm,s*t^m,mul_ne_zero hs (pow_ne_zero _ ht),?_,he ▸ ha,
    he ▸ hxs,he ▸ le_trans hsub inf_le_left⟩
  rw [divisorSection_iff_effective (mul_ne_zero hs (pow_ne_zero _ ht)),
    principalWeilDivisor_mul hs (pow_ne_zero _ ht),nsmul_add]
  intro p
  have h1 := (divisorSection_iff_effective hs).mp hsH p
  have h2 := (divisorSection_iff_effective (pow_ne_zero _ ht)).mp htD' p
  simp only [Finsupp.add_apply] at *
  linarith

omit [IsIntegral X] [IsLocallyNoetherian X] [CompactSpace X] in
lemma open_le_divisorComplement_of_coeff_zero {D : WeilDivisor X}
    (U : X.Opens) (hD : ∀ p : PrimeDivisor X, p.1 ∈ U → D p = 0) :
    U ≤ divisorComplement D := by
  intro x hx hbad
  obtain ⟨p,hp,hpx⟩ := Set.mem_iUnion₂.mp hbad
  have hsp : p.1 ⤳ x := specializes_iff_mem_closure.mpr hpx
  exact (Finsupp.mem_support_iff.mp hp) (hD p (hsp.mem_open U.isOpen hx))

omit [IsIntegral X] [IsLocallyNoetherian X] [CompactSpace X] in
lemma exists_effective_multiple_absorbing {B E : WeilDivisor X}
    (hE : 0 ≤ E) (hBE : ∀ p, E p = 0 → B p = 0) :
    ∃ N : ℕ, 0 < N ∧ 0 ≤ B + N • E := by
  classical
  let N := B.support.sup (fun p => (B p).natAbs) + 1
  have hN : 0 < N := Nat.succ_pos _
  refine ⟨N,hN,?_⟩
  intro p
  change 0 ≤ B p + (N : ℤ) * E p
  by_cases hEp : E p = 0
  · simp only [hEp,hBE p hEp,mul_zero,add_zero,le_refl]
  have hEpos : 1 ≤ E p := by
    have he0 : (0 : ℤ) ≤ E p := hE p
    omega
  have hB : -(N : ℤ) ≤ B p := by
    by_cases hBp : B p = 0
    · simpa only [hBp,neg_nonpos] using Int.natCast_nonneg N
    have habs : (B p).natAbs ≤ B.support.sup (fun p => (B p).natAbs) :=
      Finset.le_sup (f := fun p => (B p).natAbs) (Finsupp.mem_support_iff.mpr hBp)
    have hb : -(B p) ≤ ((B p).natAbs : ℤ) := by
      simpa only [Int.natAbs_neg] using (show -(B p) ≤ ((-(B p)).natAbs : ℤ) from Int.le_natAbs)
    dsimp [N]
    omega
  have hNE : (N : ℤ) ≤ (N : ℤ) * E p := by
    nlinarith [Int.natCast_nonneg N]
  omega

lemma exists_generated_twist_at {D H : WeilDivisor X}
    (hD : IsCartierDivisor D) (hH : IsAmpleDivisor H) (x : X) :
    ∃ n : ℕ, IsGeneratedAt (D+n • H) x := by
  obtain ⟨U,_hU,hxU,g,hg,hDg⟩ := hD x
  obtain ⟨m,hm,s,hs,hsH,_ha,hxs,hsub⟩ := hH.2 x U hxU
  let B := principalWeilDivisor (g⁻¹)+D
  let E := principalWeilDivisor s+m • H
  have hB : ∀ p : PrimeDivisor X, p.1 ∈ U → B p = 0 := by
    intro p hp
    dsimp [B]
    rw [order_inv _ hg, hDg p hp,neg_add_cancel]
  have hE : 0 ≤ E := (divisorSection_iff_effective hs).mp hsH
  have hBE : ∀ p, E p = 0 → B p = 0 := by
    intro p hp
    apply hB p
    apply hsub
    change p.1 ∉ divisorSupport E
    exact fun h => ((prime_mem_divisorSupport_iff E p).mp h) hp
  obtain ⟨N,_hN,hpos⟩ := exists_effective_multiple_absorbing hE hBE
  let t := g⁻¹ * s^N
  have ht : t ≠ 0 := mul_ne_zero (inv_ne_zero hg) (pow_ne_zero _ hs)
  have he : principalWeilDivisor t + (D+(N*m) • H) = B+N • E := by
    dsimp [t,B,E]
    rw [principalWeilDivisor_mul (inv_ne_zero hg) (pow_ne_zero _ hs),
      principalWeilDivisor_pow hs]
    simp only [nsmul_add,smul_smul]
    abel
  refine ⟨N*m,t,ht,?_,?_⟩
  · rw [divisorSection_iff_effective ht,he]
    exact hpos
  · change x ∈ divisorComplement _
    rw [he]
    apply open_le_divisorComplement_of_coeff_zero (sectionNonvanishing (m • H) s) ?_ hxs
    intro p hp
    have hBp := hB p (hsub hp)
    have hEp : E p = 0 := coefficient_zero_on_divisorComplement E p hp
    simp only [Finsupp.add_apply,Finsupp.smul_apply,hBp,hEp,smul_zero,add_zero]

lemma eventually_generated_twist_of_generated {D H : WeilDivisor X}
    (hD : IsCartierDivisor D) (hH : IsAmpleDivisor H)
    (hgen : ∀ x : X, IsGeneratedAt H x) :
    ∃ N : ℕ, ∀ n, N ≤ n → ∀ x : X, IsGeneratedAt (D+n • H) x := by
  classical
  choose k hk using exists_generated_twist_at hD hH
  obtain ⟨V,hV⟩ := isCompact_univ.elim_finite_subcover
    (fun x : X => {y : X | IsGeneratedAt (D+k x • H) y})
    (fun x => isOpen_isGeneratedAt _) (fun x _ => Set.mem_iUnion.mpr ⟨x,hk x⟩)
  let N := V.sup k
  refine ⟨N,?_⟩
  intro n hn x
  obtain ⟨y,hyV,hxy⟩ := Set.mem_iUnion₂.mp (hV (Set.mem_univ x))
  have hkn : k y ≤ n := (Finset.le_sup hyV).trans hn
  have hg := hxy.add ((hgen x).nsmul (n-k y))
  have he : (D+k y • H)+(n-k y) • H = D+n • H := by
    rw [add_assoc,← add_nsmul,Nat.add_sub_of_le hkn]
  exact he ▸ hg

lemma eventually_generated_cartier_twist {D H : WeilDivisor X}
    (hD : IsCartierDivisor D) (hH : IsAmpleDivisor H) :
    ∃ N : ℕ, ∀ n, N ≤ n → ∀ x : X, IsGeneratedAt (D+n • H) x := by
  classical
  obtain ⟨r,hr,hgen⟩ := ample_has_generated_power hH
  have hH' : IsAmpleDivisor (r • H) := isAmpleDivisor_nsmul hH hr
  have hDj (j : Fin r) : IsCartierDivisor (D + j.1 • H) :=
    isCartierDivisor_add hD ((cartierDivisors (X := X)).nsmul_mem hH.1 _)
  choose N hN using (fun j : Fin r =>
    eventually_generated_twist_of_generated (hDj j) hH' hgen)
  let T := Finset.univ.sup N
  refine ⟨T*r,?_⟩
  intro n hn x
  let j : Fin r := ⟨n % r,Nat.mod_lt _ hr⟩
  have hT : T ≤ n/r := (Nat.le_div_iff_mul_le hr).mpr hn
  have hj : N j ≤ n/r := (Finset.le_sup (Finset.mem_univ j)).trans hT
  have hg := hN j (n/r) hj x
  have he : (D+j.1 • H)+(n/r) • (r • H) = D+n • H := by
    rw [smul_smul,add_assoc,← add_nsmul]
    dsimp [j]
    rw [Nat.mul_comm (n/r) r,Nat.mod_add_div]
  exact he ▸ hg

theorem ample_eventual_cartier_twist
    {X : Scheme} [IsIntegral X] [IsLocallyNoetherian X]
    [StalkwiseNormal X] [CompactSpace X]
    (D H : WeilDivisor X) (hD : IsCartierDivisor D) (hH : IsAmpleDivisor H) :
    ∃ N : ℕ, ∀ n, N ≤ n →
      (∀ x : X, IsGeneratedAt (D + n • H) x) ∧ IsAmpleDivisor (D + n • H) := by
  obtain ⟨N,hN⟩ := eventually_generated_cartier_twist hD hH
  refine ⟨N+1,?_⟩
  intro n hn
  refine ⟨hN n (by omega),?_⟩
  have hcart : IsCartierDivisor (D+(n-1) • H) :=
    isCartierDivisor_add hD ((cartierDivisors (X := X)).nsmul_mem hH.1 _)
  have hample := ample_add_generated hH hcart (hN (n-1) (by omega))
  have he : H+(D+(n-1) • H) = D+n • H := by
    calc
      H+(D+(n-1) • H) = D+(1+(n-1)) • H := by
        rw [add_nsmul,one_nsmul]
        abel
      _ = D+n • H := by rw [show 1+(n-1) = n by omega]
  exact he ▸ hample

end Generation
end NumericalDimensionOne

end OAI