import Mathlib
import OAI.GroupTheory.SimpleAmenable.Homology.TotalSingle

namespace OAI

section

section

open CategoryTheory Limits SimplicialObject Simplicial Opposite AlgebraicTopology
open HomologicalComplex HomologicalComplex₂
namespace BiResolution

open DiagonalResolution TotalHomotopy

noncomputable def aug₀ : total.X 0 ⟶ (Functor.const D).obj Z :=
  complex.totalDesc (fun p q hpq => eqToHom (by
    change p+q=0 at hpq
    obtain ⟨rfl,rfl⟩ := Nat.add_eq_zero_iff.mp hpq
    rfl) ≫ DiagonalResolution.augmentation.app (op ⦋0⦌))

@[reassoc (attr := simp)] lemma ι_aug₀ :
    complex.ιTotal c 0 0 0 (by simp) ≫ aug₀ =
      DiagonalResolution.augmentation.app (op ⦋0⦌) := by
  simp [aug₀,ι_totalDesc]
  change (𝟙 _) ≫ DiagonalResolution.augmentation.app (op ⦋0⦌) = _
  exact Category.id_comp _

lemma d_aug₀ : total.d 1 0 ≫ aug₀=0 := by
  change (complex.total c).d 1 0 ≫ aug₀=0
  apply HomologicalComplex₂.total.hom_ext
  intro p q hpq
  change p+q=1 at hpq
  have hpq' : (p=0 ∧ q=1) ∨ (p=1 ∧ q=0) := by omega
  rcases hpq' with ⟨rfl,rfl⟩ | ⟨rfl,rfl⟩
  all_goals
    simp only [comp_zero]
    erw [←Category.assoc]
    first | erw [ι_d_leftZero] | erw [ι_d_rightZero]
    erw [Category.assoc,ι_aug₀]
    apply NatTrans.ext
    funext d
    apply Sigma.hom_ext
    intro f
    simp [complex,chains,row,rowMap,AlternatingFaceMapComplex.objD,
      DiagonalResolution.augmentation,pre,SimplicialObject.δ]
    erw [NatTrans.comp_app,NatTrans.app_add,NatTrans.app_neg]
  · change Sigma.ι (fun _ : (⦋0⦌,⦋1⦌) ⟶ d => Z) f ≫
      ((Limits.Sigma.desc (fun index : (⦋0⦌,⦋1⦌) ⟶ d =>
        Sigma.ι (fun _ : (⦋0⦌,⦋0⦌) ⟶ d => Z)
          (Prod.mkHom index.1 (SimplexCategory.δ 0 ≫ index.2))) +
        -Limits.Sigma.desc (fun index : (⦋0⦌,⦋1⦌) ⟶ d =>
          Sigma.ι (fun _ : (⦋0⦌,⦋0⦌) ⟶ d => Z)
            (Prod.mkHom index.1 (SimplexCategory.δ 1 ≫ index.2)))) ≫
        Sigma.desc (fun _ : (⦋0⦌,⦋0⦌) ⟶ d => 𝟙 Z)) = 0
    simp [Preadditive.add_comp,Preadditive.comp_add,Preadditive.neg_comp,
      Preadditive.comp_neg]
  · change Sigma.ι (fun _ : (⦋1⦌,⦋0⦌) ⟶ d => Z) f ≫
      ((Limits.Sigma.desc (fun index : (⦋1⦌,⦋0⦌) ⟶ d =>
        Sigma.ι (fun _ : (⦋0⦌,⦋0⦌) ⟶ d => Z)
          (Prod.mkHom (SimplexCategory.δ 0 ≫ index.1) index.2)) +
        -Limits.Sigma.desc (fun index : (⦋1⦌,⦋0⦌) ⟶ d =>
          Sigma.ι (fun _ : (⦋0⦌,⦋0⦌) ⟶ d => Z)
            (Prod.mkHom (SimplexCategory.δ 1 ≫ index.1) index.2))) ≫
        Sigma.desc (fun _ : (⦋0⦌,⦋0⦌) ⟶ d => 𝟙 Z)) = 0
    simp [Preadditive.add_comp,Preadditive.comp_add,Preadditive.neg_comp,
      Preadditive.comp_neg]

noncomputable def pi : total ⟶ (ChainComplex.single₀ (D ⥤ A)).obj ((Functor.const D).obj Z) :=
  (ChainComplex.toSingle₀Equiv total ((Functor.const D).obj Z)).symm ⟨aug₀,d_aug₀⟩

@[simp] lemma pi_f_zero : pi.f 0 = aug₀ := ChainComplex.toSingle₀Equiv_symm_apply_f_zero _ _

noncomputable def evalComplexIso (d : D) :
    TotalFunctor.map₂ ((evaluation D A).obj d) complex ≅ complexAt d := by
  let E := (evaluation D A).obj d
  let F := E.mapHomologicalComplex c
  refine eqToIso ?_
  change ((alternatingFaceMapComplex (ChainComplex (D ⥤ A) ℕ) ⋙ F.mapHomologicalComplex c).obj
    (chains ⋙ alternatingFaceMapComplex (D ⥤ A))) = _
  rw [map_alternatingFaceMapComplex F]
  change AlternatingFaceMapComplex.obj (chains ⋙ alternatingFaceMapComplex (D ⥤ A) ⋙ F) = _
  rw [map_alternatingFaceMapComplex E]
  rfl

noncomputable def evalTotalIso (d : D) :
    (((evaluation D A).obj d).mapHomologicalComplex c).obj total ≅ (complexAt d).total c :=
  TotalFunctor.iso ((evaluation D A).obj d) complex ≪≫ total.mapIso (evalComplexIso d) c

end BiResolution

end

section

open CategoryTheory Limits SimplicialObject Simplicial Opposite AlgebraicTopology
open HomologicalComplex HomologicalComplex₂
namespace BiResolution

open DiagonalResolution TotalHomotopy

lemma contraction_aug (d : D) :
    (complexAt d).ιTotal c 0 0 0 (by simp) ≫ ((totalAtEquiv d).hom.f 0) =
      Sigma.desc (fun _ : (⦋0⦌,⦋0⦌) ⟶ d => 𝟙 Z) := by
  change (complexAt d).ιTotal c 0 0 0 (by simp) ≫
    (total.map (complexAtEquiv d).hom c).f 0 ≫
    (TotalHomotopy.singleIso (AlternatingFaceMapComplex.obj (point d))).hom.f 0 ≫
    (pointExtra d).homotopyEquiv.hom.f 0 = _
  rw [ιTotal_map_assoc]
  have hs : (TotalHomotopy.single (AlternatingFaceMapComplex.obj (point d))).ιTotal c 0 0 0 (by simp) ≫
      (TotalHomotopy.singleIso (AlternatingFaceMapComplex.obj (point d))).hom.f 0 = 𝟙 _ := by
    change (TotalHomotopy.singleIn _).f 0 ≫ _ = _
    have h := congrArg (fun f : AlternatingFaceMapComplex.obj (point d) ⟶ _ => f.f 0)
      (Iso.inv_hom_id (TotalHomotopy.singleIso (AlternatingFaceMapComplex.obj (point d))))
    exact h
  erw [←Category.assoc _ ((TotalHomotopy.singleIso (AlternatingFaceMapComplex.obj (point d))).hom.f 0)
    ((pointExtra d).homotopyEquiv.hom.f 0),hs,Category.id_comp]
  dsimp [complexAtEquiv,complexAtIso,pointExtra]
  simp [HomotopyEquiv.ofIso,CategoryTheory.eqToIso,HomologicalComplex.eqToHom_f,HomologicalComplex.singleMapHomologicalComplex,
    SimplicialObject.Augmented.ExtraDegeneracy.homotopyEquiv,
    extra,augmentedAt,augmentation,pointAugmented,pointAugmentation]
  apply Sigma.hom_ext
  intro f
  erw [eqToHom_refl,Category.id_comp]
  change Sigma.ι (fun _ : (⦋0⦌,⦋0⦌) ⟶ d => Z) f ≫
    Sigma.desc (fun index : (⦋0⦌,⦋0⦌) ⟶ d =>
      Sigma.ι (fun _ : ⦋0⦌ ⟶ d.2 => Z) index.2) ≫
    Sigma.desc (fun _ : ⦋0⦌ ⟶ d.2 => 𝟙 Z) =
    Sigma.ι (fun _ : (⦋0⦌,⦋0⦌) ⟶ d => Z) f ≫
      Sigma.desc (fun _ : (⦋0⦌,⦋0⦌) ⟶ d => 𝟙 Z)
  simp

lemma eval_inverse_aug (d : D) :
    (complexAt d).ιTotal c 0 0 0 (by simp) ≫ (evalTotalIso d).inv.f 0 ≫
      ((((evaluation D A).obj d).mapHomologicalComplex c).map pi).f 0 =
      Sigma.desc (fun _ : (⦋0⦌,⦋0⦌) ⟶ d => 𝟙 Z) := by
  change (complexAt d).ιTotal c 0 0 0 (by simp) ≫
    (total.map (evalComplexIso d).inv c).f 0 ≫
    TotalFunctor.comparisonF ((evaluation D A).obj d) complex 0 ≫ (pi.f 0).app d = _
  rw [ιTotal_map_assoc]
  simp only [evalComplexIso,CategoryTheory.eqToIso,HomologicalComplex.eqToHom_f]
  change _ ≫ (TotalFunctor.comparisonF ((evaluation D A).obj d) complex 0) ≫ (pi.f 0).app d = _
  erw [←Category.assoc,TotalFunctor.ι_comparisonF,pi_f_zero]
  change (complex.ιTotal c 0 0 0 (by simp)).app d ≫ aug₀.app d = _
  erw [←NatTrans.comp_app,ι_aug₀]
  rfl

instance pi_quasiIso : QuasiIso pi := by
  rw [HomologicalComplex.quasiIso_iff_evaluation]
  intro d
  let f := (((evaluation D A).obj d).mapHomologicalComplex c).map pi
  have h : (evalTotalIso d).inv ≫ f ≫ (DiagonalResolution.singleAtIso d).hom =
      (totalAtEquiv d).hom := by
    apply HomologicalComplex.to_single_hom_ext
    apply HomologicalComplex₂.total.hom_ext
    intro p q hpq
    change p+q=0 at hpq
    obtain ⟨rfl,rfl⟩ := Nat.add_eq_zero_iff.mp hpq
    simp only [HomologicalComplex.comp_f,←Category.assoc,contraction_aug]
    dsimp only [f]
    rw [Category.assoc ((complexAt d).ιTotal c 0 0 0 hpq),eval_inverse_aug]
    simp [DiagonalResolution.singleAtIso,HomologicalComplex.singleMapHomologicalComplex]
    change (Sigma.desc (fun _ : (⦋0⦌,⦋0⦌) ⟶ d => 𝟙 Z)) ≫ 𝟙 Z = _
    exact Category.comp_id _
  change QuasiIso f
  rw [←quasiIso_iff_comp_left (evalTotalIso d).inv f,
    ←quasiIso_iff_comp_right ((evalTotalIso d).inv ≫ f) (DiagonalResolution.singleAtIso d).hom,
    Category.assoc,h]
  infer_instance

noncomputable def resolution : ProjectiveResolution ((Functor.const D).obj Z) where
  complex := total
  π := pi
  quasiIso := pi_quasiIso

end BiResolution

end

section

open CategoryTheory Limits SimplicialObject Simplicial Opposite AlgebraicTopology
open HomologicalComplex HomologicalComplex₂
namespace ModelAssembly

open DiagonalResolution
variable (X : Dᵒᵖ ⥤ Type)

@[reassoc (attr := simp)] lemma pre_forward {a b : D} (k : a ⟶ b) :
    (assembly X).map (pre k) ≫ forward X a =
      forward X b ≫ (sigmaConst.obj Z).map (X.map k.op) := by
  apply colimit.hom_ext
  intro e
  apply Sigma.hom_ext
  intro f
  change Sigma.ι (fun _ : b ⟶ e.unop.1.unop => Z) f ≫
    colimit.ι (projection X ⋙ free b) e ≫
      colim.map (Functor.whiskerLeft (projection X) (pre k)) ≫ forward X a = _
  erw [colimit.ι_map_assoc]
  change Sigma.ι (fun _ : b ⟶ e.unop.1.unop => Z) f ≫
    (pre k).app e.unop.1.unop ≫ colimit.ι (projection X ⋙ free a) e ≫ forward X a = _
  erw [←Category.assoc,ι_pre,ι_to]
  erw [ι_to_assoc]
  dsimp [freeCocone,sigmaConst]
  erw [Sigma.ι_comp_desc,←Category.assoc,Sigma.ι_comp_desc,Sigma.ι_comp_map',Category.id_comp]
  congr 1
  change X.map (k ≫ f).op e.unop.2 = X.map k.op (X.map f.op e.unop.2)
  rw [op_comp,X.map_comp]
  rfl

noncomputable def models : Dᵒᵖ ⥤ (D ⥤ A) where
  obj d := free d.unop
  map f := pre f.unop
  map_id d := pre_id _
  map_comp f g := by simp only [unop_comp,pre_comp]

noncomputable def freeNatIso : models ⋙ assembly X ≅ X ⋙ sigmaConst.obj Z :=
  NatIso.ofComponents (fun d => freeIso X d.unop) (fun f => pre_forward X f.unop)

noncomputable def modelEquiv : HomotopyEquiv DiagonalResolution.complex BiResolution.total :=
  ProjectiveResolution.homotopyEquiv DiagonalResolution.resolution BiResolution.resolution

noncomputable def assembledEquiv : HomotopyEquiv
    (((assembly X).mapHomologicalComplex (ComplexShape.down ℕ)).obj DiagonalResolution.complex)
    (((assembly X).mapHomologicalComplex (ComplexShape.down ℕ)).obj BiResolution.total) :=
  (assembly X).mapHomotopyEquiv modelEquiv

end ModelAssembly

end

end

end OAI