import OAI.AlgebraicGeometry.CharacterVarieties.Foundation.BoundaryReordering

namespace OAI

noncomputable section
open scoped Classical Matrix

namespace IntegralCharacterVarieties.SurfacePresentation.Diagram
open scoped Classical Matrix
open OccurrenceIncidence MatrixExpression HomTransport
variable {F S V R A : Type} {arity : S → ℕ} [CommRing R] [CommRing A]
variable (D : Diagram F S V arity) (φ : R →+* A)
variable (G : D.CornerBases (R:=A))
variable (g : (e : D.Generator) → (Matrix (Fin (D.generatorRank e)) (Fin (D.generatorRank e)) A)ˣ)

@[simp] lemma cornerBasis_start (a : Side S arity) : D.cornerBasis G (start a)=G a := by
  have h := MatrixIso.finite_basis_transport (fun a : Side S arity => D.rank (D.ports.facet a)) G
    a (D.sourceCorner (start a)) (D.rank (D.ports.facet a)) (D.rank (D.ports.facet a))
    rfl (congrArg D.rank (D.sourceCorner_facet (start a))).symm
    (D.sourceCorner_start a).symm rfl
  unfold cornerBasis
  erw [MatrixIso.reindex_refl_eq] at h
  simp only [finCongr_refl,MatrixIso.reindex_refl_eq] at h
  convert! h using 1

def boundaryCornerBasis (f : F) (b : Fin (D.boundaryCount f))
    (i : Fin (D.boundaryLength f b)) : MatrixIso A (Fin (D.rank f)) (Fin (D.rank f)) :=
  (G (D.boundarySide ⟨f,b,i⟩)).reindex
    (finCongr (congrArg D.rank (D.boundaryFacet f b i)).symm)
    (finCongr (congrArg D.rank (D.boundaryFacet f b i)).symm)

lemma cornerFinish_boundary (f : F) (b : Fin (D.boundaryCount f))
    (i : Fin (D.boundaryLength f b)) :
    (D.cornerBasis G (finish (D.boundarySide ⟨f,b,i⟩))).reindex
      (finCongr (congrArg D.rank (D.boundaryFacet f b i)).symm)
      (finCongr (congrArg D.rank (D.boundaryFacet f b i)).symm)=
      D.boundaryCornerBasis G f b ⟨(i.val+1)%D.boundaryLength f b,Nat.mod_lt _ (D.boundaryPositive f b)⟩ := by
  exact MatrixIso.finite_basis_transport (fun a : Side S arity => D.rank (D.ports.facet a)) G
    _ _ _ _ _ _ ((D.boundaryNext f b i).symm.trans
      (D.sourceCorner_finish (D.boundarySide ⟨f,b,i⟩)).symm) _

lemma boundaryEdge_cornerGauge (f : F) (b : Fin (D.boundaryCount f))
    (i : Fin (D.boundaryLength f b)) :
    (D.boundaryEdgeWord f b i).eval φ (D.cornerGaugeGenerators G g)=
      (D.boundaryCornerBasis G f b ⟨(i.val+1)%D.boundaryLength f b,Nat.mod_lt _ (D.boundaryPositive f b)⟩).toUnit*
        (D.boundaryEdgeWord f b i).eval φ g*(D.boundaryCornerBasis G f b i).toUnit⁻¹ := by
  have h := D.boundaryEdge_iso φ (D.cornerGaugeGenerators G g) f b i
  rw [show MatrixIso.unit ((D.cornerGaugeGenerators G g) (.side (D.boundarySide ⟨f,b,i⟩)))=
      (((D.cornerBasis G (start (D.boundarySide ⟨f,b,i⟩))).symm.trans
        (MatrixIso.unit (g (.side (D.boundarySide ⟨f,b,i⟩))))).trans
        (D.cornerBasis G (finish (D.boundarySide ⟨f,b,i⟩)))) by
          unfold cornerGaugeGenerators
          erw [MatrixIso.unit_toUnit]] at h
  erw [MatrixIso.bases_reindex,D.cornerFinish_boundary,← D.boundaryEdge_iso φ g] at h
  simp only [D.cornerBasis_start] at h
  apply Units.ext
  have hh := congrArg MatrixIso.val h
  change _=(D.boundaryCornerBasis G f b ⟨(i.val+1)%D.boundaryLength f b,Nat.mod_lt _ (D.boundaryPositive f b)⟩).val*
    (((D.boundaryEdgeWord f b i).eval φ g) : Matrix (Fin (D.rank f)) (Fin (D.rank f)) A)*
      (D.boundaryCornerBasis G f b i).inv
  simp only [boundaryCornerBasis,MatrixIso.unit,MatrixIso.trans,MatrixIso.symm,
    Matrix.mul_assoc] at hh ⊢
  convert! hh using 1

/-- Based boundary holonomy telescopes at every interior corner; only the independent chosen base
corner remains. -/
lemma boundaryWord_cornerGauge (f : F) (b : Fin (D.boundaryCount f)) :
    (D.boundaryWord f b).eval φ (D.cornerGaugeGenerators G g)=
      (D.boundaryCornerBasis G f b ⟨0,D.boundaryPositive f b⟩).toUnit*
        (D.boundaryWord f b).eval φ g*
          (D.boundaryCornerBasis G f b ⟨0,D.boundaryPositive f b⟩).toUnit⁻¹ := by
  rw [D.boundaryWord_eval_raw,D.boundaryWord_eval_raw]
  simp_rw [D.boundaryEdge_cornerGauge]
  exact SurfaceSurgery.cyclic_reverse_product_gauge _ (D.boundaryPositive f b)
    (fun i => (D.boundaryCornerBasis G f b i).toUnit)
    (fun i => (D.boundaryEdgeWord f b i).eval φ g)

/-- Fix the selected base corner of every boundary. These are coordinate gauges, not extra equations
on an old local system. -/
def CornerBases.Based (G : D.CornerBases (R:=A)) : Prop :=
  ∀ f b,D.boundaryCornerBasis G f b ⟨0,D.boundaryPositive f b⟩=MatrixIso.refl

lemma basedCorner_boundaryWord (hG : CornerBases.Based D G) (f : F) (b : Fin (D.boundaryCount f)) :
    (D.boundaryWord f b).eval φ (D.cornerGaugeGenerators G g)=
      (D.boundaryWord f b).eval φ g := by
  rw [D.boundaryWord_cornerGauge,hG f b]
  have hh : (MatrixIso.refl : MatrixIso A (Fin (D.rank f)) (Fin (D.rank f))).toUnit=1 := by
    apply Units.ext
    ext i j
    simp [MatrixIso.toUnit,MatrixIso.refl,Matrix.one_apply]
  rw [hh]
  simp

lemma basedCorner_surfaceWord (hG : CornerBases.Based D G) (f : F) :
    (D.surfaceWord f).eval φ (D.cornerGaugeGenerators G g)=(D.surfaceWord f).eval φ g := by
  simp only [surfaceWord,Term.eval,wordProduct_eval_raw,List.map_ofFn,Function.comp_def,
    D.basedCorner_boundaryWord φ G g hG]
  rfl
end IntegralCharacterVarieties.SurfacePresentation.Diagram

namespace IntegralCharacterVarieties.SurfacePresentation.Diagram
open scoped Classical Matrix
open OccurrenceIncidence MatrixExpression HomTransport
variable {F S V R A : Type} {arity : S → ℕ} [CommRing R] [CommRing A] [Algebra R A]
variable (D : Diagram F S V arity)
variable (G : D.CornerBases (R:=A)) (hG : CornerBases.Based D G)

/-- Arbitrary independent internal corner gauges act on the full solution, not just on boundary
holonomies or its regular seam equations. The original scalar punctures and handles are
unchanged. -/
def basedCornerSolution (P : D.Punctures R) (x : D.Solution P A) : D.Solution P A := by
  refine ⟨⟨D.cornerGaugeGenerators G x.val.val,?_⟩,?_⟩
  · intro j
    cases j with
    | inl f =>
      change SameFramedFlag (fun _ => 0)
        (matrixUnitEquiv ((D.surfaceWord f).eval (algebraMap R A) (D.cornerGaugeGenerators G x.val.val)))
        (matrixUnitEquiv ((D.surfaceTarget P f).eval (algebraMap R A) (D.cornerGaugeGenerators G x.val.val)))
      rw [D.basedCorner_surfaceWord (algebraMap R A) G x.val.val hG]
      exact x.val.property (.inl f)
    | inr s =>
      exact D.seamHolds_cornerGauge (algebraMap R A) G x.val.val s (x.val.property (.inr s))
  · exact D.vertexHolds_cornerGauge G x.val.val x.property
end IntegralCharacterVarieties.SurfacePresentation.Diagram

namespace IntegralCharacterVarieties.SurfacePresentation.Diagram
open scoped Classical Matrix
open OccurrenceIncidence MatrixExpression
variable {F S V A : Type} {arity : S → ℕ} [CommRing A]
variable (D : Diagram F S V arity)

abbrev BoundaryBases := (f : F) → (b : Fin (D.boundaryCount f)) →
  (i : Fin (D.boundaryLength f b)) → MatrixIso A (Fin (D.rank f)) (Fin (D.rank f))

/-- Transport the exhaustively indexed boundary bases to the side occurrences, including every
repeated facet and every cyclic base position. -/
def cornerBasesOfBoundary (B : D.BoundaryBases (A:=A)) : D.CornerBases (R:=A) := fun a =>
  let z := D.boundarySide.symm a
  (B z.1 z.2.1 z.2.2).reindex
    (finCongr (congrArg D.rank (D.sideCircle_facet a)).symm)
    (finCongr (congrArg D.rank (D.sideCircle_facet a)).symm)

lemma boundaryBasis_ofBoundary (B : D.BoundaryBases (A:=A))
    (f : F) (b : Fin (D.boundaryCount f)) (i : Fin (D.boundaryLength f b)) :
    D.boundaryCornerBasis (D.cornerBasesOfBoundary B) f b i=B f b i := by
  have hh := MatrixIso.finite_basis_transport
    (fun z : (f : F) × (b : Fin (D.boundaryCount f)) × Fin (D.boundaryLength f b) => D.rank z.1)
    (fun z => B z.1 z.2.1 z.2.2)
    ⟨f,b,i⟩ (D.boundarySide.symm (D.boundarySide ⟨f,b,i⟩))
    (D.rank f) (D.rank (D.ports.facet (D.boundarySide ⟨f,b,i⟩)))
    rfl (congrArg D.rank (D.sideCircle_facet (D.boundarySide ⟨f,b,i⟩))).symm
    (D.boundarySide.symm_apply_apply ⟨f,b,i⟩).symm
    (congrArg D.rank (D.boundaryFacet f b i)).symm
  simpa only [boundaryCornerBasis,cornerBasesOfBoundary,finCongr_refl,
    MatrixIso.reindex_refl_eq] using hh


lemma cornerBasesOfBoundary_based (B : D.BoundaryBases (A:=A))
    (hB : ∀ f b,B f b ⟨0,D.boundaryPositive f b⟩=MatrixIso.refl) :
    CornerBases.Based D (D.cornerBasesOfBoundary B) := by
  intro f b
  rw [D.boundaryBasis_ofBoundary,hB]
end IntegralCharacterVarieties.SurfacePresentation.Diagram

namespace IntegralCharacterVarieties.SurfaceSurgery
variable {G : Type*} [Group G]

/-- Chronological prefix products: the first edge acts first. -/
def prefixProduct (e : ℕ → G) : ℕ → G
  | 0 => 1
  | n+1 => e n*prefixProduct e n

@[simp] lemma prefixProduct_zero (e : ℕ → G) : prefixProduct e 0=1 := rfl
@[simp] lemma prefixProduct_succ (e : ℕ → G) (n : ℕ) :
    prefixProduct e (n+1)=e n*prefixProduct e n := rfl

lemma prefixProduct_eq_reverse (e : ℕ → G) (n : ℕ) :
    prefixProduct e n=(List.ofFn (fun i : Fin n => e i.val)).reverse.prod := by
  induction n with
  | zero => rfl
  | succ n ih =>
    rw [prefixProduct_succ,List.ofFn_succ',List.concat_eq_append,List.reverse_concat,List.prod_cons,ih]
    rfl

/-- Extension by 1 is solely for evaluating the finite prefix; no selected path ever encounters an
extended edge. -/
def cycleEdge {n : ℕ} (e : Fin n → G) (i : ℕ) : G :=
  if h : i<n then e ⟨i,h⟩ else 1

@[simp] lemma cycleEdge_at {n : ℕ} (e : Fin n → G) (i : Fin n) :
    cycleEdge e i.val=e i := by simp [cycleEdge,i.isLt]

def prefixBasis {n : ℕ} (e : Fin n → G) (i : Fin n) : G :=
  (prefixProduct (cycleEdge e) i.val)⁻¹

@[simp] lemma prefixBasis_zero {n : ℕ} (hn : 0<n) (e : Fin n → G) :
    prefixBasis e ⟨0,hn⟩=1 := by simp [prefixBasis]

lemma prefixProduct_cycle {n : ℕ} (e : Fin n → G) :
    prefixProduct (cycleEdge e) n=(List.ofFn e).reverse.prod := by
  rw [prefixProduct_eq_reverse]
  simp only [cycleEdge_at]

/-- All interior edges become 1; the FINAL side retains precisely the original based holonomy, not a
merely conjugate matrix. -/
theorem prefix_gauge {n : ℕ} (hn : 0<n) (e : Fin n → G) (i : Fin n) :
    prefixBasis e ⟨(i.val+1)%n,Nat.mod_lt _ hn⟩*e i*(prefixBasis e i)⁻¹=
      if i.val+1<n then 1 else (List.ofFn e).reverse.prod := by
  by_cases hi : i.val+1<n
  · rw [ite_eq_left hi]
    simp only [prefixBasis,Nat.mod_eq_of_lt hi,prefixProduct_succ,cycleEdge_at]
    group
  · rw [ite_eq_right hi]
    have he : i.val+1=n := by omega
    have hm : (i.val+1)%n=0 := by rw [he,Nat.mod_self]
    simp only [prefixBasis,hm,prefixProduct_zero,inv_one,one_mul,inv_inv]
    rw [←cycleEdge_at e i,←prefixProduct_succ,he,prefixProduct_cycle]
end IntegralCharacterVarieties.SurfaceSurgery

end

end OAI