import Mathlib
import OAI.GroupTheory.SimpleOvergroups.BoundedContexts

namespace OAI


namespace SimpleFInftyOvergroups.BoundedEncoding.NamedAction

structure Operations (G X : Type*) where
  one : G
  mul : G → G → G
  inv : G → G
  act : G → X → X
  gcost : G → ℕ
  xcost : X → ℕ
  cost_one : gcost one = 0
  cost_mul : ∀ g h, gcost (mul g h) = gcost g + gcost h
  cost_inv : ∀ g, gcost (inv g) = gcost g
  cost_act : ∀ g x, xcost (act g x) = gcost g + xcost x

abbrev Letter (G X : Type*) := G ⊕ (X ⊕ Option X)
abbrev Form (G X : Type*) := Option (List X × G × List X)
abbrev Result (K L : Type*) := Option (List L × K × List L)

namespace Operations
variable {G X K L : Type*} (N : Operations G X)

def letterCost : Letter G X → ℕ
  | .inl g => N.gcost g
  | .inr (.inl x) | .inr (.inr (some x)) => N.xcost x
  | .inr (.inr none) => 0

def wordCost (w : List (Letter G X)) : ℕ := (w.map N.letterCost).sum

def formCost : Form G X → ℕ
  | none => 0
  | some (l,g,r) => (l.map N.xcost).sum + N.gcost g + (r.map N.xcost).sum

def formKey (kg : G → K) (kx : X → L) : Form G X → Result K L :=
  Option.map (fun p => (p.1.map kx,kg p.2.1,p.2.2.map kx))

def plan : Letter G X → Form G X → Form G X ⊕ (X × X × Form G X)
  | _, none => .inl none
  | .inr (.inr none), _ => .inl none
  | .inr (.inl x), some (l,g,r) => .inl (some (x::l,g,r))
  | .inl h, some ([],g,r) => .inl (some ([],N.mul h g,r))
  | .inl h, some (x::l,g,r) => .inl (some (N.act h x::l,g,r))
  | .inr (.inr (some y)), some ([],g,r) =>
      .inl (some ([],N.one,r++[N.act (N.inv g) y]))
  | .inr (.inr (some y)), some (x::l,g,r) => .inr (y,x,some (l,g,r))

variable [DecidableEq L]

def totalStep (kx : X → L) (a : Letter G X) (f : Form G X) : Form G X :=
  (N.plan a f).elim id (fun p => if kx p.1 = kx p.2.1 then p.2.2 else none)

def totalRun (kx : X → L) (w : List (Letter G X)) (f : Form G X) : Form G X :=
  w.foldr (N.totalStep kx) f

def totalNormalize (kx : X → L) (w : List (Letter G X)) : Form G X :=
  N.totalRun kx w (some ([],N.one,[]))

def totalTest (kg : G → K) (kx : X → L) (w : List (Letter G X)) : Result K L :=
  formKey kg kx (N.totalNormalize kx w)

@[simp] theorem totalRun_nil (kx : X → L) (f : Form G X) : N.totalRun kx [] f = f := rfl
@[simp] theorem totalRun_cons (kx : X → L) (a : Letter G X) (w : List (Letter G X))
    (f : Form G X) : N.totalRun kx (a::w) f = N.totalStep kx a (N.totalRun kx w f) := rfl
@[simp] theorem wordCost_nil : N.wordCost [] = 0 := rfl
@[simp] theorem wordCost_cons (a : Letter G X) (w : List (Letter G X)) :
    N.wordCost (a::w) = N.letterCost a + N.wordCost w := rfl
@[simp] theorem wordCost_append (u v : List (Letter G X)) :
    N.wordCost (u++v) = N.wordCost u + N.wordCost v := by simp [wordCost]
@[simp] theorem totalStep_none (kx : X → L) (a : Letter G X) :
    N.totalStep kx a none = none := rfl

theorem totalStep_cost (kx : X → L) (a : Letter G X) (f : Form G X) :
    N.formCost (N.totalStep kx a f) ≤ N.letterCost a + N.formCost f := by
  cases f with
  | none => simp [formCost]
  | some p =>
    rcases p with ⟨l,g,r⟩
    rcases a with h | (x | y)
    · cases l <;> simp [totalStep,plan,formCost,letterCost,N.cost_mul,N.cost_act] <;> omega
    · simp [totalStep,plan,formCost,letterCost]; omega
    · cases y with
      | none => simp [totalStep,plan,formCost,letterCost]
      | some y =>
        cases l with
        | nil => simp [totalStep,plan,formCost,letterCost,N.cost_one,N.cost_act,N.cost_inv]; omega
        | cons x l =>
          by_cases h : kx y = kx x <;> simp [totalStep,plan,h,formCost,letterCost]; omega

theorem totalRun_cost (kx : X → L) (w : List (Letter G X)) (f : Form G X) :
    N.formCost (N.totalRun kx w f) ≤ N.wordCost w + N.formCost f := by
  induction w with
  | nil => simp
  | cons a w ih =>
    exact (N.totalStep_cost kx a (N.totalRun kx w f)).trans (by rw [wordCost_cons]; omega)

theorem totalNormalize_cost (kx : X → L) (w : List (Letter G X)) :
    N.formCost (N.totalNormalize kx w) ≤ N.wordCost w := by
  simpa [totalNormalize,formCost,N.cost_one] using N.totalRun_cost kx w (some ([],N.one,[]))

end Operations

structure Interpretation {G X V Y K L : Type*} [Group V] [MulAction V Y]
    {m : ℕ} (N : Operations G X) (C : ActionCalculus V Y K L m) where
  group : G → C.GLabel
  point : X → C.XLabel
  group_cost : ∀ g, (group g).cost = N.gcost g
  point_cost : ∀ x, (point x).cost = N.xcost x
  one : group N.one = C.identity
  mul : ∀ g h, group (N.mul g h) = C.multiply (group g) (group h)
  inv : ∀ g, group (N.inv g) = C.inverse (group g)
  act : ∀ g x, point (N.act g x) = C.act (group g) (point x)

namespace Interpretation
variable {G X V Y K L : Type*} [Group V] [MulAction V Y] {m : ℕ}
  {N : Operations G X} {C : ActionCalculus V Y K L m} (I : Interpretation N C)

def gkey (g : G) : K := (I.group g).key
def xkey (x : X) : L := (I.point x).key

def letter : Letter G X → C.Letter
  | .inl g => .grp (I.group g)
  | .inr (.inl x) => .pre (I.point x)
  | .inr (.inr (some x)) => .del (I.point x)
  | .inr (.inr none) => .zero

def form : Form G X → C.Form :=
  Option.map (fun p => (p.1.map I.point,I.group p.2.1,p.2.2.map I.point))

@[simp] theorem letter_cost (a : Letter G X) : (I.letter a).cost C = N.letterCost a := by
  rcases a with g | (x | y)
  · exact I.group_cost g
  · exact I.point_cost x
  · cases y with
    | none => rfl
    | some x => exact I.point_cost x

@[simp] theorem form_cost (f : Form G X) : (I.form f).cost C = N.formCost f := by
  cases f with
  | none => rfl
  | some p => simp [form,ActionCalculus.Form.cost,Operations.formCost,List.map_map,
      Function.comp_def,I.point_cost,I.group_cost]

@[simp] theorem word_cost (w : List (Letter G X)) : C.wordCost (w.map I.letter) = N.wordCost w := by
  simp [ActionCalculus.wordCost,Operations.wordCost,List.map_map,Function.comp_def]

@[simp] theorem form_key (f : Form G X) :
    (I.form f).key C = Operations.formKey I.gkey I.xkey f := by
  cases f <;> simp [form,Operations.formKey,ActionCalculus.Form.key,List.map_map,
    Function.comp_def,gkey,xkey]

variable [DecidableEq L]

theorem totalStep (a : Letter G X) (f : Form G X) :
    I.form (N.totalStep I.xkey a f) = C.step (I.letter a) (I.form f) := by
  cases f with
  | none => simp [form]
  | some p =>
    rcases p with ⟨l,g,r⟩
    rcases a with h | (x | y)
    · cases l <;> simp [Operations.totalStep,Operations.plan,letter,form,ActionCalculus.step,I.mul,I.act]
    · simp [Operations.totalStep,Operations.plan,letter,form,ActionCalculus.step]
    · cases y with
      | none => rfl
      | some y =>
        cases l with
        | nil => simp [Operations.totalStep,Operations.plan,letter,form,ActionCalculus.step,I.one,I.inv,I.act]
        | cons x l =>
          by_cases h : I.xkey y = I.xkey x
          · change (I.point y).key = (I.point x).key at h
            simp [Operations.totalStep,Operations.plan,letter,form,ActionCalculus.step,xkey,h]
          · change (I.point y).key ≠ (I.point x).key at h
            simp [Operations.totalStep,Operations.plan,letter,form,ActionCalculus.step,xkey,h]

theorem totalRun (w : List (Letter G X)) (f : Form G X) :
    I.form (N.totalRun I.xkey w f) = C.run (w.map I.letter) (I.form f) := by
  induction w with
  | nil => rfl
  | cons a w ih => rw [Operations.totalRun_cons,I.totalStep,ih,List.map_cons,ActionCalculus.run_cons]

theorem totalNormalize (w : List (Letter G X)) :
    I.form (N.totalNormalize I.xkey w) = C.normalize (w.map I.letter) := by
  unfold Operations.totalNormalize
  rw [I.totalRun]
  simp only [form,Option.map_some,List.map_nil,I.one]
  rfl

theorem totalTest (w : List (Letter G X)) :
    N.totalTest I.gkey I.xkey w = (C.normalize (w.map I.letter)).key C := by
  rw [← I.totalNormalize,I.form_key]
  rfl

theorem totalTest_context {u v a b : List (Letter G X)} {d : ℕ}
    (h : N.totalTest I.gkey I.xkey u = N.totalTest I.gkey I.xkey v)
    (hu : N.wordCost (a++u++b) ≤ d) (hv : N.wordCost (a++v++b) ≤ d) (hm : 3*d ≤ m) :
    N.totalTest I.gkey I.xkey (a++u++b) = N.totalTest I.gkey I.xkey (a++v++b) := by
  simp only [I.totalTest,List.map_append] at h ⊢
  apply C.normalize_context h (hm := hm)
  · simpa only [← List.map_append,I.word_cost] using hu
  · simpa only [← List.map_append,I.word_cost] using hv

theorem totalTest_zero_context {u a b : List (Letter G X)} {d : ℕ}
    (h : N.totalTest I.gkey I.xkey u = none)
    (hu : N.wordCost (a++u++b) ≤ d) (hm : 3*d ≤ m) :
    N.totalTest I.gkey I.xkey (a++u++b) = none := by
  simp only [I.totalTest,List.map_append] at h ⊢
  exact C.normalize_zero_context h (by simpa only [← List.map_append,I.word_cost] using hu) hm

@[simp] theorem totalTest_nil : N.totalTest I.gkey I.xkey [] ≠ none := by
  simp only [I.totalTest,List.map_nil]
  exact C.normalize_nil_ne_zero

end Interpretation
end SimpleFInftyOvergroups.BoundedEncoding.NamedAction

end OAI