import OAI.Algebra.Finitistic.Ordinary.OrdinaryCochain
import Mathlib.Algebra.Category.ModuleCat.ChangeOfRings
import Mathlib.Algebra.Homology.Additive
import Mathlib.RingTheory.TensorProduct.Maps

namespace OAI
noncomputable section
open CategoryTheory
open scoped TensorProduct
namespace LittleFinitistic.OrdinarySimulation
universe u
variable {k A : Type u} [Field k] [Ring A] [Algebra k A]

/-- Forgetting to k uses the actual restriction-of-scalars functor on complexes. -/
abbrev underlyingComplex (P : CochainComplex (ModuleCat.{u} A) ℤ) :
    CochainComplex (ModuleCat.{u} k) ℤ :=
  ((ModuleCat.restrictScalars (algebraMap k A)).mapHomologicalComplex (.up ℤ)).obj P

/-- Ordinary finite compression of the actual dg A-module P on [a,a+l].
Take A=B tensor Bᵐᵒᵖ for a genuine dg B-bimodule. -/
def Compression (P : CochainComplex (ModuleCat.{u} A) ℤ) (a : ℤ) (l : ℕ) :=
  ∀ i : Fin (l+1), P.X (a + (i.val : ℤ))

namespace Compression
variable (P : CochainComplex (ModuleCat.{u} A) ℤ) (a : ℤ) (l : ℕ)
instance : AddCommGroup (Compression P a l) :=
  inferInstanceAs (AddCommGroup (∀ i : Fin (l+1), P.X (a + (i.val : ℤ))))
instance : Module k (Compression P a l) :=
  inferInstanceAs (Module k (OrdinaryTerms (intervalTerms (underlyingComplex (k := k) P) a l)))
instance : Module A (Compression P a l) :=
  inferInstanceAs (Module A (∀ i : Fin (l+1), P.X (a + (i.val : ℤ))))
instance : Module (ChainAlgebra k l) (Compression P a l) :=
  cochainModule (underlyingComplex (k := k) P) a l
instance : IsScalarTower k (ChainAlgebra k l) (Compression P a l) :=
  OrdinaryTerms.scalarTower _ _ (intervalDifferential_square (underlyingComplex (k := k) P) a l)

instance scalarTowerA : IsScalarTower k A (Compression P a l) where
  smul_assoc c r v := by
    funext i
    change (c • r) • v i = (algebraMap k A c) • r • v i
    rw [Algebra.smul_def, mul_smul]

instance : SMulCommClass (ChainAlgebra k l) A (Compression P a l) where
  smul_comm x r v := by
    let (n : ℤ) : Module k (P.X n) := Module.compHom _ (algebraMap k A)
    let (n : ℤ) : IsScalarTower k A (P.X n) := IsScalarTower.of_compHom k A (P.X n)
    let (i : Fin (l+1)) : Module A (intervalTerms (underlyingComplex (k := k) P) a l i) := inferInstanceAs (Module A (P.X (a + (i.val : ℤ))))
    let (i : Fin (l+1)) : SMulCommClass k A (intervalTerms (underlyingComplex (k := k) P) a l i) := inferInstanceAs (SMulCommClass k A (P.X (a + (i.val : ℤ))))
    change OrdinaryTerms.action (intervalTerms (underlyingComplex (k := k) P) a l) (intervalDifferential (underlyingComplex (k := k) P) a l) x (r • v) = r • OrdinaryTerms.action (intervalTerms (underlyingComplex (k := k) P) a l) (intervalDifferential (underlyingComplex (k := k) P) a l) x v
    apply OrdinaryTerms.action_commutes
    intro i j r v
    exact (P.d (a + (i.val : ℤ)) (a + (j.val : ℤ))).hom.map_smul r v

/-- The commuting actions give the actual tensor-algebra representation. -/
def tensorAction : (A ⊗[k] ChainAlgebra k l) →ₐ[k] Module.End k (Compression P a l) :=
  Algebra.TensorProduct.lift (Algebra.lsmul k k (Compression P a l))
    (Algebra.lsmul k k (Compression P a l)) (by
      intro r x
      ext v
      change r • (x • v) = x • (r • v)
      exact (smul_comm x r v).symm)

@[simp] theorem tensorAction_tmul (r : A) (x : ChainAlgebra k l) (v : Compression P a l) :
    tensorAction (k := k) P a l (r ⊗ₜ[k] x) v = r • (x • v) := rfl

instance finiteDimensional [∀ n, FiniteDimensional k ((underlyingComplex (k := k) P).X n)] :
    FiniteDimensional k (Compression P a l) :=
  inferInstanceAs (FiniteDimensional k (∀ i : Fin (l+1), (underlyingComplex (k := k) P).X (a+(i.val:ℤ))))
end Compression
end LittleFinitistic.OrdinarySimulation

end

end OAI