import Mathlib

namespace OAI

namespace PiExponent.NatToIntGrading
noncomputable section
open DirectSum
variable {M σM : Type*} [AddCommGroup M] [SetLike σM M] [AddSubgroupClass σM M]
  (𝓜 : ℕ → σM) [DirectSum.Decomposition 𝓜]

def piece : ℤ → AddSubgroup M
  | .ofNat n => AddSubgroup.ofClass (𝓜 n)
  | .negSucc _ => ⊥

def component (m : M) : ∀ d, piece 𝓜 d
  | .ofNat n => ⟨DirectSum.decompose 𝓜 m n, (DirectSum.decompose 𝓜 m n).property⟩
  | .negSucc _ => 0

def support (m : M) : Finset ℤ := by
  classical
  exact (DirectSum.decompose 𝓜 m).support.image (fun n : ℕ => (n : ℤ))

theorem component_eq_zero_of_not_mem (m : M) (d : ℤ) (hd : d ∉ support 𝓜 m) :
    component 𝓜 m d = 0 := by
  classical
  cases d with
  | ofNat n =>
      apply Subtype.ext
      have hn : n ∉ (DirectSum.decompose 𝓜 m).support := by
        intro hn
        exact hd (Finset.mem_image.mpr ⟨n, hn, rfl⟩)
      change (DirectSum.decompose 𝓜 m n : M) = 0
      rw [DFinsupp.notMem_support_iff.mp hn]
      rfl
  | negSucc n => rfl

def decompositionMap : M →+ ⨁ d, piece 𝓜 d where
  toFun m := DFinsupp.mk' (component 𝓜 m) (Trunc.mk
    ⟨(support 𝓜 m).val, fun d => by
      classical
      by_cases hd : d ∈ support 𝓜 m
      · exact Or.inl hd
      · exact Or.inr (component_eq_zero_of_not_mem 𝓜 m d hd)⟩)
  map_zero' := by
    apply DFinsupp.ext
    intro d
    apply Subtype.ext
    cases d with
    | ofNat n =>
        change (DirectSum.decompose 𝓜 (0 : M) n : M) = 0
        rw [DirectSum.decompose_zero]
        rfl
    | negSucc n => rfl
  map_add' m n := by
    apply DFinsupp.ext
    intro d
    apply Subtype.ext
    cases d with
    | ofNat k =>
        change (DirectSum.decompose 𝓜 (m + n) k : M) =
          (DirectSum.decompose 𝓜 m k : M) + (DirectSum.decompose 𝓜 n k : M)
        rw [DirectSum.decompose_add]
        rfl
    | negSucc k => exact (zero_add (0 : M)).symm

@[simp] theorem decompositionMap_nat (m : M) (n : ℕ) :
    (decompositionMap 𝓜 m (n : ℤ) : M) = (DirectSum.decompose 𝓜 m n : M) := rfl

theorem decompositionMap_injective : Function.Injective (decompositionMap 𝓜) := by
  intro m n h
  apply (DirectSum.decompose 𝓜).injective
  ext k
  exact congrArg (fun z : ⨁ d, piece 𝓜 d => (z (k : ℤ) : M)) h

theorem decompositionMap_homogeneous (d : ℤ) (m : piece 𝓜 d) :
    decompositionMap 𝓜 m.val = DirectSum.of (fun d => piece 𝓜 d) d m := by
  classical
  cases d with
  | negSucc n =>
      have hm : m = 0 := Subtype.ext m.property
      subst m
      simp
  | ofNat n =>
      apply DFinsupp.ext
      intro e
      apply Subtype.ext
      cases e with
      | negSucc k =>
          rw [DirectSum.of_eq_of_ne _ _ _ (show Int.negSucc k ≠ Int.ofNat n from by intro h; cases h)]
          rfl
      | ofNat k =>
          by_cases hnk : n = k
          · subst k
            rw [DirectSum.of_eq_same]
            exact DirectSum.decompose_of_mem_same 𝓜 m.property
          · rw [DirectSum.of_eq_of_ne _ _ _ (show Int.ofNat k ≠ Int.ofNat n from
              fun h => hnk (Int.ofNat.inj h).symm)]
            exact DirectSum.decompose_of_mem_ne 𝓜 m.property hnk

instance decomposition : DirectSum.Decomposition (piece 𝓜) := by
  have hr : (decompositionMap 𝓜).comp (DirectSum.coeAddMonoidHom (piece 𝓜)) = AddMonoidHom.id _ := by
    apply DirectSum.addHom_ext
    intro d m
    simp only [AddMonoidHom.comp_apply, DirectSum.coeAddMonoidHom_of,
      AddMonoidHom.id_apply, decompositionMap_homogeneous]
  apply DirectSum.Decomposition.ofAddHom (piece 𝓜) (decompositionMap 𝓜) ?_ hr
  apply AddMonoidHom.ext
  intro m
  apply decompositionMap_injective 𝓜
  exact DFunLike.congr_fun hr (decompositionMap 𝓜 m)

@[simp] theorem decompose_nat (m : M) (n : ℕ) :
    (DirectSum.decompose (piece 𝓜) m (n : ℤ) : M) = (DirectSum.decompose 𝓜 m n : M) := rfl

@[simp] theorem decompose_negSucc (m : M) (n : ℕ) :
    (DirectSum.decompose (piece 𝓜) m (.negSucc n) : M) = 0 := rfl

section Scalars
variable {R σR : Type*} [Ring R] [Module R M] [SetLike σR R] [AddSubgroupClass σR R]
  (𝒜 : ℕ → σR) [SetLike.GradedSMul 𝒜 𝓜]

instance gradedSMul : SetLike.GradedSMul (piece 𝒜) (piece 𝓜) where
  smul_mem := by
    intro i j a m ha hm
    cases i with
    | negSucc n =>
        have ha' : a = 0 := ha
        rw [ha', zero_smul]
        exact zero_mem _
    | ofNat n =>
        cases j with
        | negSucc k =>
            have hm' : m = 0 := hm
            rw [hm', smul_zero]
            exact zero_mem _
        | ofNat k =>
            change a • m ∈ 𝓜 (n + k)
            exact SetLike.GradedSMul.smul_mem (show a ∈ 𝒜 n from ha) (show m ∈ 𝓜 k from hm)
end Scalars

section Ring
variable {R σR : Type*} [Ring R] [SetLike σR R] [AddSubgroupClass σR R]
  (𝒜 : ℕ → σR) [SetLike.GradedMonoid 𝒜]

instance gradedMonoid : SetLike.GradedMonoid (piece 𝒜) where
  one_mem := by
    change (1 : R) ∈ 𝒜 0
    exact SetLike.GradedOne.one_mem
  mul_mem := by
    intro i j a b ha hb
    cases i with
    | negSucc n =>
        have ha' : a = 0 := ha
        rw [ha', zero_mul]
        exact zero_mem _
    | ofNat n =>
        cases j with
        | negSucc k =>
            have hb' : b = 0 := hb
            rw [hb', mul_zero]
            exact zero_mem _
        | ofNat k =>
            change a * b ∈ 𝒜 (n + k)
            exact SetLike.mul_mem_graded (show a ∈ 𝒜 n from ha) (show b ∈ 𝒜 k from hb)
end Ring

end
end PiExponent.NatToIntGrading

end OAI