import Mathlib
import OAI.AlgebraicGeometry.RelativeTriviality.ResidueIsomorphism

namespace OAI

noncomputable section

namespace CampanaPeternellSix.RelativeCech
section
open CategoryTheory AlgebraicGeometry TopologicalSpace Opposite
open Scheme.Modules
universe u
variable {X : Scheme.{u}} {F E : X.Modules} (φ : F ⟶ E)
def isoLocus : X.Opens :=
  ⨆ (U : X.Opens) (_ : ∀ V : X.Opens, V ≤ U → Function.Bijective (φ.app V)), U
lemma mem_isoLocus (x : X) : x ∈ isoLocus φ ↔
    ∃ U : X.Opens, x ∈ U ∧ ∀ V : X.Opens, V ≤ U → Function.Bijective (φ.app V) := by
  simp only [isoLocus, Opens.mem_iSup]
  aesop
lemma isIso_of_local_bijective
    (h : ∀ x : X, ∃ U : X.Opens, x ∈ U ∧
      ∀ V : X.Opens, V ≤ U → Function.Bijective (φ.app V)) : IsIso φ := by
  choose U hx hU using h
  have hc : (Opens.grothendieckTopology X).CoversTop U := by
    rw [Opens.coversTop_iff]
    exact top_unique (fun x _ => Opens.mem_iSup.mpr ⟨x, hx x⟩)
  let ψ := (SheafOfModules.toSheaf X.ringCatSheaf).map φ
  have hp : IsIso ψ := by
    apply CategoryTheory.Sheaf.isIso_of_coversTop hc
    intro x
    rw [← ObjectProperty.isIso_hom_iff, NatTrans.isIso_iff_isIso_app]
    intro V
    rw [ConcreteCategory.isIso_iff_bijective]
    exact hU x V.unop.left (leOfHom V.unop.hom)
  have : IsIso ((toPresheaf X).map φ) := by
    exact (sheafToPresheaf _ _).map_isIso ψ
  exact isIso_of_reflects_iso φ (toPresheaf X)
end

section
open CategoryTheory AlgebraicGeometry TopologicalSpace Opposite
open Scheme.Modules
universe u
lemma isIso_restrict_of_range_in_isoLocus {X Y : Scheme.{u}} (f : X ⟶ Y)
    [IsOpenImmersion f] {F E : Y.Modules} (φ : F ⟶ E)
    (h : ∀ x : X, f x ∈ isoLocus φ) : IsIso ((restrictFunctor f).map φ) := by
  apply isIso_of_local_bijective
  intro x
  obtain ⟨U, hx, hU⟩ := (mem_isoLocus φ (f x)).mp (h x)
  refine ⟨f ⁻¹ᵁ U, hx, ?_⟩
  intro V hV
  change Function.Bijective (φ.app (f ''ᵁ V))
  apply hU
  rintro y ⟨z, hz, rfl⟩
  exact hV hz
lemma isIso_pullback_isoLocus {X : Scheme.{u}} {F E : X.Modules} (φ : F ⟶ E) :
    IsIso ((pullback (isoLocus φ).ι).map φ) := by
  have := isIso_restrict_of_range_in_isoLocus (isoLocus φ).ι φ (fun x => x.property)
  exact (NatIso.isIso_map_iff (restrictFunctorIsoPullback (isoLocus φ).ι) φ).mp inferInstance
end

section
open CategoryTheory AlgebraicGeometry TopologicalSpace Opposite
open Scheme.Modules
universe u
lemma isIso_pullback_of_range_in_isoLocus {X Y : Scheme.{u}} (f : X ⟶ Y)
    {F E : Y.Modules} (φ : F ⟶ E) (h : ∀ x : X, f x ∈ isoLocus φ) :
    IsIso ((pullback f).map φ) := by
  let U := isoLocus φ
  have hr : Set.range f ⊆ Set.range U.ι := by
    rintro y ⟨x, rfl⟩
    exact ⟨⟨f x, h x⟩, rfl⟩
  let g := IsOpenImmersion.lift U.ι f hr
  have hg : g ≫ U.ι = f := IsOpenImmersion.lift_fac _ _ _
  have := isIso_pullback_isoLocus φ
  have : IsIso (((pullback U.ι) ⋙ pullback g).map φ) :=
    Functor.map_isIso (pullback g) _
  rw [← hg]
  exact (NatIso.isIso_map_iff (pullbackComp g U.ι) φ).mp inferInstance
end

section
open CategoryTheory AlgebraicGeometry TopologicalSpace Opposite
open Scheme.Modules
universe u
lemma affine_field_point_mem_isoLocus {R : CommRingCat.{u}} {K : Type u} [Field K]
    {F E : (Spec R).Modules} [F.IsQuasicoherent] [E.IsQuasicoherent]
    [Module.Finite R (moduleSpecΓFunctor.obj F)]
    [Module.Flat R (moduleSpecΓFunctor.obj F)]
    [Module.FinitePresentation R (moduleSpecΓFunctor.obj E)]
    [Module.Flat R (moduleSpecΓFunctor.obj E)]
    (φ : F ⟶ E) (g : Spec (.of K) ⟶ Spec R)
    [IsIso ((pullback g).map φ)] : g default ∈ isoLocus φ := by
  obtain ⟨a, rfl⟩ := Spec.map_surjective g
  let : Algebra R K := a.hom.toAlgebra
  have hbij := affine_baseChange_bijective_of_isIso_pullback K φ
  let p : PrimeSpectrum R := Spec.map a default
  have hp : p.asIdeal = RingHom.ker (algebraMap R K) := rfl
  have hres := residue_bijective_of_field_bijective (moduleSpecΓFunctor.map φ).hom
    p.asIdeal hp hbij
  obtain ⟨r, hr, hU⟩ := affine_exists_basicOpen_bijective φ p hres
  exact (mem_isoLocus φ p).mpr ⟨PrimeSpectrum.basicOpen r, hr, hU⟩
end

section
open CategoryTheory AlgebraicGeometry TopologicalSpace Opposite
open Scheme.Modules
universe u
lemma mem_isoLocus_of_mem_restrict {X Y : Scheme.{u}} (f : X ⟶ Y)
    [IsOpenImmersion f] {F E : Y.Modules} (φ : F ⟶ E) (x : X)
    (hx : x ∈ isoLocus ((restrictFunctor f).map φ)) : f x ∈ isoLocus φ := by
  obtain ⟨U, hxU, hU⟩ := (mem_isoLocus _ x).mp hx
  apply (mem_isoLocus φ (f x)).mpr
  refine ⟨f ''ᵁ U, ⟨x, hxU, rfl⟩, ?_⟩
  intro W hW
  have hpre : f ⁻¹ᵁ W ≤ U := by
    intro z hz
    obtain ⟨w, hw, he⟩ := hW hz
    exact f.isOpenEmbedding.injective he ▸ hw
  have he : f ''ᵁ (f ⁻¹ᵁ W) = W := by
    ext y
    constructor
    · rintro ⟨z, hz, rfl⟩; exact hz
    · intro hy
      obtain ⟨z, hz, rfl⟩ := hW hy
      exact ⟨z, hy, rfl⟩
  have hh := hU (f ⁻¹ᵁ W) hpre
  change Function.Bijective (φ.app (f ''ᵁ (f ⁻¹ᵁ W))) at hh
  rwa [he] at hh
end

section
open CategoryTheory AlgebraicGeometry Opposite
open Scheme.Modules
universe u
lemma flat_affine_sections {R : CommRingCat.{u}} (E : (Spec R).Modules)
    (hE : ∃ q : E.LocalGeneratorsData, q.IsLocallyFreeData ∧ q.IsFiniteType) :
    Module.Flat R (moduleSpecΓFunctor.obj E) := by
  have := flat_affine_restriction R (Spec R) E hE (𝟙 _)
  exact Module.Flat.of_linearEquiv
    (moduleSpecΓFunctor.mapIso (restrictFunctorId.app E)).toLinearEquiv.symm
lemma finitePresentation_affine_sections {R : CommRingCat.{u}} (E : (Spec R).Modules)
    (hE : ∃ q : E.LocalGeneratorsData, q.IsLocallyFreeData ∧ q.IsFiniteType) :
    Module.FinitePresentation R (moduleSpecΓFunctor.obj E) := by
  have := finitePresentation_affine_restriction R (Spec R) E hE (𝟙 _)
  exact Module.FinitePresentation.of_equiv
    (moduleSpecΓFunctor.mapIso (restrictFunctorId.app E)).toLinearEquiv
end

section
open CategoryTheory AlgebraicGeometry TopologicalSpace Opposite
open Scheme.Modules
universe u
lemma field_point_mem_isoLocus {X : Scheme.{u}} {K : Type u} [Field K]
    {F E : X.Modules}
    (hF : ∃ q : F.LocalGeneratorsData, q.IsLocallyFreeData ∧ q.IsFiniteType)
    (hE : ∃ q : E.LocalGeneratorsData, q.IsLocallyFreeData ∧ q.IsFiniteType)
    (φ : F ⟶ E) (g : Spec (.of K) ⟶ X)
    [IsIso ((pullback g).map φ)] : g default ∈ isoLocus φ := by
  obtain ⟨qF, hqF, htF⟩ := hF
  obtain ⟨qE, hqE, htE⟩ := hE
  let := hqF
  let := htF
  let := qF.isLocallyFree
  let := hqE
  let := htE
  let := qE.isLocallyFree
  have : F.IsQuasicoherent := qF.quasiCoherentData.isQuasicoherent
  have : E.IsQuasicoherent := qE.quasiCoherentData.isQuasicoherent
  obtain ⟨R, f, hf, y, hy⟩ := X.exists_Spec_apply_eq (g default)
  let := hf
  have hr : Set.range g ⊆ Set.range f := by
    rintro z ⟨t, rfl⟩
    refine ⟨y, ?_⟩
    simpa only [Subsingleton.elim t (default : Spec (.of K))] using hy
  let g' := IsOpenImmersion.lift f g hr
  have hg : g' ≫ f = g := IsOpenImmersion.lift_fac _ _ _
  have : IsIso ((pullback (g' ≫ f)).map φ) := by rw [hg]; infer_instance
  have : IsIso (((pullback f) ⋙ pullback g').map φ) :=
    (NatIso.isIso_map_iff (pullbackComp g' f) φ).mpr inferInstance
  have : IsIso ((pullback g').map ((restrictFunctor f).map φ)) :=
    (NatIso.isIso_map_iff (Functor.isoWhiskerRight (restrictFunctorIsoPullback f) (pullback g')) φ).mpr
      inferInstance
  have := flat_affine_restriction R X F ⟨qF, hqF, htF⟩ f
  have := flat_affine_restriction R X E ⟨qE, hqE, htE⟩ f
  have := finitePresentation_affine_restriction R X F ⟨qF, hqF, htF⟩ f
  have := finitePresentation_affine_restriction R X E ⟨qE, hqE, htE⟩ f
  have hm := affine_field_point_mem_isoLocus ((restrictFunctor f).map φ) g'
  have hn := mem_isoLocus_of_mem_restrict f φ (g' default) hm
  convert hn using 1
  exact congrArg (fun h : Spec (.of K) ⟶ X => h default) hg.symm
end

section
open CategoryTheory AlgebraicGeometry TopologicalSpace
universe u
 

lemma exists_basicOpen_preimage_le {R : CommRingCat.{u}} {X : Scheme.{u}}
    (f : X ⟶ Spec R) [UniversallyClosed f] (p : PrimeSpectrum R)
    (U : X.Opens) (hp : ∀ x : X, f x = p → x ∈ U) :
    ∃ r : R, r ∉ p.asIdeal ∧ f ⁻¹ᵁ (PrimeSpectrum.basicOpen r) ≤ U := by
  let V : (Spec R).Opens := ⟨(f '' (U : Set X)ᶜ)ᶜ,
    (f.isClosedMap _ U.isOpen.isClosed_compl).isOpen_compl⟩
  have hpV : p ∈ V := by
    rintro ⟨x, hx, hxp⟩
    exact hx (hp x hxp)
  obtain ⟨W, ⟨r, rfl⟩, hr, hV⟩ :=
    PrimeSpectrum.isTopologicalBasis_basic_opens.exists_subset_of_mem_open hpV V.isOpen
  refine ⟨r, hr, ?_⟩
  intro x hx
  by_contra hn
  exact hV hx ⟨x, hn, rfl⟩
end

open CategoryTheory AlgebraicGeometry TopologicalSpace Opposite Limits
open Scheme.Modules
universe u
lemma residueSpecMap_apply (R : CommRingCat.{u}) (p : PrimeSpectrum R)
    (t : Spec (.of p.asIdeal.ResidueField)) :
    Spec.map (CommRingCat.ofHom (algebraMap R p.asIdeal.ResidueField)) t = p := by
  apply PrimeSpectrum.ext
  change Ideal.comap (algebraMap R p.asIdeal.ResidueField) t.asIdeal = p.asIdeal
  rw [Subsingleton.elim t (⊥ : PrimeSpectrum p.asIdeal.ResidueField)]
  exact Ideal.ker_algebraMap_residueField _
lemma fiber_mem_isoLocus {R : CommRingCat.{u}} {X : Scheme.{u}}
    (f : X ⟶ Spec R) {F E : X.Modules}
    (hF : ∃ q : F.LocalGeneratorsData, q.IsLocallyFreeData ∧ q.IsFiniteType)
    (hE : ∃ q : E.LocalGeneratorsData, q.IsLocallyFreeData ∧ q.IsFiniteType)
    (p : PrimeSpectrum R) (φ : F ⟶ E)
    [IsIso ((Scheme.Modules.pullback (Limits.pullback.fst f
      (Spec.map (CommRingCat.ofHom (algebraMap R p.asIdeal.ResidueField))))).map φ)]
    (x : X) (hx : f x = p) : x ∈ isoLocus φ := by
  let k := Spec.map (CommRingCat.ofHom (algebraMap R p.asIdeal.ResidueField))
  let P := Limits.pullback f k
  have hx' : x ∈ Set.range (Limits.pullback.fst f k) := by
    rw [Scheme.Pullback.range_fst]
    exact ⟨default, (residueSpecMap_apply R p _).trans hx.symm⟩
  obtain ⟨y, hy⟩ := hx'
  let g : Spec (P.residueField y) ⟶ X := P.fromSpecResidueField y ≫ Limits.pullback.fst f k
  have : IsIso ((Scheme.Modules.pullback (Limits.pullback.fst f k)).map φ) := inferInstance
  have hpb : IsIso ((Scheme.Modules.pullback (P.fromSpecResidueField y)).map
      ((Scheme.Modules.pullback (Limits.pullback.fst f k)).map φ)) :=
    Functor.map_isIso (Scheme.Modules.pullback (P.fromSpecResidueField y)) _
  have : IsIso ((Scheme.Modules.pullback g).map φ) :=
    (NatIso.isIso_map_iff (pullbackComp _ _) φ).mp hpb
  have hh := field_point_mem_isoLocus (K := P.residueField y) hF hE φ g
  have hgpt (t : Spec (P.residueField y)) : g t = x := by
    change (Limits.pullback.fst f k) ((P.fromSpecResidueField y) t) = x
    rw [Scheme.fromSpecResidueField_apply]
    exact hy
  exact Eq.mp (congrArg (fun z : X => z ∈ isoLocus φ) (hgpt _)) hh
lemma isIso_near_fiber_proper {R : CommRingCat.{u}} {X : Scheme.{u}}
    (f : X ⟶ Spec R) [UniversallyClosed f] {F E : X.Modules}
    (hF : ∃ q : F.LocalGeneratorsData, q.IsLocallyFreeData ∧ q.IsFiniteType)
    (hE : ∃ q : E.LocalGeneratorsData, q.IsLocallyFreeData ∧ q.IsFiniteType)
    (p : PrimeSpectrum R) (φ : F ⟶ E)
    [IsIso ((Scheme.Modules.pullback (Limits.pullback.fst f
      (Spec.map (CommRingCat.ofHom (algebraMap R p.asIdeal.ResidueField))))).map φ)] :
    ∃ r : R, r ∉ p.asIdeal ∧ IsIso ((Scheme.Modules.pullback
      (Limits.pullback.fst f (Spec.map (CommRingCat.ofHom
        (algebraMap R (Localization.Away r)))))).map φ) := by
  obtain ⟨r, hr, hU⟩ := exists_basicOpen_preimage_le f p (isoLocus φ)
    (fiber_mem_isoLocus f hF hE p φ)
  refine ⟨r, hr, isIso_pullback_of_range_in_isoLocus _ φ ?_⟩
  intro x
  apply hU
  have hx : f (Limits.pullback.fst f (Spec.map (CommRingCat.ofHom
      (algebraMap R (Localization.Away r)))) x) ∈
      Set.range (PrimeSpectrum.comap (algebraMap R (Localization.Away r))) := by
    let a := Spec.map (CommRingCat.ofHom (algebraMap R (Localization.Away r)))
    refine ⟨Limits.pullback.snd f a x, ?_⟩
    exact congrArg (fun h : Limits.pullback f a ⟶ Spec R => h x)
      (Limits.pullback.condition (f := f) (g := a)).symm
  rwa [PrimeSpectrum.localization_away_comap_range (Localization.Away r) r] at hx
end CampanaPeternellSix.RelativeCech

end

end OAI