import Mathlib
import OAI.GroupTheory.SimpleAmenable.Configurations.TrackPoint

namespace OAI

open scoped symmDiff
namespace SimpleAmenable
open scoped commutatorElement
open Classical Set CategoryTheory

structure PolygonObject (a : ℕ) where
  tracks : ℕ
  cell : Fin tracks → polygonAlgebra a

namespace PolygonObject
variable {a : ℕ}

abbrev Point (U : PolygonObject a) := {x : TrackPoint a U.tracks // x.2 ∈ (U.cell x.1).val}

structure Chart (m n : ℕ) where
  source : Fin m
  target : Fin n
  shift : CutRing × CutRing
  domain : polygonAlgebra a

namespace Chart
variable {U V W : PolygonObject a}

def Holds (c : Chart (a:=a) U.tracks V.tracks) (f : U.Point → V.Point) : Prop :=
  ∀ x∈c.domain.val, ∃hx : x∈(U.cell c.source).val,
    (f ⟨(c.source,x),hx⟩).val=(c.target,translate a c.shift x)

def Contains (c : Chart (a:=a) U.tracks V.tracks) (x : U.Point) : Prop :=
  x.val.1=c.source ∧ x.val.2∈c.domain.val

noncomputable def comp (c : Chart (a:=a) V.tracks W.tracks)
    (d : Chart (a:=a) U.tracks V.tracks) : Chart (a:=a) U.tracks W.tracks :=
  ⟨d.source,c.target,c.shift+d.shift,
    ⟨d.domain.val ∩ translate a d.shift ⁻¹' c.domain.val,
      BooleanSubalgebra.inf_mem d.domain.property (polygon_preimage_translate d.shift c.domain.property)⟩⟩

theorem comp_holds {c : Chart (a:=a) V.tracks W.tracks}
    {d : Chart (a:=a) U.tracks V.tracks} {f : V.Point → W.Point} {g : U.Point → V.Point}
    (hc : c.Holds f) (hd : d.Holds g) (hmatch : c.source=d.target) :
    (c.comp d).Holds (f ∘ g) := by
  rintro x ⟨hx,hcx⟩
  obtain ⟨hu,he⟩ := hd x hx
  obtain ⟨hv,hf⟩ := hc (translate a d.shift x) hcx
  refine ⟨hu,?_⟩
  have hp : g ⟨(d.source,x),hu⟩=⟨(c.source,translate a d.shift x),hv⟩ := by
    apply Subtype.ext
    simpa only [hmatch] using he
  change (f (g ⟨(d.source,x),hu⟩)).val=(c.target,translate a (c.shift+d.shift) x)
  rw [hp,hf,translate_add]

noncomputable def inverse (c : Chart (a:=a) U.tracks V.tracks) :
    Chart (a:=a) V.tracks U.tracks :=
  ⟨c.target,c.source,-c.shift,
    ⟨translation a c.shift '' c.domain.val,polygon_image_translation _ c.domain.property⟩⟩

theorem inverse_holds (f : U.Point ≃ V.Point) {c : Chart (a:=a) U.tracks V.tracks}
    (hc : c.Holds f) : c.inverse.Holds f.symm := by
  rintro y ⟨x,hx,rfl⟩
  obtain ⟨hu,he⟩ := hc x hx
  have hv : translate a c.shift x∈(V.cell c.target).val := by
    have h := (f ⟨(c.source,x),hu⟩).property
    rw [he] at h
    exact h
  refine ⟨hv,?_⟩
  have hp : (⟨(c.target,translate a c.shift x),hv⟩ : V.Point)=f ⟨(c.source,x),hu⟩ :=
    Subtype.ext he.symm
  change (f.symm ⟨(c.target,translate a c.shift x),hv⟩).val =
    (c.source,translate a (-c.shift) (translate a c.shift x))
  rw [hp,f.symm_apply_apply,←translate_add,neg_add_cancel,translate_zero]

end Chart

def HasTable {U V : PolygonObject a} (f : U.Point → V.Point) : Prop :=
  ∃s : Finset (Chart (a:=a) U.tracks V.tracks),
    (∀c∈s,c.Holds f) ∧ ∀x,∃c∈s,c.Contains x

theorem identity_hasTable (U : PolygonObject a) : HasTable (id : U.Point → U.Point) := by
  let c : Fin U.tracks → Chart (a:=a) U.tracks U.tracks := fun i => ⟨i,i,0,U.cell i⟩
  refine ⟨Finset.univ.image c,?_,?_⟩
  · intro d hd
    obtain ⟨i,-,rfl⟩ := Finset.mem_image.mp hd
    intro x hx
    exact ⟨hx,by change (i,x)=(i,translate a 0 x); rw [translate_zero]⟩
  · intro x
    exact ⟨c x.val.1,Finset.mem_image.mpr ⟨_,Finset.mem_univ _,rfl⟩,rfl,x.property⟩

theorem comp_hasTable {U V W : PolygonObject a} {f : V.Point → W.Point} {g : U.Point → V.Point}
    (hf : HasTable f) (hg : HasTable g) : HasTable (f ∘ g) := by
  obtain ⟨s,hs,hcover⟩ := hf
  obtain ⟨t,ht,tcover⟩ := hg
  let pairs := (s×ˢt).filter (fun cd => cd.1.source=cd.2.target)
  refine ⟨pairs.image (fun cd => cd.1.comp cd.2),?_,?_⟩
  · intro e he
    obtain ⟨⟨c,d⟩,hcd,rfl⟩ := Finset.mem_image.mp he
    obtain ⟨hmem,hmatch⟩ := Finset.mem_filter.mp hcd
    obtain ⟨hc,hd⟩ := Finset.mem_product.mp hmem
    exact Chart.comp_holds (hs c hc) (ht d hd) hmatch
  · intro x
    obtain ⟨d,hd,hx⟩ := tcover x
    obtain ⟨c,hc,hgx⟩ := hcover (g x)
    obtain ⟨hu,he⟩ := ht d hd x.val.2 hx.2
    have hxval : (⟨(d.source,x.val.2),hu⟩ : U.Point)=x := by
      apply Subtype.ext
      exact Prod.ext hx.1.symm rfl
    rw [hxval] at he
    have hmatch : c.source=d.target := by
      change (g x).val.1=c.source ∧ (g x).val.2∈c.domain.val at hgx
      rw [he] at hgx
      exact hgx.1.symm
    refine ⟨c.comp d,Finset.mem_image.mpr ⟨(c,d),?_,rfl⟩,hx.1,hx.2,?_⟩
    · exact Finset.mem_filter.mpr ⟨Finset.mem_product.mpr ⟨hc,hd⟩,hmatch⟩
    · change translate a d.shift x.val.2∈c.domain.val
      simpa only [he] using hgx.2

theorem inverse_hasTable {U V : PolygonObject a} (f : U.Point ≃ V.Point)
    (hf : HasTable f) : HasTable f.symm := by
  obtain ⟨s,hs,hcover⟩ := hf
  refine ⟨s.image Chart.inverse,?_,?_⟩
  · intro c hc
    obtain ⟨d,hd,rfl⟩ := Finset.mem_image.mp hc
    exact Chart.inverse_holds f (hs d hd)
  · intro y
    obtain ⟨c,hc,hx⟩ := hcover (f.symm y)
    obtain ⟨hu,he⟩ := hs c hc (f.symm y).val.2 hx.2
    have hp : (⟨(c.source,(f.symm y).val.2),hu⟩ : U.Point)=f.symm y := by
      apply Subtype.ext
      exact Prod.ext hx.1.symm rfl
    rw [hp,f.apply_symm_apply] at he
    refine ⟨c.inverse,Finset.mem_image.mpr ⟨c,hc,rfl⟩,?_,?_⟩
    · exact congrArg Prod.fst he
    · exact ⟨(f.symm y).val.2,hx.2,(congrArg Prod.snd he).symm⟩

structure Arrow (U V : PolygonObject a) where
  toEquiv : U.Point ≃ V.Point
  hasTable : HasTable toEquiv

@[ext] theorem Arrow.ext {U V : PolygonObject a} {f g : Arrow U V}
    (h : f.toEquiv=g.toEquiv) : f=g := by
  cases f; cases g; cases h; rfl

noncomputable instance : Groupoid (PolygonObject a) where
  Hom := Arrow
  id U := ⟨Equiv.refl _,identity_hasTable U⟩
  comp f g := ⟨f.toEquiv.trans g.toEquiv,comp_hasTable (f:=g.toEquiv) (g:=f.toEquiv) g.hasTable f.hasTable⟩
  id_comp f := Arrow.ext rfl
  comp_id f := Arrow.ext rfl
  assoc f g h := Arrow.ext rfl
  inv f := ⟨f.toEquiv.symm,inverse_hasTable f.toEquiv f.hasTable⟩
  inv_comp f := by apply Arrow.ext; exact Equiv.symm_trans_self _
  comp_inv f := by apply Arrow.ext; exact Equiv.self_trans_symm _

def Positional {U V : PolygonObject a} (f : U ⟶ V) : Prop :=
  ∀x,(f.toEquiv x).val.2=x.val.2

noncomputable def positionalSubgroupoid (a : ℕ) : Subgroupoid (PolygonObject a) where
  arrows U V := {f | Positional f}
  inv := by
    intro U V f hf y
    change (f.toEquiv.symm y).val.2=y.val.2
    have h := hf (f.toEquiv.symm y)
    simpa using h.symm
  mul := by
    intro U V W f hf g hg x
    exact (hg (f.toEquiv x)).trans (hf x)

theorem identity_positional (U : PolygonObject a) : Positional (𝟙 U) := fun _ => rfl

end PolygonObject

end SimpleAmenable

end OAI