import Mathlib
import OAI.Geometry.HyperbolicGroups.BoundaryList

namespace OAI

section
section


noncomputable section
namespace HyperbolicObstruction.PictureSwitch
open Equiv Equiv.Perm
attribute [local instance] Classical.propDecidable
variable {D S L : Type*} [DecidableEq D]

/-- A literal indexed match between two enumerated boundaries. Repeated
edge letters are not quotiented: this map uses the unique side positions. -/
def boundaryIndex (xs : List D) (ys : List S) (hlen : xs.length = ys.length)
    (x : D) (hx : x ∈ xs) : S :=
  ys[xs.idxOf x]'(by rw [← hlen]; exact List.idxOf_lt_length_iff.mpr hx)

lemma boundaryIndex_get (xs : List D) (ys : List S) (hn : xs.Nodup)
    (hlen : xs.length = ys.length) (i : ℕ) (hi : i < xs.length) :
    boundaryIndex xs ys hlen xs[i] (List.getElem_mem hi) = ys[i]'(by omega) := by
  have hh : xs.idxOf xs[i] < xs.length := List.idxOf_lt_length_iff.mpr (List.getElem_mem hi)
  have he : xs.idxOf xs[i] = i := hn.getElem_inj_iff.mp (List.getElem_idxOf hh)
  simp only [boundaryIndex,he]

lemma boundaryIndex_label (xs : List D) (ys : List S) (hlen : xs.length = ys.length)
    (label : D → L) (edge : S → L) (he : xs.map label = ys.map edge)
    (x : D) (hx : x ∈ xs) : edge (boundaryIndex xs ys hlen x hx) = label x := by
  have hi : xs.idxOf x < xs.length := List.idxOf_lt_length_iff.mpr hx
  have h := congrArg (fun l => l[xs.idxOf x]?) he
  simp only [List.getElem?_map,List.getElem?_eq_getElem hi,
    List.getElem?_eq_getElem (show xs.idxOf x < ys.length by omega),Option.map_some,
    Option.some.injEq,List.getElem_idxOf] at h
  exact h.symm

lemma boundaryIndex_inj (xs : List D) (ys : List S) (hny : ys.Nodup)
    (hlen : xs.length = ys.length) {x y : D} (hx : x ∈ xs) (hy : y ∈ xs)
    (he : boundaryIndex xs ys hlen x hx = boundaryIndex xs ys hlen y hy) : x = y := by
  have hi := hny.getElem_inj_iff.mp he
  have hx' := List.getElem_idxOf (List.idxOf_lt_length_iff.mpr hx)
  have hy' := List.getElem_idxOf (List.idxOf_lt_length_iff.mpr hy)
  have ht : xs[xs.idxOf x]'(List.idxOf_lt_length_iff.mpr hx) =
      xs[xs.idxOf y]'(List.idxOf_lt_length_iff.mpr hy) := by simp only [hi]
  exact hx'.symm.trans (ht.trans hy')

variable [DecidableEq S]

lemma boundaryIndex_commute {f : Perm D} {t : Perm S} {xs : List D} {ys : List S}
    (hf : IsBoundary f xs) (ht : IsBoundary t ys) (hlen : xs.length = ys.length)
    (x : D) (hx : x ∈ xs) :
    boundaryIndex xs ys hlen (f x) (hf.invariant hx) = t (boundaryIndex xs ys hlen x hx) := by
  obtain ⟨i,hi,rfl⟩ := List.getElem_of_mem hx
  have hn : 0 < xs.length := (Nat.zero_le i).trans_lt hi
  have hn' : 0 < ys.length := by omega
  rw [boundaryIndex_get xs ys hf.nodup hlen i hi,ht.turn _ (List.getElem_mem (by omega)),
    List.formPerm_apply_getElem ys ht.nodup i (by omega)]
  have he : f xs[i] = xs[(i+1)%xs.length]'(Nat.mod_lt _ hn) :=
    (hf.turn _ (List.getElem_mem hi)).trans (List.formPerm_apply_getElem xs hf.nodup i hi)
  simp only [he,boundaryIndex_get xs ys hf.nodup hlen,hlen]

/-- Build a coherent index map by selecting one boundary match PER FACE,
not independently per side. This is the coherence step between
word van Kampen diagrams and actual cellular pictures. -/
theorem indexedFaceMap_exists (f : Perm D) (t : Perm S) (label : D → L) (edge : S → L)
    (h : ∀ x : D, ∃ xs : List D, ∃ ys : List S,
      IsBoundary f xs ∧ x ∈ xs ∧ IsBoundary t ys ∧ xs.map label = ys.map edge) :
    ∃ j : D → S, IndexedFaceMap f t j ∧ ∀ x, edge (j x) = label x := by
  let F := Quotient (SameCycle.setoid f)
  let cls : D → F := Quotient.mk _
  let xs : F → List D := fun c => (h c.out).choose
  let ys : F → List S := fun c => (h c.out).choose_spec.choose
  have hd : ∀ c : F, IsBoundary f (xs c) ∧ c.out ∈ xs c ∧
      IsBoundary t (ys c) ∧ (xs c).map label = (ys c).map edge :=
    fun c => (h c.out).choose_spec.choose_spec
  have hlen : ∀ c, (xs c).length = (ys c).length := fun c => by
    have hh := congrArg List.length (hd c).2.2.2
    simpa only [List.length_map] using hh
  have hm : ∀ x, x ∈ xs (cls x) := by
    intro x
    exact (hd (cls x)).1.mem_of_sameCycle (hd (cls x)).2.1
      (Quotient.exact (Quotient.out_eq' (cls x)))
  have hc : ∀ x, cls (f x) = cls x := fun x =>
    Quotient.sound (SameCycle.rfl.apply_right.symm)
  let j : D → S := fun x => boundaryIndex (xs (cls x)) (ys (cls x)) (hlen _) x (hm x)
  refine ⟨j,⟨?_,?_⟩,?_⟩
  · intro x
    dsimp only [j]
    simp only [hc x]
    exact boundaryIndex_commute (hd (cls x)).1 (hd (cls x)).2.2.1 (hlen _) x (hm x)
  · intro x y hxy he
    have hec : cls x = cls y := Quotient.sound hxy
    dsimp only [j] at he
    simp only [← hec] at he
    exact boundaryIndex_inj _ _ (hd (cls x)).2.2.1.nodup (hlen _) (hm x) (hec ▸ hm y) he
  · intro x
    exact boundaryIndex_label _ _ (hlen _) label edge (hd (cls x)).2.2.2 x (hm x)

end HyperbolicObstruction.PictureSwitch
end
end

section

end
end

end OAI