import OAI.NumberTheory.PiExponent.LocalAlgebra.FiniteGlobalPresentation

namespace OAI

namespace PiExponent.CoherentCokernels
noncomputable section
open AlgebraicGeometry CategoryTheory CategoryTheory.Limits TopologicalSpace Opposite
open PiExponent.FiniteGlobalPresentation PiExponent.CoherentAffineFinite
universe u

private def presentationOfIso (X : Scheme.{u})
    {M N : SheafOfModules.{u} X.ringCatSheaf} (e : M ≅ N)
    (P : M.Presentation) : N.Presentation := by
  let : IsIso e.hom := e.isIso_hom
  exact P.ofIsIso e.hom

def specCokernelIso {R : CommRingCat.{u}} {M N : (Spec R).Modules}
    [M.IsQuasicoherent] [N.IsQuasicoherent] (f : M ⟶ N) :
    let g := (tilde.functor R).preimage
      ((asIso M.fromTildeΓ).hom ≫ f ≫ (asIso N.fromTildeΓ).inv)
    (tilde.functor R).obj (cokernel g) ≅ cokernel f := by
  intro g
  let hm := Scheme.Modules.isIso_fromTildeΓ_of_isQuasicoherent M
  let hn := Scheme.Modules.isIso_fromTildeΓ_of_isQuasicoherent N
  let em := @asIso _ _ _ _ M.fromTildeΓ hm
  let en := @asIso _ _ _ _ N.fromTildeΓ hn
  exact PreservesCokernel.iso (tilde.functor R) g ≪≫
    cokernel.mapIso ((tilde.functor R).map g) f em en (by
        change (tilde.functor R).map ((tilde.functor R).preimage _) ≫ _ = _
        erw [Functor.map_preimage]
        exact (Category.assoc em.hom (f ≫ en.inv) en.hom).trans
          (congrArg (fun q => em.hom ≫ q)
            ((Category.assoc f en.inv en.hom).trans
              ((congrArg (fun q => f ≫ q) en.inv_hom_id).trans (Category.comp_id f)))))

theorem spec_cokernel_exists_finitePresentation {R : CommRingCat.{u}} [IsNoetherianRing R]
    {M N : (Spec R).Modules} [M.IsQuasicoherent] [N.IsQuasicoherent]
    [Module.Finite R ((modulesSpecToSheaf.obj N).obj.obj (op ⊤))] (f : M ⟶ N) :
    ∃ P : (cokernel f).Presentation, P.IsFinite := by
  let g := (tilde.functor R).preimage
    ((asIso M.fromTildeΓ).hom ≫ f ≫ (asIso N.fromTildeΓ).inv)
  have : Module.Finite R (moduleSpecΓFunctor.obj N) := inferInstanceAs
    (Module.Finite R ((modulesSpecToSheaf.obj N).obj.obj (op ⊤)))
  have : Module.Finite R (cokernel (C := ModuleCat R) g) :=
    Module.Finite.of_surjective (cokernel.π g).hom
      ((ModuleCat.epi_iff_surjective _).mp inferInstance)
  obtain ⟨P,hP⟩ := tilde_exists_finitePresentation (cokernel g)
  exact ⟨presentationOfIso (Spec R) (specCokernelIso f) P,
    ⟨⟨hP.isFiniteType_generators.finite⟩, ⟨hP.isFiniteType_relations.finite⟩⟩⟩

theorem affine_cokernel_exists_finitePresentation {X : Scheme.{u}}
    [IsAffine X] [IsLocallyNoetherian X] {M N : X.Modules}
    [M.IsQuasicoherent] [N.IsQuasicoherent] (f : M ⟶ N)
    (hN : LocallyFinitelyGenerated N) :
    ∃ P : (cokernel f).Presentation, P.IsFinite := by
  let a := X.isoSpec.inv
  let F := Scheme.Modules.restrictFunctor a
  have : IsNoetherianRing Γ(X,⊤) :=
    IsLocallyNoetherian.component_noetherian ⟨⊤, isAffineOpen_top X⟩
  have : Module.Finite Γ(X,⊤) ((modulesSpecToSheaf.obj (N.restrict a)).obj.obj (op ⊤)) :=
    spec_sections_finite_of_localGenerators (N.restrict a) (hN.restrict a)
  obtain ⟨P,hP⟩ := spec_cokernel_exists_finitePresentation (F.map f)
  let e := PreservesCokernel.iso F f
  let P' := presentationOfIso (Spec Γ(X,⊤)) e.symm P
  let b := X.isoSpec.hom
  let G : SheafOfModules (Spec Γ(X,⊤)).ringCatSheaf ⥤ SheafOfModules X.ringCatSheaf :=
    Scheme.Modules.restrictFunctor b
  let : PreservesColimitsOfSize.{u,u} G :=
    (Scheme.Modules.restrictAdjunction b).leftAdjoint_preservesColimits
  let Q := P'.map G (Scheme.Modules.restrictUnitIso b).symm
  let e₁ := (Scheme.Modules.restrictFunctorComp b a).app (cokernel f)
  have e₂ : (cokernel f).restrict (𝟙 X) ≅ ((cokernel f).restrict a).restrict b := by
    change (cokernel f).restrict (b ≫ a) ≅ ((cokernel f).restrict a).restrict b at e₁
    simpa only [b, a, Iso.hom_inv_id] using e₁
  let e₃ := e₂.symm ≪≫ Scheme.Modules.restrictFunctorId.app (cokernel f)
  exact ⟨presentationOfIso X e₃ Q,
    ⟨⟨hP.isFiniteType_generators.finite⟩, ⟨hP.isFiniteType_relations.finite⟩⟩⟩

theorem cokernel_isFinitePresentation {X : Scheme.{u}} [IsLocallyNoetherian X]
    {M N : X.Modules} [M.IsQuasicoherent] [N.IsFinitePresentation] (f : M ⟶ N) :
    (cokernel f).IsFinitePresentation := by
  apply isFinitePresentation_of_affine_presentations
  intro U
  have : IsAffine U.1.toScheme := U.2
  let F := Scheme.Modules.restrictFunctor U.1.ι
  let : N.IsQuasicoherent :=
    (SheafOfModules.IsFinitePresentation.exists_quasicoherentData N).choose.isQuasicoherent
  obtain ⟨P,hP⟩ := affine_cokernel_exists_finitePresentation (F.map f)
    ((locallyFinitelyGenerated_of_finitePresentation N).restrict U.1.ι)
  let e := PreservesCokernel.iso F f
  exact ⟨presentationOfIso U.1.toScheme e.symm P,
    ⟨⟨hP.isFiniteType_generators.finite⟩, ⟨hP.isFiniteType_relations.finite⟩⟩⟩
end
end PiExponent.CoherentCokernels

end OAI