import OAI.Algebra.Finitistic.Localization.SourceVerdier
import OAI.Algebra.Finitistic.Rectification.VertexTensorEvaluation
import OAI.Algebra.Finitistic.Localization.TensorEvaluationFunctor

namespace OAI
noncomputable section
open CategoryTheory Limits Category
namespace LittleFinitistic.ConcreteTensorEvaluation
open QuadraticEncoding
universe u
variable {k : Type u} [Field k] {d t : ℕ} {P : Relations k d t}
variable {Y : Type u} [AddCommGroup Y] [Module k Y] (X : Representation P Y)

/-- Match the opposite-regular presentation of eB to the fixed-point presentation. -/
def idealEquiv (e : B P) (he : e*e=e) :
    VertexProjectives.ideal e ≃ₗ[(B P)ᵐᵒᵖ] IdempotentTensor.rightIdeal e where
  toFun x := ⟨x.val.unop, by
    exact congrArg MulOpposite.unop (VertexProjectives.fixed e he x)⟩
  invFun x := ⟨MulOpposite.op x.val, ⟨MulOpposite.op x.val, by
    change MulOpposite.op x.val * MulOpposite.op e = MulOpposite.op x.val
    exact congrArg MulOpposite.op x.property⟩⟩
  left_inv x := by rfl
  right_inv x := by rfl
  map_add' x y := rfl
  map_smul' a x := rfl

section TensorCongr
variable {A : Type u} [Ring A] [Algebra k A]
variable {M M' N : Type u} [AddCommGroup M] [AddCommGroup M'] [AddCommGroup N]
variable [Module k M] [Module k M'] [Module k N]
variable [Module Aᵐᵒᵖ M] [Module Aᵐᵒᵖ M'] [Module A N]
variable [IsScalarTower k Aᵐᵒᵖ M] [IsScalarTower k Aᵐᵒᵖ M']

/-- Balanced tensor respects actual right-module equivalences. -/
def tensorCongr (e : M ≃ₗ[Aᵐᵒᵖ] M') :
    BalancedTensor.Tensor k A M N ≃ₗ[k] BalancedTensor.Tensor k A M' N where
  __ := BalancedTensor.mapLeft (k := k) N e.toLinearMap
  invFun := BalancedTensor.mapLeft (k := k) N e.symm.toLinearMap
  left_inv z := by
    change BalancedTensor.mapLeft (k := k) N e.symm.toLinearMap
      (BalancedTensor.mapLeft (k := k) N e.toLinearMap z) = z
    induction z using BalancedTensor.induction_on with
    | hz => simp
    | ht m n => simp
    | ha a b ha hb =>
      simp only [map_add]
      exact congrArg₂ (· + ·) ha hb
  right_inv z := by
    change BalancedTensor.mapLeft (k := k) N e.toLinearMap
      (BalancedTensor.mapLeft (k := k) N e.symm.toLinearMap z) = z
    induction z using BalancedTensor.induction_on with
    | hz => simp
    | ht m n => simp
    | ha a b ha hb =>
      simp only [map_add]
      exact congrArg₂ (· + ·) ha hb
end TensorCongr

/-- Actual tensor evaluation on projectives. -/
abbrev moduleEvaluation : SourceVerdier.Proj P ⥤ ModuleCat.{u} k :=
  (ProjectiveComplexes.finiteProjective (B P)).ι ⋙
    BalancedTensor.tensorFunctor k (B P) X.Evaluation

instance vertexScalarTower (i : Fin 3) :
    IsScalarTower k (B P)ᵐᵒᵖ (BalancedTensor.ScalarModule k (B P) (SourceVerdier.E P i).obj) :=
  BalancedTensor.scalarModuleTower k (B P) (SourceVerdier.E P i).obj

/-- The exact natural vertex identification E_i tensor_B M(Y) = Y. -/
def vertexIso (i : Fin 3) : (moduleEvaluation X).obj (SourceVerdier.E P i) ≅ ModuleCat.of k Y :=
  ((@tensorCongr k _ (B P) _ _
    (BalancedTensor.ScalarModule k (B P) (SourceVerdier.E P i).obj)
    (IdempotentTensor.rightIdeal (SourceVerdier.vertex P i)) X.Evaluation
    _ _ _ (BalancedTensor.ScalarModule k (B P) (SourceVerdier.E P i).obj).isModule _ _
    _ _ _ (vertexScalarTower (P := P) i) inferInstance
    (idealEquiv (SourceVerdier.vertex P i) (SourceVerdier.vertex_idem P i))).trans
      (X.vertexTensorEquiv i)).toModuleIso

@[simp] theorem vertexIso_mk (i : Fin 3)
    (m : BalancedTensor.ScalarModule k (B P) (SourceVerdier.E P i).obj) (y : X.Evaluation) :
    (vertexIso X i).hom.hom
      (BalancedTensor.mk k (B P) _ X.Evaluation m y) = X.projection i (m.val.unop • y) := rfl

/-- The two actual identity-arrow tensor maps become identities on Y. -/
theorem s_naturality :
    (moduleEvaluation X).map (SourceVerdier.arrow01 P 0) ≫ (vertexIso X 1).hom =
      (vertexIso X 0).hom := by
  apply ModuleCat.hom_ext
  apply BalancedTensor.ext
  intro m y
  change X.projection 1 ((m.val * MulOpposite.op (QuadraticEncoding.arrow01 P 0)).unop • y) =
    X.projection 0 (m.val.unop • y)
  rw [MulOpposite.unop_mul, MulOpposite.unop_op, mul_smul, X.arrow01_smul]
  simp [Representation.projection]

theorem s'_naturality :
    (moduleEvaluation X).map (SourceVerdier.arrow12 P 0) ≫ (vertexIso X 2).hom =
      (vertexIso X 1).hom := by
  apply ModuleCat.hom_ext
  apply BalancedTensor.ext
  intro m y
  change X.projection 2 ((m.val * MulOpposite.op (QuadraticEncoding.arrow12 P 0)).unop • y) =
    X.projection 1 (m.val.unop • y)
  rw [MulOpposite.unop_mul, MulOpposite.unop_op, mul_smul, X.arrow12_smul]
  simp [Representation.projection]

instance s_inverted : IsIso ((moduleEvaluation X).map (SourceVerdier.arrow01 P 0)) := by
  have : IsIso ((moduleEvaluation X).map (SourceVerdier.arrow01 P 0) ≫ (vertexIso X 1).hom) := by
    rw [s_naturality]
    infer_instance
  exact IsIso.of_isIso_comp_right _ (vertexIso X 1).hom

instance s'_inverted : IsIso ((moduleEvaluation X).map (SourceVerdier.arrow12 P 0)) := by
  have : IsIso ((moduleEvaluation X).map (SourceVerdier.arrow12 P 0) ≫ (vertexIso X 2).hom) := by
    rw [s'_naturality]
    infer_instance
  exact IsIso.of_isIso_comp_right _ (vertexIso X 2).hom

end LittleFinitistic.ConcreteTensorEvaluation

end

end OAI