import OAI.Combinatorics.Hamiltonian.Rectangle

namespace OAI

/-! Graph realization and exact finite duality for topological plane embeddings. -/

namespace Barnette.Network
noncomputable section
open scoped Classical
variable {V W E : Type*} [Fintype V] [Fintype W] [Fintype E]

def Realizes (G : SimpleGraph V) (M : Network V G.edgeSet) : Prop :=
  ∀ e, s(M.tail e, M.head e) = e.val

omit [Fintype V] in
lemma Realizes.graph_eq {G : SimpleGraph V} {M : Network V G.edgeSet}
    (h : M.Realizes G) : M.graph = G := by
  ext v w
  constructor
  · rintro ⟨_, e, ⟨rfl, rfl⟩ | ⟨rfl, rfl⟩⟩
    · exact G.mem_edgeSet.mp ((h e).symm ▸ e.property)
    · exact (G.mem_edgeSet.mp ((h e).symm ▸ e.property)).symm
  · intro hvw
    let e : G.edgeSet := ⟨s(v,w), hvw⟩
    refine ⟨hvw.ne, e, ?_⟩
    have he := h e
    change s(M.tail e, M.head e) = s(v,w) at he
    exact Sym2.eq_iff.mp he

omit [Fintype V] in
lemma Realizes.loopless {G : SimpleGraph V} {M : Network V G.edgeSet}
    (h : M.Realizes G) (e : G.edgeSet) : M.tail e ≠ M.head e := by
  have he : G.Adj (M.tail e) (M.head e) := G.mem_edgeSet.mp ((h e).symm ▸ e.property)
  exact he.ne

omit [Fintype V] in
lemma exists_dart_for_edge (G : SimpleGraph V) (e : G.edgeSet) :
    ∃ d : G.Dart, d.edge = e.val := by
  obtain ⟨e, he⟩ := e
  induction e using Sym2.inductionOn with
  | hf x y => exact ⟨⟨(x,y), he⟩, rfl⟩

omit [Fintype V] [Fintype W] [Fintype E] in
lemma connectedFibers_of_partition (N : Network W E) (q : W → V)
    (B : V → Set W) (hB : ∀ v, (N.graph.induce (B v)).Connected)
    (hmem : ∀ w v, q w = v ↔ w ∈ B v) : N.ConnectedFibers q := by
  intro x y hxy
  let T := N.restrict (Subtype.val : N.internal q → E)
  let f : N.graph.induce (B (q x)) →g T.graph := {
    toFun := Subtype.val
    map_rel' := by
      intro a b hab
      rcases hab with ⟨hne, e, he⟩
      have ha : q a.val = q x := (hmem _ _).mpr a.property
      have hb : q b.val = q x := (hmem _ _).mpr b.property
      have hei : e ∈ N.internal q := by
        rcases he with ⟨ht, hh⟩ | ⟨ht, hh⟩
        · change q (N.tail e) = q (N.head e)
          rw [ht, hh]; exact ha.trans hb.symm
        · change q (N.tail e) = q (N.head e)
          rw [ht, hh]; exact hb.trans ha.symm
      exact ⟨hne, ⟨e, hei⟩, he⟩ }
  have hx : x ∈ B (q x) := (hmem x (q x)).mp rfl
  have hy : y ∈ B (q x) := (hmem y (q x)).mp hxy.symm
  exact ((hB (q x)) ⟨x,hx⟩ ⟨y,hy⟩).map f

omit [Fintype E] in

theorem minor_quotient {G : SimpleGraph V} (hG : G.Connected)
    (N : Network W E) (hN : N.graph.Connected) (M : MinorModel G N.graph) :
    ∃ (q : W → V) (j : G.edgeSet → E), Function.Surjective q ∧
      N.ConnectedFibers q ∧ Function.Injective j ∧
      ((N.mapVertices q).restrict j).Realizes G := by
  have : Nonempty V := hG.nonempty
  obtain ⟨B, hsub, hconn, hdisj, hcover⟩ := BranchPartition.extend N.graph hN
    M.branch M.branch_connected M.branches_disjoint
  obtain ⟨q, hq, hmem⟩ := BranchPartition.quotient N.graph B hconn hdisj hcover
  choose d hd using exists_dart_for_edge G
  have hex (e : G.edgeSet) : ∃ k : E, s(q (N.tail k), q (N.head k)) = e.val := by
    obtain ⟨a, ha, b, hb, _, k, hk⟩ := M.adjacency (d e).fst (d e).snd (d e).adj
    have ha' : q a = (d e).fst := (hmem _ _).mpr (hsub _ ha)
    have hb' : q b = (d e).snd := (hmem _ _).mpr (hsub _ hb)
    refine ⟨k, ?_⟩
    rcases hk with ⟨ht, hh⟩ | ⟨ht, hh⟩
    · rw [ht, hh, ha', hb']; exact hd e
    · rw [ht, hh, ha', hb', Sym2.eq_swap]; exact hd e
  choose j hj using hex
  refine ⟨q, j, hq, N.connectedFibers_of_partition q B hconn hmem, ?_, hj⟩
  intro e f hef
  apply Subtype.ext
  exact (hj e).symm.trans ((congrArg (fun k => s(q (N.tail k), q (N.head k))) hef).trans (hj f))

universe uF
variable {F : Type uF} [Fintype F]

theorem Duality.graphMinor {G : SimpleGraph V} (hG : G.Connected)
    (N : Network W E) (D : Network F E) (h : N.Duality D)
    (M : MinorModel G N.graph) :
    ∃ (P : Network V G.edgeSet) (L : Type uF) (_ : Fintype L) (Q : Network L G.edgeSet),
      P.Realizes G ∧ P.Duality Q := by
  obtain ⟨q,j,hq,hc,hj,hreal⟩ := minor_quotient hG N h.connected M
  have he (e : G.edgeSet) : q (N.tail (j e)) ≠ q (N.head (j e)) := hreal.loopless e
  have hPc : ((N.mapVertices q).restrict j).graph.Connected := by
    rw [hreal.graph_eq]; exact hG
  obtain ⟨L, hL, Q, hQ⟩ := h.minor N D q hq hc j hj he hPc
  exact ⟨_, L, hL, Q, hreal, hQ⟩

end
end Barnette.Network

namespace Barnette.PlaneEmbedding
noncomputable section
open scoped Classical
variable {V : Type*} [Fintype V] {G : SimpleGraph V}

theorem exists_exact_dual (E : PlaneEmbedding G) (hG : G.Connected) :
    ∃ (P : Network V G.edgeSet) (F : Type) (_ : Fintype F) (D : Network F G.edgeSet),
      P.Realizes G ∧ P.Duality D := by
  obtain ⟨M⟩ := E.exists_lattice_minor_model
  obtain ⟨r, ⟨M'⟩⟩ := RectangularDual.lattice_minor_in_rectangle M
  exact (RectangularDual.grid_duality (2*r) (2*r)).graphMinor hG _ _ M'
end
end Barnette.PlaneEmbedding

end OAI