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

namespace OAI

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

open DiagonalResolution
variable {X Y : Dᵒᵖ ⥤ Type} (φ : X ⟶ Y)
noncomputable def mapCocone (F : D ⥤ A) : Cocone (projection X ⋙ F) where
  pt := (assembly Y).obj F
  ι := {
    app e := colimit.ι (projection Y ⋙ F) (φ.mapElements.op.obj e)
    naturality e e' f := by
      simpa [projection,NatTrans.mapElements,assembly] using
        colimit.w (projection Y ⋙ F) (φ.mapElements.op.map f) }
noncomputable def assemblyMapF (F : D ⥤ A) : (assembly X).obj F ⟶ (assembly Y).obj F :=
  colimit.desc (projection X ⋙ F) (mapCocone φ F)
@[reassoc (attr := simp)] lemma ι_assemblyMapF (F : D ⥤ A) (e : X.Elementsᵒᵖ) :
    colimit.ι (projection X ⋙ F) e ≫ assemblyMapF φ F =
      colimit.ι (projection Y ⋙ F) (φ.mapElements.op.obj e) :=
  colimit.ι_desc _ _
noncomputable def assemblyMap : assembly X ⟶ assembly Y where
  app := assemblyMapF φ
  naturality F G α := by
    apply colimit.hom_ext
    intro e
    change colimit.ι (projection X ⋙ F) e ≫
      colim.map (Functor.whiskerLeft (projection X) α) ≫ assemblyMapF φ G =
      colimit.ι (projection X ⋙ F) e ≫ assemblyMapF φ F ≫
        colim.map (Functor.whiskerLeft (projection Y) α)
    erw [colimit.ι_map_assoc,ι_assemblyMapF,←Category.assoc,ι_assemblyMapF,colimit.ι_map]
    rfl
@[reassoc (attr := simp)] lemma ι_assemblyMap (F : D ⥤ A) (e : X.Elementsᵒᵖ) :
    colimit.ι (projection X ⋙ F) e ≫ (assemblyMap φ).app F =
      colimit.ι (projection Y ⋙ F) (φ.mapElements.op.obj e) :=
  ι_assemblyMapF φ F e
@[reassoc] lemma map_forward (d : D) :
    (assemblyMap φ).app (free d) ≫ forward Y d =
      forward X d ≫ (sigmaConst.obj Z).map (φ.app (op d)) := by
  apply colimit.hom_ext
  intro e
  apply Sigma.hom_ext
  intro f
  change Sigma.ι (fun _ : d ⟶ e.unop.1.unop => Z) f ≫ colimit.ι (projection X ⋙ free d) e ≫ _ = _
  erw [← Category.assoc (colimit.ι (projection X ⋙ free d) e)
    ((assemblyMap φ).app (free d)) (forward Y d), ι_assemblyMap, ι_to]
  change Sigma.ι (fun _ : d ⟶ e.unop.1.unop => Z) f ≫
    (freeCocone Y d).ι.app (φ.mapElements.op.obj e) =
    Sigma.ι (fun _ : d ⟶ e.unop.1.unop => Z) f ≫
    colimit.ι (projection X ⋙ free d) e ≫ forward X d ≫ _
  erw [← Category.assoc (colimit.ι (projection X ⋙ free d) e) (forward X d)
    ((sigmaConst.obj Z).map (φ.app (op d))), ι_to]
  dsimp only [freeCocone]
  erw [Sigma.ι_comp_desc, Sigma.ι_comp_desc_assoc]
  dsimp only [sigmaConst]
  erw [Sigma.ι_comp_map', Category.id_comp]
  congr 1
  exact (ConcreteCategory.congr_hom (φ.naturality f.op) e.unop.2).symm
end ModelAssembly

end

open CategoryTheory Limits HomologicalComplex HomologicalComplex₂
namespace TotalFunctor

universe u v u' v'
variable {C : Type u} [Category.{v} C] [Preadditive C] [HasCoproducts.{0} C]
  {E : Type u'} [Category.{v'} E] [Preadditive E] [HasCoproducts.{0} E]
open TotalHomotopy
variable {F G : C ⥤ E} [F.Additive] [G.Additive] (α : F ⟶ G)
noncomputable abbrev nat₂ (K : HomologicalComplex₂ C c c) : map₂ F K ⟶ map₂ G K :=
  ((α.mapHomologicalComplex c).mapHomologicalComplex c).app K
@[reassoc] lemma comparison_natural (K : HomologicalComplex₂ C c c) :
    total.map (nat₂ α K) c ≫ comparison G K =
      comparison F K ≫ (α.mapHomologicalComplex c).app (K.total c) := by
  apply HomologicalComplex.Hom.ext
  funext n
  apply total.hom_ext
  intro p q hpq
  change (map₂ F K).ιTotal c p q n hpq ≫ (total.map (nat₂ α K) c).f n ≫ comparisonF G K n =
    (map₂ F K).ιTotal c p q n hpq ≫ comparisonF F K n ≫ α.app _
  rw [ιTotal_map_assoc,ι_comparisonF,ι_comparisonF_assoc]
  exact (α.naturality _).symm
@[reassoc] lemma iso_natural [PreservesColimitsOfSize.{0,0} F] [PreservesColimitsOfSize.{0,0} G]
    (K : HomologicalComplex₂ C c c) :
    (α.mapHomologicalComplex c).app (K.total c) ≫ (iso G K).hom =
      (iso F K).hom ≫ total.map (nat₂ α K) c := by
  apply (cancel_mono (comparison G K)).mp
  simp only [Category.assoc]
  change _ ≫ inv (comparison G K) ≫ comparison G K =
    inv (comparison F K) ≫ total.map (nat₂ α K) c ≫ comparison G K
  rw [IsIso.inv_hom_id,Category.comp_id,comparison_natural,←Category.assoc,
    IsIso.inv_hom_id,Category.id_comp]
end TotalFunctor

end OAI