import OAI.RingTheory.DirectFiniteness.IncidenceDirections

namespace OAI

universe u_1 u_2 u_3

noncomputable section
open scoped Classical BigOperators
namespace KaplanskyCounterexample.AssignedDirections
open IncidenceDirections
variable {V : Type u_1} {F : Type u_2} (Inc : F → Finset V) (ℓ : ℕ) [Fact ℓ.Prime]
variable (assign : ∀ v, {f : F // v ∈ Inc f} ≃ Option (ZMod ℓ))

def incidenceMap (v : V) (f : {f : F // v ∈ Inc f}) : ZMod ℓ →+ (Fin 2 → ZMod ℓ) :=
  (directionMap (assign v f)).toAddMonoidHom

lemma incidenceMap_injective (v : V) (f : {f : F // v ∈ Inc f}) :
    Function.Injective (incidenceMap Inc ℓ assign v f) := directionMap_injective _

lemma incidenceMap_independent (v : V) (f g : {f : F // v ∈ Inc f}) (hne : f ≠ g)
    (a b : ZMod ℓ) (h : incidenceMap Inc ℓ assign v f a + incidenceMap Inc ℓ assign v g b = 0) :
    a = 0 ∧ b = 0 := directionMap_independent ((assign v).injective.ne hne) a b h

lemma incidenceMap_covers (v : V) (a : Fin 2 → ZMod ℓ) (ha : a ≠ 0) :
    ∃ (f : F) (hf : v ∈ Inc f) (c : ZMod ℓ), c ≠ 0 ∧ incidenceMap Inc ℓ assign v ⟨f,hf⟩ c = a := by
  obtain ⟨d,c,hc,hca⟩ := directionMap_covers a ha
  obtain ⟨f,hf⟩ := (assign v).surjective d
  exact ⟨f.val,f.property,c,hc,by simpa [incidenceMap,hf] using hca⟩

end KaplanskyCounterexample.AssignedDirections

namespace KaplanskyCounterexample.AssignedDevelopment
open GluedGroup AssignedDirections IncidenceDirections
variable {V F : Type} (Inc : F → Finset V) (ℓ : ℕ) [Fact ℓ.Prime]
variable (assign : ∀ v, {f : F // v ∈ Inc f} ≃ Option (ZMod ℓ))
variable (hInc : ∀ f, (Inc f).Nonempty)

abbrev maps := AssignedDirections.incidenceMap Inc ℓ assign

lemma covers : CoversPoints Inc ℓ (maps Inc ℓ assign) :=
  AssignedDirections.incidenceMap_covers Inc ℓ assign

abbrev Base := N Inc ℓ (maps Inc ℓ assign)

def point (v : V) : PointGroup ℓ →* Base Inc ℓ assign :=
  theta Inc ℓ (maps Inc ℓ assign) (covers Inc ℓ assign) v

include hInc in
lemma point_injective
    (hg : 12 ≤ (Planar.incidenceGraph (fun v f => v ∈ Inc f)).egirth) (v : V) :
    Function.Injective (point Inc ℓ assign v) := by
  apply theta_injective _ _ _ _ hInc _ _ hg v
  · intro v f hv
    rw [totalMap_of_mem _ _ _ v f hv]
    exact AssignedDirections.incidenceMap_injective Inc ℓ assign v ⟨f, hv⟩
  · intro v f g hf hg hne a b hab
    rw [totalMap_of_mem _ _ _ v f hf, totalMap_of_mem _ _ _ v g hg] at hab
    exact (AssignedDirections.incidenceMap_independent Inc ℓ assign v ⟨f, hf⟩ ⟨g, hg⟩
      (fun h => hne (congrArg Subtype.val h)) a b hab).1

def line (f : F) : Multiplicative (ZMod ℓ) →* Base Inc ℓ assign :=
  (point Inc ℓ assign ((hInc f).choose)).comp
    (AddMonoidHom.toMultiplicative (maps Inc ℓ assign (hInc f).choose
      ⟨f, (hInc f).choose_spec⟩))

lemma point_direction (v : V) (f : F) (hf : v ∈ Inc f) (c : ZMod ℓ) :
    point Inc ℓ assign v (Multiplicative.ofAdd (maps Inc ℓ assign v ⟨f, hf⟩ c)) =
      line Inc ℓ assign hInc f (Multiplicative.ofAdd c) := by
  by_cases hc : c = 0
  · subst c
    simp
  · exact (theta_generator Inc ℓ (maps Inc ℓ assign) (covers Inc ℓ assign) v f hf c hc).trans
      (theta_generator Inc ℓ (maps Inc ℓ assign) (covers Inc ℓ assign) (hInc f).choose f (hInc f).choose_spec c hc).symm

lemma line_injective
    (hg : 12 ≤ (Planar.incidenceGraph (fun v f => v ∈ Inc f)).egirth) (f : F) :
    Function.Injective (line Inc ℓ assign hInc f) := by
  apply (point_injective Inc ℓ assign hInc hg (hInc f).choose).comp
  exact AssignedDirections.incidenceMap_injective Inc ℓ assign _ _

variable [Fintype F]

lemma subgroup_decomposition {K : Type u_3} [CommRing K] (v : V) :
    ∑ a : PointGroup ℓ, MonoidAlgebra.single (point Inc ℓ assign v a) (1 : K) =
      1 + ∑ f : {f : F // v ∈ Inc f},
        ((∑ c : Multiplicative (ZMod ℓ), MonoidAlgebra.single (line Inc ℓ assign hInc f.val c) (1 : K)) - 1) := by
  have h := sum_directions (K := ZMod ℓ) (fun a =>
    MonoidAlgebra.single (point Inc ℓ assign v (Multiplicative.ofAdd a)) (1 : K))
  rw [← Equiv.sum_comp Multiplicative.ofAdd
    (fun a : PointGroup ℓ => MonoidAlgebra.single (point Inc ℓ assign v a) (1 : K))]
  rw [h]
  simp only [ofAdd_zero, map_one, ← MonoidAlgebra.one_def]
  congr 1
  rw [← Equiv.sum_comp (assign v)
    (fun d : Option (ZMod ℓ) =>
      (∑ c : ZMod ℓ, MonoidAlgebra.single
        (point Inc ℓ assign v (Multiplicative.ofAdd (directionMap d c))) (1 : K)) - 1)]
  apply Finset.sum_congr rfl
  intro f _
  congr 1
  rw [← Equiv.sum_comp Multiplicative.ofAdd
    (fun c : Multiplicative (ZMod ℓ) => MonoidAlgebra.single (line Inc ℓ assign hInc f.val c) (1 : K))]
  apply Finset.sum_congr rfl
  intro c _
  exact congrArg (fun g => MonoidAlgebra.single g (1 : K))
    (point_direction Inc ℓ assign hInc v f.val f.property c)

end KaplanskyCounterexample.AssignedDevelopment
end

end OAI