import Mathlib
import Development.AbelianVarietyTheory.Proofs.DivisorProofs.BalTau
import Development.AbelianVarietyTheory.Proofs.AbelianSchemeLawProofs.GlobalFnsHolds
import Development.AbelianVarietyTheory.Proofs.DivisorProofs.SymmetricPullbackGeneratorSecondDifferenceStatement
import Development.AbelianVarietyTheory.Proofs.DivisorProofs.SymmetricPullbackGeneratorEvenValueStatement

open AlgebraicGeometry CategoryTheory Limits MonoidalCategory CartesianMonoidalCategory MonObj
open ReciprocityTheory.ChartRestriction.G ReciprocityTheory.ChartRestriction.G.Semi ReciprocityTheory.ChartRestriction.G.Out ReciprocityTheory.ChartRestriction.G.Geo.Tor
open scoped CategoryTheory.Obj
attribute [local instance] Over.cartesianMonoidalCategory

noncomputable section

namespace GlobalTheory.UTau0

theorem formEq_psi {R : Type} [CommRing R] [IsDomain R] (D₀ : DegPre R) (f : D₀.P.A ⟶ D₀.P.A) [IsMonHom f]
    (x x' : 𝟙_ (Over (Sp R)) ⟶ D₀.P.A) (hx : x' = x ≫ f) :
    FormEq (Sum.elim (Sum.elim (PolDeg.lamPts x x') fun k => x.left ≫ w0φ D₀ f k) fun _ : PUnit => eSec D₀.P.A)
      (Sum.elim (Sum.elim PolDeg.negε w0ε) fun _ => (-1 : ℤ)) (fun _ : PUnit => x.left) (fun _ => (-1 : ℤ)) := by
  intro U _ h
  subst hx
  have m₁ : x ≫ padd D₀.P.A (𝟙 _) f = x * (x ≫ f) := (MonObj.comp_mul _ _ _).trans (by simp)
  have m₃ : x ≫ (toUnit D₀.P.A ≫ η[D₀.P.A]) = 1 := by
    rw [← Category.assoc, toUnit_unique (x ≫ toUnit _) (toUnit _), ← Hom.one_def]
  have m₄ : (1 : 𝟙_ (Over (Sp R)) ⟶ D₀.P.A) = η[D₀.P.A] := by
    rw [Hom.one_def, toUnit_unique (toUnit _) (𝟙 _), Category.id_comp]
  have e₁ : x.left ≫ (padd D₀.P.A (𝟙 _) f).left = (x * (x ≫ f)).left := by rw [← Over.comp_left, m₁]
  have e₂ : x.left ≫ f.left = (x ≫ f).left := (Over.comp_left _ _ _ _ _).symm
  have e₃ : x.left ≫ (toUnit D₀.P.A ≫ η[D₀.P.A]).left = (1 : 𝟙_ (Over (Sp R)) ⟶ D₀.P.A).left := by
    rw [← Over.comp_left, m₃]
  have e₄ : eSec D₀.P.A = (1 : 𝟙_ (Over (Sp R)) ⟶ D₀.P.A).left := by rw [m₄]; rfl
  simp only [Fintype.prod_sum_type, Fin.prod_univ_four, Fintype.prod_unique, Sum.elim_inl, Sum.elim_inr,
    PolDeg.lamPts, PolDeg.negε, w0φ, w0ε, Matrix.cons_val_zero, Matrix.cons_val_one, Matrix.cons_val_two,
    Matrix.cons_val_three, Matrix.head_cons, Matrix.tail_cons, Category.comp_id, e₁, e₂, e₃, e₄]
  apply Additive.ofMul.injective
  simp only [ofMul_mul, ofMul_zpow]
  abel

theorem exists_psi_rLaws : ∀ (R : Type) [CommRing R] [IsDomain R] [IsLocalRing R] (D₀ : DegPre R) (O : Type) [CommRing O] [StarRing O]
    [Module O D₀.X] (onB : D₀.P.OAct O), (∀ (a : O) (y : D₀.X), D₀.c (a • y) = D₀.c y ≫ onB.act a) →
    ∀ w0 : O, w0 + star w0 = 1 → ∀ uw : LB.Gen (LB.LinComb D₀.P.L (GlobalTheory.UTau0.w0φ D₀ (onB.act w0)) GlobalTheory.UTau0.w0ε), uw.IsGen →
    LB.Gen.Corr D₀.P.L _ _ _ _ (LB.pullGen D₀.P.L _ _ uw (eSec D₀.P.A)) (LB.oneGen D₀.P.L) →
    ∀ τ' : ∀ y z : D₀.X, LB.Gen (LB.LinComb D₀.P.L (GlobalTheory.PolDeg.lamPts (D₀.c y) (D₀.c z)) GlobalTheory.PolDeg.negε),
    GlobalTheory.UTau0.BalTau ⟨D₀.P.L, D₀.rig, D₀.P.isLB, D₀.rig_gen⟩ D₀.cub onB.toRingAct D₀.c τ' →
    (∀ y z p J, Good D₀.P.L p J → val (τ' y z) (𝟙 _) p J = val (τ' z y) (𝟙 _) p J) →
    ∃ ψ : ∀ y : D₀.X, LB.Gen (LB.LinComb D₀.P.L (K := PUnit) (fun _ => (D₀.c y).left) (fun _ => -1)),
      GlobalTheory.UTau0.RLaws D₀ onB w0 uw ψ := by
  intro R _ _ _ D₀ O _ _ _ onB hc w0 hw uw huw uw0 τ' hbal hsym
  haveI := onB.hom w0
  haveI := onB.hom (star w0)
  obtain ⟨u, hu, hu0⟩ := exists_ros GlobalTheory.globalFns_holds D₀.P.isAb D₀.P.isLB (onB.act w0) (onB.act (star w0))
    (onB.rosati w0)
  have hfg : padd D₀.P.A (onB.act w0) (onB.act (star w0)) = 𝟙 _ := by
    rw [← onB.map_add, hw, onB.map_one]
  have cadd : ∀ a b, D₀.c (a + b) = D₀.c a * D₀.c b := fun a b => D₀.c_add a b
  have c0 : D₀.c 0 = 1 := by
    have := cadd 0 0
    rw [add_zero] at this
    exact mul_left_cancel (this.symm.trans (_root_.mul_one _).symm)
  have cneg : ∀ a, D₀.c (-a) = (D₀.c a)⁻¹ := fun a =>
    eq_inv_of_mul_eq_one_left (by rw [← cadd, neg_add_cancel, c0])
  let t := fun y : D₀.X => LB.mulGen D₀.P.L _ _ _ _
    (LB.mulGen D₀.P.L _ _ _ _ (τ' y (w0 • y)) (LB.pullGen D₀.P.L _ _ uw (D₀.c y).left))
    (LB.invGen D₀.P.L (fun _ : PUnit => eSec D₀.P.A) (fun _ => 1) D₀.rig)
  have ht : ∀ y, (t y).IsGen := fun y => DVR.mulGen_isGen _ _ _ _ _ _ _
    (DVR.mulGen_isGen _ _ _ _ _ _ _ (hbal.1 y _) (DVR.pullGen_isGen _ _ _ _ huw _))
    (DVR.invGen_isGen _ _ _ _ D₀.rig_gen)
  choose ψ hψ hψv using fun y => exists_gen D₀.P.isLB (formEq_psi D₀ (onB.act w0) (D₀.c y) _ (hc w0 y)) (t y) (ht y)
  have Vψ : ∀ y p J, Good D₀.P.L p J → val (ψ y) (𝟙 _) p J =
      val (τ' y (w0 • y)) (𝟙 _) p J * val uw (D₀.c y).left p J * (rigV D₀ p J)⁻¹ := by
    intro y p J hJ
    rw [hψv y _ _ p J hJ, val_mul hJ, val_mul hJ, val_inv, val_pull hJ, Category.id_comp]
    rfl
  have key : ∀ y z p J, Good D₀.P.L p J → tauV D₀ ψ p J y z = val (τ' y z) (𝟙 _) p J := by
    intro y z p J hJ
    have e1 := hbal.2.1 y z (w0 • y + w0 • z) p J hJ
    have e2 := hbal.2.2.1 y (w0 • y) (w0 • z) p J hJ
    have e3 := hbal.2.2.1 z (w0 • y) (w0 • z) p J hJ
    have e4 := hsym z (w0 • y) p J hJ
    have e5 := hbal.2.2.2 w0 u hu hu0 y z p J hJ
    have e6 := hbal.2.2.1 y (w0 • z) (star w0 • z) p J hJ
    rw [← add_smul, hw, one_smul] at e6
    have g := GlobalTheory.T.symmetricPullbackGenerator_second_difference R D₀ (onB.act w0) (onB.act (star w0)) hfg uw huw uw0 u hu hu0 _ (D₀.c y) (D₀.c z) p J hJ
    simp only [cadd, hc] at e1 e2 e3 e6
    unfold tauV
    rw [Vψ _ p J hJ, Vψ _ p J hJ, Vψ _ p J hJ, smul_add]
    simp only [cadd]
    apply Additive.ofMul.injective
    have E := fun {a b : ((𝟙_ (Over (Sp R))).left.presheaf.stalk p)ˣ} (e : a = b) => congrArg Additive.ofMul e
    have a1 := E e1; have a2 := E e2; have a3 := E e3; have a4 := E e4; have a5 := E e5; have a6 := E e6
    have b1 := E g
    simp only [ofMul_mul, ofMul_inv] at a1 a2 a3 a4 a5 a6 b1 ⊢
    linear_combination (norm := abel) a1 + a2 + a3 + b1 + a4 + a5 - a6
  refine ⟨ψ, hψ, ?_, ?_, ?_, ?_⟩
  · intro y y' z p J hJ
    rw [key _ _ p J hJ, key _ _ p J hJ, key _ _ p J hJ]
    exact hbal.2.1 y y' z p J hJ
  · intro y p J hJ
    have C := isCub_cubV D₀.cub hJ
    rw [Vψ _ p J hJ, Vψ _ p J hJ, smul_neg]
    have f1 := hbal.2.1 y (-y) (w0 • y) p J hJ
    have z1 := hbal.2.1 0 0 (w0 • y) p J hJ
    have f2 := hbal.2.2.1 (-y) (w0 • y) (-(w0 • y)) p J hJ
    have z2 := hbal.2.2.1 (-y) 0 0 p J hJ
    rw [add_neg_cancel] at f1 f2
    rw [add_zero] at z1 z2
    have g := GlobalTheory.T.symmetricPullbackGenerator_even_value R D₀ (onB.act w0) uw huw uw0 _ (D₀.c y) p J hJ
    simp only [cneg, hc, c0] at f1 z1 f2 z2 ⊢
    rw [C.face] at z1 z2
    apply Additive.ofMul.injective
    have E := fun {a b : ((𝟙_ (Over (Sp R))).left.presheaf.stalk p)ˣ} (e : a = b) => congrArg Additive.ofMul e
    have a1 := E f1; have a2 := E f2; have a3 := E z1; have a4 := E z2; have b1 := E g
    simp only [ofMul_mul, ofMul_inv, ofMul_one] at a1 a2 a3 a4 b1 ⊢
    linear_combination (norm := abel) b1 + a1 - a2 + a3 - a4
  · intro a u' hu' hu0' y z p J hJ
    rw [key _ _ p J hJ, key _ _ p J hJ]
    exact hbal.2.2.2 a u' hu' hu0' y z p J hJ
  · intro y p J hJ
    rw [key _ _ p J hJ, Vψ _ p J hJ, inv_mul_cancel_right]

end GlobalTheory.UTau0
