import Mathlib
import OAI.Combinatorics.MatchingCount.Graphs.IndexedCycle
import OAI.Combinatorics.MatchingCount.Graphs.ArcData

namespace OAI

namespace MatchingFPRAS.Cells
open SimpleGraph

variable {L : Type*} {G : SimpleGraph L}
namespace CycleData

variable [DecidableEq L] {m : ℕ} (C : CycleData G m)

def sets (i : ℤ) : Finset L := {C.labels (i - 1), C.labels i}

def Admissible (x y : ℕ) : Prop := ∃ l, l ∈ C.sets x ∧ l ∈ C.sets y

def Good (x y : ℕ) : Prop := y = x + 1 ∨ C.Admissible (x + 1) (y - 1)

def ExteriorGood (x y : ℕ) : Prop :=
  y + 1 = x + m ∨ ∃ l, l ∈ C.sets ((y : ℤ) + 1) ∧ l ∈ C.sets ((x : ℤ) - 1)

lemma sets_clique (i : ℤ) : ∀ u ∈ C.sets i, ∀ v ∈ C.sets i, u = v ∨ G.Adj u v := by
  intro u hu v hv
  simp only [sets, Finset.mem_insert, Finset.mem_singleton] at hu hv
  rcases hu with rfl | rfl <;> rcases hv with rfl | rfl
  · exact Or.inl rfl
  · exact C.adjacent i
  · exact (C.adjacent i).imp Eq.symm (fun h => h.symm)
  · exact Or.inl rfl

def arc (x s : ℕ) : ArcData G s where
  labels i := C.labels ((x : ℤ) + i)
  sets i := C.sets ((x : ℤ) + i)
  left_mem i _ := by simp [sets]
  right_mem i _ := by
    simp only [sets, Finset.mem_insert, Finset.mem_singleton]
    left
    congr 1
    push_cast
    omega
  clique i _ := C.sets_clique ((x : ℤ) + i)

lemma arc_admissible (x s u v : ℕ) :
    (C.arc x s).Admissible u v ↔ C.Admissible (x + u) (x + v) := by
  simp only [ArcData.Admissible, Admissible, arc, Nat.cast_add]

lemma arc_good (x s u v : ℕ) (huv : u < v) :
    (C.arc x s).Good u v ↔ C.Good (x + u) (x + v) := by
  have hv : 1 ≤ v := by omega
  have h₁ : x + u + 1 = x + (u + 1) := by omega
  have h₂ : x + v - 1 = x + (v - 1) := by omega
  simp only [ArcData.Good, Good, h₁, h₂, ← C.arc_admissible x s]
  constructor
  · rintro (h | h)
    · exact Or.inl (by omega)
    · exact Or.inr h
  · rintro (h | h)
    · exact Or.inl (by omega)
    · exact Or.inr h

lemma bad_exterior_boundary (x s : ℕ) (hs : 0 < s) (P : L)
    (hP₀ : P ∈ (C.arc x s).sets 0) (hPₛ : P ∈ (C.arc x s).sets s)
    (hbad : ¬ C.ExteriorGood x (x + s)) :
    (C.arc x s).labels 0 = P ∨ (C.arc x s).labels (s - 1) = P := by
  by_contra h
  push Not at h
  rcases h with ⟨hleft, hright⟩
  have hcast : (↑(s - 1) : ℤ) = (s : ℤ) - 1 := by omega
  simp only [arc, Nat.cast_zero, add_zero] at hleft hP₀
  simp only [arc, hcast] at hright
  have h₀ : P = C.labels ((x : ℤ) - 1) := by
    simpa only [sets, Finset.mem_insert, Finset.mem_singleton, or_iff_left hleft.symm] using hP₀
  have hₛ : P = C.labels ((x : ℤ) + s) := by
    have hne : P ≠ C.labels ((x : ℤ) + s - 1) := by
      intro hh
      apply hright
      convert hh.symm using 1
      congr 1
      omega
    simpa only [arc, sets, Finset.mem_insert, Finset.mem_singleton, or_iff_right hne] using hPₛ
  apply hbad
  right
  refine ⟨P, ?_, ?_⟩
  · simp only [sets, Finset.mem_insert, Finset.mem_singleton]
    left
    convert hₛ using 1
    congr 1
    push_cast
    omega
  · simp only [sets, Finset.mem_insert, Finset.mem_singleton]
    exact Or.inr h₀

structure Cell (x p q y : ℕ) : Prop where
  first_pos : x < p
  middle_pos : p < q
  third_pos : q < y
  odd_first : (p - x) % 2 = 1
  odd_middle : (q - p) % 2 = 1
  odd_third : (y - q) % 2 = 1
  odd_exterior : (m - (y - x)) % 2 = 1
  first : C.Admissible x p
  middle : C.Admissible p q
  third : C.Admissible q y
  exterior : C.Admissible y x
  some_good : (C.Good x p ∧ C.Good q y) ∨ (C.Good p q ∧ C.ExteriorGood x y)
  outer_long : 1 < p - x → 1 < y - q → C.Good p q ∧ C.ExteriorGood x y
  middle_exterior_long : 1 < q - p → 1 < m - (y - x) → C.Good x p ∧ C.Good q y

inductive Subdivision (C : CycleData G m) : ℕ → ℕ → Type _ where
  | edge {x y} (short : y = x + 1) : Subdivision C x y
  | node {x p q y} (cell : C.Cell x p q y)
      (first : Subdivision C x p) (middle : Subdivision C p q)
      (third : Subdivision C q y) : Subdivision C x y

lemma cell_of_split (x s : ℕ) (hm : m % 2 = 0) (hs : s % 2 = 1)
    (hbound : x + s < m) (hadm : C.Admissible x (x + s))
    (T : (C.arc x s).Split (C.ExteriorGood x (x + s))) :
    C.Cell x (x + T.p₁) (x + T.p₂) (x + s) := by
  have h₁ := T.positive
  have h₂ := T.ordered
  have h₃ := T.inside
  have ho := T.odd₁
  have he := T.even₂
  have ha₁ : C.Admissible x (x + T.p₁) := by
    simpa only [Nat.add_zero] using (C.arc_admissible x s 0 T.p₁).mp T.first
  have ha₂ := (C.arc_admissible x s T.p₁ T.p₂).mp T.middle
  have ha₃ := (C.arc_admissible x s T.p₂ s).mp T.third
  have hae : C.Admissible (x + s) x := by
    obtain ⟨l, hl₁, hl₂⟩ := hadm
    exact ⟨l, hl₂, hl₁⟩
  have g₁ : (C.arc x s).Good 0 T.p₁ → C.Good x (x + T.p₁) := by
    intro h
    simpa only [Nat.add_zero] using (C.arc_good x s 0 T.p₁ h₁).mp h
  have g₂ := (C.arc_good x s T.p₁ T.p₂ h₂).mp
  have g₃ := (C.arc_good x s T.p₂ s h₃).mp
  refine ⟨by omega, by omega, by omega, by omega, by omega, by omega, by omega,
      ha₁, ha₂, ha₃, hae, ?_, ?_, ?_⟩
  · rcases T.some_good with ⟨hf, ht⟩ | ⟨hm, hg⟩
    · exact Or.inl ⟨g₁ hf, g₃ ht⟩
    · exact Or.inr ⟨g₂ hm, hg⟩
  · intro hf ht
    obtain ⟨hm, hg⟩ := T.outer_long (by omega) (by omega)
    exact ⟨g₂ hm, hg⟩
  · intro hmiddle _
    obtain ⟨hf, ht⟩ := T.middle_long (by omega)
    exact ⟨g₁ hf, g₃ ht⟩

theorem quadrangulate_arc (hG : G.IsAcyclic) (heven : m % 2 = 0)
    (s : ℕ) : ∀ x, 0 < s → s % 2 = 1 → x + s < m →
      C.Admissible x (x + s) → Nonempty (Subdivision C x (x + s)) := by
  induction s using Nat.strong_induction_on with
  | h s ih =>
    intro x hs hsodd hbound hadm
    by_cases hshort : s = 1
    · exact ⟨.edge (by omega)⟩
    have hslarge : 3 ≤ s := by omega
    obtain ⟨P, hP₀, hPₛ⟩ := hadm
    have hP₀' : P ∈ (C.arc x s).sets 0 := by simpa only [arc, Nat.cast_zero, add_zero] using hP₀
    have hPₛ' : P ∈ (C.arc x s).sets s := by simpa only [arc, Nat.cast_add] using hPₛ
    obtain ⟨T⟩ := (C.arc x s).split hG (C.ExteriorGood x (x + s)) hslarge hsodd P
      hP₀' hPₛ' (C.bad_exterior_boundary x s hs P hP₀' hPₛ')
    have h₁ := T.positive
    have h₂ := T.ordered
    have h₃ := T.inside
    have ho := T.odd₁
    have he := T.even₂
    have cell := C.cell_of_split x s heven hsodd hbound ⟨P, hP₀, hPₛ⟩ T
    obtain ⟨Q₁⟩ := ih T.p₁ (by omega) x h₁ ho (by omega) cell.first
    have eq₂ : x + T.p₁ + (T.p₂ - T.p₁) = x + T.p₂ := by omega
    have eq₃ : x + T.p₂ + (s - T.p₂) = x + s := by omega
    obtain ⟨Q₂⟩ := ih (T.p₂ - T.p₁) (by omega) (x + T.p₁) (by omega) (by omega)
      (by omega) (by simpa only [eq₂] using cell.middle)
    obtain ⟨Q₃⟩ := ih (s - T.p₂) (by omega) (x + T.p₂) (by omega) (by omega)
      (by omega) (by simpa only [eq₃] using cell.third)
    rw [eq₂] at Q₂
    rw [eq₃] at Q₃
    exact ⟨.node cell Q₁ Q₂ Q₃⟩

theorem quadrangulate (hG : G.IsAcyclic) (hm : 4 ≤ m) (heven : m % 2 = 0) :
    Nonempty (Subdivision C 0 (m - 1)) := by
  have hclose : C.labels ((m : ℤ) - 1) = C.labels (-1) := by
    calc
      C.labels ((m : ℤ) - 1) = C.labels (-1 + (m : ℤ)) := congrArg C.labels (by omega)
      _ = C.labels (-1) := C.periodic (-1)
  have hadm : C.Admissible 0 (0 + (m - 1)) := by
    refine ⟨C.labels (-1), ?_, ?_⟩
    · simp [sets]
    · simp only [Nat.zero_add, sets, Finset.mem_insert, Finset.mem_singleton]
      right
      rw [← hclose]
      congr 1
      omega
  simpa only [Nat.zero_add] using
    C.quadrangulate_arc hG heven (m - 1) 0 (by omega) (by omega) (by omega) hadm

namespace Subdivision

variable {C} {x y : ℕ}

def cells : {x y : ℕ} → Subdivision C x y → ℕ
  | _, _, .edge _ => 0
  | _, _, .node _ Q₁ Q₂ Q₃ => 1 + Q₁.cells + Q₂.cells + Q₃.cells

def leaves : {x y : ℕ} → Subdivision C x y → ℕ
  | _, _, .edge _ => 1
  | _, _, .node _ Q₁ Q₂ Q₃ => Q₁.leaves + Q₂.leaves + Q₃.leaves

lemma cells_length (Q : Subdivision C x y) : 2 * Q.cells + 1 + x = y := by
  induction Q with
  | edge h => simp only [cells]; omega
  | node cell Q₁ Q₂ Q₃ h₁ h₂ h₃ => simp only [cells]; omega

lemma leaves_length (Q : Subdivision C x y) : Q.leaves + x = y := by
  induction Q with
  | edge h => simp only [leaves]; omega
  | node cell Q₁ Q₂ Q₃ h₁ h₂ h₃ => simp only [leaves]; omega

def interiorDiagonals (Q : Subdivision C x y) : ℕ := Q.cells - 1

lemma counts (hm : 4 ≤ m) (Q : Subdivision C 0 (m - 1)) :
    Q.cells = (m - 2) / 2 ∧ Q.interiorDiagonals = (m - 4) / 2 ∧
    Q.leaves = m - 1 := by
  have hc := Q.cells_length
  have hl := Q.leaves_length
  simp only [interiorDiagonals]
  omega

def sumCells : {x y : ℕ} → Subdivision C x y → (ℕ → ℕ → ℕ → ℕ → ℝ) → ℝ
  | _, _, .edge _, _ => 0
  | x, y, .node (p := p) (q := q) _ Q₁ Q₂ Q₃, localTerm =>
      localTerm x p q y + Q₁.sumCells localTerm + Q₂.sumCells localTerm + Q₃.sumCells localTerm

lemma signed_cancellation (Q : Subdivision C x y)
    (gain : ℕ → ℕ → ℝ) (localTerm : ℕ → ℕ → ℕ → ℕ → ℝ)
    (hshort : ∀ x, gain x (x + 1) = 0)
    (hcell : ∀ x p q y, C.Cell x p q y →
      gain x y = localTerm x p q y + gain x p + gain p q + gain q y) :
    gain x y = Q.sumCells localTerm := by
  induction Q with
  | edge h => simpa only [h, sumCells] using hshort _
  | node cell Q₁ Q₂ Q₃ h₁ h₂ h₃ =>
    simpa only [sumCells, h₁, h₂, h₃] using hcell _ _ _ _ cell

end Subdivision

end CycleData

end MatchingFPRAS.Cells

namespace MatchingFPRAS.Transport

variable {V E L : Type*}

namespace IndexedCycle

variable {inc : E → V → Prop} (c : IndexedCycle inc)

def zindex (i : ℤ) : Fin c.size :=
  ⟨(i % (c.size : ℤ)).toNat, (Int.toNat_lt (Int.emod_nonneg _ (by
    have := c.four_le; omega))).mpr (Int.emod_lt_of_pos _ (by have := c.four_le; omega))⟩

def vertexAtZ (i : ℤ) : V := c.vertex (c.zindex i)

def edgeAtZ (i : ℤ) : E := c.edge (c.zindex i)

lemma zindex_nat (i : ℕ) : c.zindex i = c.index i := by
  apply Fin.ext
  change ((i : ℤ) % (c.size : ℤ)).toNat = i % c.size
  rw [← Int.natCast_emod, Int.toNat_natCast]

lemma zindex_periodic (i : ℤ) : c.zindex (i + c.size) = c.zindex i := by
  apply Fin.ext
  simp [zindex]

lemma vertexAtZ_nat (i : ℕ) : c.vertexAtZ i = c.vertexAt i := by
  simp [vertexAtZ, vertexAt, c.zindex_nat]

lemma edgeAtZ_nat (i : ℕ) : c.edgeAtZ i = c.edgeAt i := by
  simp [edgeAtZ, edgeAt, c.zindex_nat]

lemma vertexAtZ_periodic (i : ℤ) : c.vertexAtZ (i + c.size) = c.vertexAtZ i := by
  simp [vertexAtZ, c.zindex_periodic]

lemma edgeAtZ_periodic (i : ℤ) : c.edgeAtZ (i + c.size) = c.edgeAtZ i := by
  simp [edgeAtZ, c.zindex_periodic]

lemma zindex_succ (i : ℤ) : c.zindex (i + 1) =
    ⟨((c.zindex i).val + 1) % c.size, Nat.mod_lt _ (by have := c.four_le; omega)⟩ := by
  have hsz : (c.size : ℤ) ≠ 0 := by have := c.four_le; omega
  apply Fin.ext
  apply Int.natCast_inj.mp
  change (((i + 1) % (c.size : ℤ)).toNat : ℤ) =
    (((((i % (c.size : ℤ)).toNat + 1) % c.size) : ℕ) : ℤ)
  rw [Int.toNat_of_nonneg (Int.emod_nonneg _ hsz), Int.natCast_emod,
    Nat.cast_add, Nat.cast_one, Int.toNat_of_nonneg (Int.emod_nonneg _ hsz)]
  simp only [Int.add_emod, Int.emod_emod]

lemma edgeAtZ_incidence (i : ℤ) (v : V) :
    inc (c.edgeAtZ i) v ↔ v = c.vertexAtZ i ∨ v = c.vertexAtZ (i+1) := by
  simpa [edgeAtZ, vertexAtZ, c.zindex_succ] using c.incidence (c.zindex i) v

end IndexedCycle

namespace BagEdge

variable {bags : V → Finset L}

def color (e : BagEdge bags) : L := e.val.color

lemma color_mem (e : BagEdge bags) {v : V} (hv : e.Incident v) : e.color ∈ bags v :=
  e.property v hv

def ofEndpoints (v w : V) (hvw : v ≠ w) (l : L)
    (hlv : l ∈ bags v) (hlw : l ∈ bags w) : BagEdge bags :=
  ⟨⟨(s(v,w),l), by simpa using hvw⟩, by
    intro u hu
    change u ∈ s(v,w) at hu
    change l ∈ bags u
    rcases Sym2.mem_iff.mp hu with rfl | rfl
    · exact hlv
    · exact hlw⟩

lemma ofEndpoints_incidence (v w : V) (hvw : v ≠ w) (l : L)
    (hlv : l ∈ bags v) (hlw : l ∈ bags w) (u : V) :
    (ofEndpoints v w hvw l hlv hlw).Incident u ↔ u = v ∨ u = w :=
  Sym2.mem_iff

lemma ofEndpoints_color (v w : V) (hvw : v ≠ w) (l : L)
    (hlv : l ∈ bags v) (hlw : l ∈ bags w) :
    (ofEndpoints v w hvw l hlv hlw).color = l := rfl

end BagEdge

end MatchingFPRAS.Transport

end OAI