import OAI.Combinatorics.Automata.Wiring

namespace OAI

namespace OneWayLiveness
namespace Pairing
variable {P I : Type} [Fintype P] [Fintype I]

lemma transport_compatible {P Q C : Type*} (a : Pairing P) (e : P ≃ Q) (c : Q → C) :
    (a.transport e).Compatible c ↔ a.Compatible (c ∘ e) := by
  constructor
  · intro h x y hxy
    exact h (e x) (e y) (by simpa only [transport, Equiv.symm_apply_apply] using hxy)
  · intro h x y hxy
    simpa only [Function.comp_apply, Equiv.apply_symm_apply] using h _ _ hxy

/-- Close all internal tips with a matching of local joins. -/
noncomputable def close (lanes : Pairing (P ⊕ I)) (joins : Pairing I) : Pairing P :=
  (compose lanes (joins.transport (Equiv.sumEmpty I Empty).symm)).transport (Equiv.sumEmpty P Empty)

lemma close_compatible (lanes : Pairing (P ⊕ I)) (joins : Pairing I) (c : P → Bool) :
    (close lanes joins).Compatible c ↔
    ∃ f : I → Bool, lanes.Compatible (Sum.elim c f) ∧ joins.Compatible f := by
  rw [close, transport_compatible]
  have hc : c ∘ (Equiv.sumEmpty P Empty) = Sum.elim c (fun e => e.elim) := by
    funext p; cases p with | inl p => rfl | inr p => exact p.elim
  rw [hc, compose_compatible]
  apply exists_congr
  intro f
  rw [transport_compatible]
  rfl

lemma ofInvolution_compatible {P C : Type*} (f : P → P) (hf : Function.Involutive f)
    (hn : ∀ p, f p ≠ p) (c : P → C) :
    (ofInvolution f hf hn).Compatible c ↔ ∀ p, c p = c (f p) := by
  constructor
  · intro h p; exact h p (f p) rfl
  · intro h p q hpq; cases hpq; exact h p

end Pairing

namespace CellNetwork
variable (Q : Type)
/-- `true` directs the prospective successor to the right. -/
abbrev Slot := Bool × Q × Q
abbrev Port := Slot Q × Bool
abbrev Boundary := Bool × Slot Q
abbrev Incidence := Boundary Q ⊕ ((Q × Q) × Bool)
abbrev Tip := Incidence Q × Bool
abbrev LocalVertex := Q ⊕ Incidence Q

/-- A lane's absolute label changes its incoming/outgoing role between
opposite sides of a cell. -/
def tipRole (side lane : Bool) : Bool := side ^^ lane
@[simp] lemma tipRole_twice (s l : Bool) : tipRole s (tipRole s l) = l := by cases s <;> cases l <;> rfl
@[simp] lemma tipRole_ne (s l : Bool) : tipRole (!s) l = !(tipRole s l) := by cases s <;> cases l <;> rfl

/-- All stay candidates are allowed locally; a nontransition candidate will
be attached to a fresh leaf. This leaves the external degree unchanged. -/
def laneMate : ((Boundary Q × Bool) ⊕ Tip Q) → ((Boundary Q × Bool) ⊕ Tip Q)
  | .inl (b,l) => .inr (.inl b, tipRole b.1 l)
  | .inr (.inl b,t) => .inl (b, tipRole b.1 t)
  | .inr (.inr (pq,r),t) => .inr (.inr (pq,!r),!t)

lemma laneMate_involutive : Function.Involutive (laneMate Q) := by
  rintro (⟨⟨s,slot⟩,l⟩ | ⟨(⟨s,slot⟩ | ⟨pq,r⟩),t⟩) <;> simp [laneMate]
lemma laneMate_ne (p) : laneMate Q p ≠ p := by
  rcases p with ⟨⟨s,slot⟩,l⟩ | ⟨(⟨s,slot⟩ | ⟨pq,r⟩),t⟩ <;> simp [laneMate]

def lanes : Pairing ((Boundary Q × Bool) ⊕ Tip Q) :=
  Pairing.ofInvolution (laneMate Q) (laneMate_involutive Q) (laneMate_ne Q)

def joinMate (r : Equiv.Perm (Incidence Q)) : Tip Q → Tip Q
  | (i,false) => (r i, true)
  | (i,true) => (r.symm i, false)

lemma joinMate_involutive (r : Equiv.Perm (Incidence Q)) : Function.Involutive (joinMate Q r) := by
  rintro ⟨i, b⟩; cases b <;> simp [joinMate]
lemma joinMate_ne (r : Equiv.Perm (Incidence Q)) (p) : joinMate Q r p ≠ p := by
  rcases p with ⟨i,b⟩; cases b <;> simp [joinMate]

def joins (r : Equiv.Perm (Incidence Q)) : Pairing (Tip Q) :=
  Pairing.ofInvolution (joinMate Q r) (joinMate_involutive Q r) (joinMate_ne Q r)

lemma lanes_compatible (c : Boundary Q × Bool → Bool) (f : Tip Q → Bool) :
    (lanes Q).Compatible (Sum.elim c f) ↔
    (∀ b l, c (b,l) = f (.inl b, tipRole b.1 l)) ∧
    (∀ pq r t, f (.inr (pq,r),t) = f (.inr (pq,!r),!t)) := by
  rw [lanes, Pairing.ofInvolution_compatible]
  constructor
  · intro h; exact ⟨fun b l => h (.inl (b,l)), fun pq r t => h (.inr (.inr (pq,r),t))⟩
  · rintro ⟨hb, hs⟩ (⟨b,l⟩ | ⟨(b | ⟨pq,r⟩),t⟩)
    · exact hb b l
    · simpa only [laneMate, Sum.elim_inl, Sum.elim_inr, tipRole_twice] using (hb b (tipRole b.1 t)).symm
    · exact hs pq r t

lemma joins_compatible (r : Equiv.Perm (Incidence Q)) (f : Tip Q → Bool) :
    (joins Q r).Compatible f ↔ ∀ i, f (i,false) = f (r i,true) := by
  rw [joins, Pairing.ofInvolution_compatible]
  constructor
  · exact fun h i => h (i,false)
  · intro h ⟨i,b⟩
    cases b with
    | false => exact h i
    | true => simpa [joinMate] using (h (r.symm i)).symm

/-- The two sides use exactly the same slot/lane labels. -/
def portsEquiv : (Boundary Q × Bool) ≃ (Port Q ⊕ Port Q) where
  toFun p := if p.1.1 then .inr (p.1.2,p.2) else .inl (p.1.2,p.2)
  invFun p := p.elim (fun p => ((false,p.1),p.2)) (fun p => ((true,p.1),p.2))
  left_inv p := by rcases p with ⟨⟨s,slot⟩,l⟩; cases s <;> rfl
  right_inv p := by cases p <;> rfl

noncomputable def diagram [Fintype Q] (r : Equiv.Perm (Incidence Q)) : Pairing (Port Q ⊕ Port Q) :=
  (Pairing.close (lanes Q) (joins Q r)).transport (portsEquiv Q)

lemma diagram_compatible [Fintype Q] (r : Equiv.Perm (Incidence Q))
    (left right : Port Q → Bool) :
    (diagram Q r).Compatible (Sum.elim left right) ↔ ∃ f : Tip Q → Bool,
    (∀ s slot l, (if s then right else left) (slot,l) = f (.inl (s,slot),tipRole s l)) ∧
    (∀ pq role t, f (.inr (pq,role),t) = f (.inr (pq,!role),!t)) ∧
    (∀ i, f (i,false) = f (r i,true)) := by
  rw [diagram, Pairing.transport_compatible, Pairing.close_compatible]
  apply exists_congr
  intro f
  rw [lanes_compatible, joins_compatible, and_assoc]
  apply and_congr_left
  intro _
  constructor
  · intro h s slot l
    cases s with
    | false => simpa [portsEquiv] using h (false,slot) l
    | true => simpa [portsEquiv] using h (true,slot) l
  · intro h ⟨s,slot⟩ l
    cases s with
    | false => simpa [portsEquiv] using h false slot l
    | true => simpa [portsEquiv] using h true slot l

end CellNetwork
end OneWayLiveness

end OAI