import OAI.Algebra.Finitistic.Bimodule.BimoduleBalancedTensor

namespace OAI
noncomputable section
open CategoryTheory
open scoped TensorProduct ModuleCat.Algebra
namespace LittleFinitistic.BimoduleBalancedTensor
open ExternalTensor.Section4
attribute [local instance] inputEnveloping
universe u
variable (k B : Type u) [Field k] [Ring B] [Algebra k B]
variable (M : ModuleCat.{u} (Enveloping k B))
variable (N : Type u) [AddCommGroup N] [Module k N] [Module B N]

theorem algebraMap_smul (c : k) (x : Tensor k B M N) :
    algebraMap k B c • x = c • x := by
  induction x using BalancedTensor.induction_on with
  | hz => simp
  | ht m n =>
    rw [smul_mk]
    have he : (algebraMap k B c ⊗ₜ[k] (1 : Bᵐᵒᵖ)) =
        algebraMap k (Enveloping k B) c :=
      (Algebra.TensorProduct.includeLeft : B →ₐ[k] Enveloping k B).commutes c
    rw [he]
    have hm : algebraMap k (Enveloping k B) c • (m : M) = (c • m : Input k B M) := by
      change algebraMap k (Enveloping k B) c • (m : M) =
        BimoduleVertex.restriction k B (algebraMap k Bᵐᵒᵖ c) • (m : M)
      rw [show BimoduleVertex.restriction k B (algebraMap k Bᵐᵒᵖ c) =
        algebraMap k (Enveloping k B) c from
        (Algebra.TensorProduct.includeRight : Bᵐᵒᵖ →ₐ[k] Enveloping k B).commutes c]
    rw [hm]
    exact LinearMap.congr_fun ((BalancedTensor.mk k B (Input k B M) N).map_smul c m) n
  | ha x y hx hy => simp_all [smul_add]

instance scalarTower : IsScalarTower k B (Tensor k B M N) :=
  IsScalarTower.of_algebraMap_smul (algebraMap_smul k B M N)

variable {M} {M' : ModuleCat.{u} (Enveloping k B)}
/-- A genuine bimodule map induces a map preserving the full left B action after tensoring. -/
def map (f : M ⟶ M') : Tensor k B M N →ₗ[B] Tensor k B M' N where
  __ := (BalancedTensor.mapLeft (k := k) N ((forgetRight k B).map f).hom).toAddMonoidHom
  map_smul' b x := by
    induction x using BalancedTensor.induction_on with
    | hz =>
      rw [smul_zero]
      exact (map_zero _).trans
        ((congrArg (b • ·) (map_zero _)).trans (smul_zero b)).symm
    | ht m n =>
      change BalancedTensor.mk k B (Input k B M') N (f.hom
        ((b ⊗ₜ[k] (1 : Bᵐᵒᵖ)) • (m : M))) n =
        BalancedTensor.mk k B (Input k B M') N
          ((b ⊗ₜ[k] (1 : Bᵐᵒᵖ)) • f.hom m) n
      exact congrArg (fun m' => BalancedTensor.mk k B (Input k B M') N m' n)
        (f.hom.map_smul (b ⊗ₜ[k] (1 : Bᵐᵒᵖ)) (m : M))
    | ha x y hx hy =>
      rw [smul_add]
      exact (map_add _ _ _).trans ((congrArg₂ (· + ·) hx hy).trans
        ((smul_add b _ _).symm.trans (congrArg (b • ·) (map_add _ _ _).symm)))

/-- The actual balanced tensor functor from bimodules to left modules. -/
def functor : ModuleCat.{u} (Enveloping k B) ⥤ ModuleCat.{u} B where
  obj M := ModuleCat.of B (Tensor k B M N)
  map f := ModuleCat.ofHom (map k B N f)
  map_id M := by
    apply ModuleCat.hom_ext
    apply LinearMap.ext
    intro x
    induction x using BalancedTensor.induction_on with
    | hz => simp
    | ht m n => rfl
    | ha x y hx hy =>
      exact (map_add _ _ _).trans
        ((congrArg₂ (· + ·) hx hy).trans (map_add _ _ _).symm)
  map_comp f g := by
    apply ModuleCat.hom_ext
    apply LinearMap.ext
    intro x
    induction x using BalancedTensor.induction_on with
    | hz => simp
    | ht m n => rfl
    | ha x y hx hy =>
      exact (map_add _ _ _).trans
        ((congrArg₂ (· + ·) hx hy).trans (map_add _ _ _).symm)

instance additive : (functor k B N).Additive where
  map_add := by
    intros M M' f g
    apply ModuleCat.hom_ext
    apply LinearMap.ext
    intro x
    induction x using BalancedTensor.induction_on with
    | hz =>
      exact (map_zero _).trans (map_zero _).symm
    | ht m n =>
      change BalancedTensor.mk k B (Input k B M') N (f.hom m + g.hom m) n = _
      exact LinearMap.congr_fun ((BalancedTensor.mk k B (Input k B M') N).map_add _ _) n
    | ha x y hx hy =>
      exact (map_add _ _ _).trans
        ((congrArg₂ (· + ·) hx hy).trans (map_add _ _ _).symm)
end LittleFinitistic.BimoduleBalancedTensor

end

end OAI