import Mathlib
import OAI.AlgebraicGeometry.RelativeTriviality.Coordinates
import OAI.AlgebraicGeometry.RelativeTriviality.Charts

namespace OAI

namespace CampanaPeternellSix.RelativeLineGlobalFunctions
noncomputable section
open CategoryTheory AlgebraicGeometry Opposite
open scoped Polynomial LaurentPolynomial
open RelativeLineCharts
universe u
variable (R : Type u) [CommRing R]
attribute [local instance] MvPolynomial.gradedAlgebra

lemma laurent_coeff_nat (p : R[X]) (n : ℕ) : p.toLaurent.coeff (n : ℤ) = p.coeff n := by
  rw [LaurentPolynomial.coeff_toLaurent]
  exact Finsupp.mapDomain_apply_of_injective Nat.castEmbedding.injective _ n

lemma laurent_coeff_neg (p : R[X]) (n : ℕ) (hn : 0 < n) :
    p.toLaurent.coeff (-(n : ℤ)) = 0 := by
  rw [LaurentPolynomial.coeff_toLaurent]
  apply Finsupp.mapDomain_of_notMem_range
  rintro ⟨i, hi⟩
  change (i : ℤ) = -(n : ℤ) at hi
  omega

lemma polynomial_overlap_constants (p q : R[X])
    (h : p.toLaurent = LaurentPolynomial.invert q.toLaurent) :
    ∃ a : R, p = Polynomial.C a ∧ q = Polynomial.C a := by
  have hc : p.coeff 0 = q.coeff 0 := by
    have := congrArg (fun z : R[T;T⁻¹] => z.coeff 0) h
    change p.toLaurent.coeff (↑(0 : ℕ)) = (LaurentPolynomial.invert q.toLaurent).coeff (↑(0 : ℕ)) at this
    rw [laurent_coeff_nat, LaurentPolynomial.invert_apply] at this
    rw [Nat.cast_zero, neg_zero] at this
    exact this.trans (laurent_coeff_nat R q 0)
  have cp : p = Polynomial.C (p.coeff 0) := by
    ext k
    by_cases hk : k = 0
    · subst k; simp
    · have he := congrArg (fun z : R[T;T⁻¹] => z.coeff (k : ℤ)) h
      rw [laurent_coeff_nat, LaurentPolynomial.invert_apply,
        laurent_coeff_neg R q k (Nat.pos_of_ne_zero hk)] at he
      simpa only [Polynomial.coeff_C, ite_eq_right hk] using he
  have cq : q = Polynomial.C (q.coeff 0) := by
    ext k
    by_cases hk : k = 0
    · subst k; simp
    · have he := congrArg (fun z : R[T;T⁻¹] => z.coeff (-(k : ℤ))) h
      rw [laurent_coeff_neg R p k (Nat.pos_of_ne_zero hk),
        LaurentPolynomial.invert_apply, neg_neg, laurent_coeff_nat] at he
      simpa only [Polynomial.coeff_C, ite_eq_right hk] using he.symm
  exact ⟨p.coeff 0, cp, by simpa [hc] using cq⟩

def scalars : R →+* Γ(RelativePolynomialEvaluation.space R 1, ⊤) :=
  ((Scheme.ΓSpecIso (.of R)).inv ≫ (RelativePolynomialEvaluation.toBase R 1).appTop).hom

lemma scalars_restrict_X (i : Fin 2) (a : R) :
    (scheme R).presheaf.map (homOfLE (show Proj.basicOpen (grading R) (MvPolynomial.X i) ≤ ⊤ from le_top)).op
        (scalars R a) =
      Proj.awayToSection (grading R) (MvPolynomial.X i)
        (HomogeneousLocalization.fromZeroRingHom (grading R) _ (constants R a)) := by
  apply Subtype.ext
  funext p
  apply HomogeneousLocalization.val_injective
  change ((((Scheme.ΓSpecIso (.of R)).inv ≫
    (RelativePolynomialEvaluation.toBase R 1).appTop) a).val ⟨p.1, trivial⟩).val = _
  rw [RelativePolynomialEvaluation.toBase_section R 1 a p.1]
  rfl

lemma scalars_left (a : R) :
    leftSectionEquiv R ((scheme R).presheaf.map (homOfLE le_top : leftOpen R ⟶ ⊤).op
      (scalars R a)) = Polynomial.C a := by
  refine (congrArg (leftSectionEquiv R) (scalars_restrict_X R 0 a)).trans ?_
  change chartEquiv R ((leftSectionsIso R).inv ((leftSectionsIso R).hom
    (algebraMap R (ChartRing R) a))) = _
  simpa using chartEquiv_constant R a

lemma scalars_right (a : R) :
    rightSectionEquiv R ((scheme R).presheaf.map (homOfLE le_top : rightOpen R ⟶ ⊤).op
      (scalars R a)) = Polynomial.C a := by
  refine (congrArg (rightSectionEquiv R) (scalars_restrict_X R 1 a)).trans ?_
  change rightChartEquiv R ((rightSectionsIso R).inv ((rightSectionsIso R).hom
    (HomogeneousLocalization.fromZeroRingHom (grading R) _ (constants R a)))) = _
  simp only [Iso.hom_inv_id_apply]
  rw [← chartSwap_constant R a]
  change chartEquiv R ((chartSwap R).symm ((chartSwap R) (algebraMap R (ChartRing R) a))) = _
  rw [RingEquiv.symm_apply_apply, chartEquiv_constant]

lemma polynomial_restrictions_agree (s : Γ(scheme R, ⊤)) :
    (leftSectionEquiv R ((scheme R).presheaf.map
      (homOfLE le_top : leftOpen R ⟶ ⊤).op s)).toLaurent =
    LaurentPolynomial.invert (rightSectionEquiv R ((scheme R).presheaf.map
      (homOfLE le_top : rightOpen R ⟶ ⊤).op s)).toLaurent := by
  rw [← (standard_section_restrictions R).1, ← (standard_section_restrictions R).2]
  congr 1

theorem scalars_bijective : Function.Bijective (scalars R) := by
  constructor
  · intro a b h
    apply Polynomial.C_injective (R := R)
    have he := congrArg (fun s => leftSectionEquiv R ((scheme R).presheaf.map
      (homOfLE le_top : leftOpen R ⟶ ⊤).op s)) h
    exact (scalars_left R a).symm.trans (he.trans (scalars_left R b))
  · intro s
    obtain ⟨a, ha, hb⟩ := polynomial_overlap_constants R _ _
      (polynomial_restrictions_agree R s)
    refine ⟨a, ?_⟩
    refine (scheme R).sheaf.eq_of_locally_eq₂
      (homOfLE le_top : leftOpen R ⟶ ⊤) (homOfLE le_top : rightOpen R ⟶ ⊤)
      (by rw [standard_cover R]) _ _ ?_ ?_
    · apply (leftSectionEquiv R).injective
      exact (scalars_left R a).trans ha.symm
    · apply (rightSectionEquiv R).injective
      exact (scalars_right R a).trans hb.symm
end
end CampanaPeternellSix.RelativeLineGlobalFunctions

end OAI