import Mathlib
import OAI.Combinatorics.MatchingCount.Sampling.Corner

namespace OAI

namespace MatchingFPRAS.Transport

section

variable {V E : Type*}

variable (inc : E → V → Prop)

structure IndexedCycle where
  size : ℕ
  four_le : 4 ≤ size
  even : size % 2 = 0
  vertex : Fin size → V
  simple : Function.Injective vertex
  edge : Fin size → E
  incidence : ∀ i v, inc (edge i) v ↔ v = vertex i ∨ v = vertex ⟨(i.val + 1) % size, Nat.mod_lt _ (by omega)⟩

namespace IndexedCycle

variable {inc} (c : IndexedCycle inc)

def index (i : ℕ) : Fin c.size := ⟨i % c.size, Nat.mod_lt i (by have := c.four_le; omega)⟩

def vertexAt (i : ℕ) : V := c.vertex (c.index i)

def edgeAt (i : ℕ) : E := c.edge (c.index i)

lemma index_succ (i : ℕ) : c.index (i + 1) = ⟨((c.index i).val + 1) % c.size, Nat.mod_lt _ (by have := c.four_le; omega)⟩ := by
  apply Fin.ext
  simp only [index, Nat.add_mod, Nat.mod_mod]

lemma vertexAt_mod (i : ℕ) : c.vertexAt (i % c.size) = c.vertexAt i := by
  exact congrArg c.vertex (Fin.ext (Nat.mod_mod i c.size))

lemma vertexAt_periodic (i : ℕ) : c.vertexAt (i + c.size) = c.vertexAt i := by
  simp [vertexAt, index]

lemma edgeAt_incidence (i : ℕ) (v : V) :
    inc (c.edgeAt i) v ↔ v = c.vertexAt i ∨ v = c.vertexAt (i + 1) := by
  simpa [edgeAt, vertexAt, c.index_succ] using c.incidence (c.index i) v

lemma mod_of_lt_twice {m x : ℕ} (hx : x < 2 * m) :
    x % m = if x < m then x else x - m := by
  split_ifs with h
  · exact Nat.mod_eq_of_lt h
  · rw [Nat.mod_eq_sub_mod (by omega), Nat.mod_eq_of_lt (by omega)]

lemma vertexAt_eq_iff {a x y : ℕ} (ha : a < c.size)
    (hx : a ≤ x ∧ x < a + c.size) (hy : a ≤ y ∧ y < a + c.size) :
    c.vertexAt x = c.vertexAt y ↔ x = y := by
  constructor
  · intro h
    have hm : x % c.size = y % c.size := congrArg Fin.val (c.simple h)
    rw [mod_of_lt_twice (by omega), mod_of_lt_twice (by omega)] at hm
    split_ifs at hm <;> omega
  · exact congrArg c.vertexAt

def arc (start length : ℕ) (hstart : start < c.size) (hpos : 0 < length)
    (hlt : length < c.size) (hodd : length % 2 = 1) : OddPath inc where
  length := length
  positive := hpos
  odd := hodd
  vertex i := c.vertexAt (start + i)
  edge i := c.edgeAt (start + i)
  simple := by
    intro i hi j hj h
    change 0 ≤ i ∧ i ≤ length at hi
    change 0 ≤ j ∧ j ≤ length at hj
    have := (c.vertexAt_eq_iff hstart
      (x := start + i) (y := start + j) (by constructor <;> omega)
      (by constructor <;> omega)).mp h
    omega
  incidence := by
    intro i hi v
    simpa [Nat.add_assoc] using c.edgeAt_incidence (start + i) v

structure Corners where
  a₀ : ℕ
  a₁ : ℕ
  a₂ : ℕ
  a₃ : ℕ
  lt₀ : a₀ < a₁
  lt₁ : a₁ < a₂
  lt₂ : a₂ < a₃
  lt₃ : a₃ < c.size
  odd₀ : (a₁ - a₀) % 2 = 1
  odd₁ : (a₂ - a₁) % 2 = 1
  odd₂ : (a₃ - a₂) % 2 = 1
  odd₃ : (c.size + a₀ - a₃) % 2 = 1

namespace Corners

variable {c} (k : c.Corners)

def start : Fin 4 → ℕ := ![k.a₀, k.a₁, k.a₂, k.a₃]

def stop : Fin 4 → ℕ := ![k.a₁, k.a₂, k.a₃, c.size + k.a₀]

def length (i : Fin 4) : ℕ := k.stop i - k.start i

lemma bounds (i : Fin 4) :
    k.a₀ ≤ k.start i ∧ k.start i < c.size ∧
    k.start i < k.stop i ∧ k.stop i ≤ k.a₀ + c.size ∧
    k.stop i < k.start i + c.size := by
  have h₀ := k.lt₀
  have h₁ := k.lt₁
  have h₂ := k.lt₂
  have h₃ := k.lt₃
  fin_cases i <;> simp [start, stop] <;> omega

lemma length_pos (i : Fin 4) : 0 < k.length i := by
  have := k.bounds i
  dsimp [length]
  omega

lemma length_lt (i : Fin 4) : k.length i < c.size := by
  have := k.bounds i
  dsimp [length]
  omega

lemma length_odd (i : Fin 4) : k.length i % 2 = 1 := by
  fin_cases i
  · exact k.odd₀
  · exact k.odd₁
  · exact k.odd₂
  · exact k.odd₃

def side (i : Fin 4) : OddPath inc :=
  c.arc (k.start i) (k.length i) (k.bounds i).2.1 (k.length_pos i)
    (k.length_lt i) (k.length_odd i)

lemma side_vertex (i : Fin 4) (j : ℕ) :
    (k.side i).vertex j = c.vertexAt (k.start i + j) := rfl

lemma side_length (i : Fin 4) : (k.side i).length = k.length i := rfl

lemma side_first (i : Fin 4) : (k.side i).vertex 0 = c.vertexAt (k.start i) := by
  simp [side_vertex]

lemma side_last (i : Fin 4) : (k.side i).vertex (k.side i).length =
    c.vertexAt (k.stop i) := by
  rw [side_vertex, side_length]
  congr 1
  dsimp [length]
  have := k.bounds i
  omega

lemma joins (i : Fin 4) : (k.side i).vertex (k.side i).length =
    (k.side (i + 1)).vertex 0 := by
  rw [side_last, side_first]
  fin_cases i <;> simp [start, stop]
  simpa only [Nat.add_comm] using c.vertexAt_periodic k.a₀

lemma starts_injective : Function.Injective k.start := by
  have h₀ := k.lt₀
  have h₁ := k.lt₁
  have h₂ := k.lt₂
  intro i j h
  fin_cases i <;> fin_cases j <;> simp_all [start] <;> omega

lemma corners_injective : Function.Injective fun i => (k.side i).vertex 0 := by
  intro i j h
  simp only [side_first] at h
  have hi := k.bounds i
  have hj := k.bounds j
  have ha : k.a₀ < c.size := by have := k.lt₀; omega
  apply k.starts_injective
  exact (c.vertexAt_eq_iff ha ⟨hi.1, by omega⟩ ⟨hj.1, by omega⟩).mp h

variable [DecidableEq V]

lemma inside_iff (i : Fin 4) (v : V) :
    v ∈ (k.side i).inside ↔
      ∃ t, k.start i < t ∧ t < k.stop i ∧ c.vertexAt t = v := by
  simp only [OddPath.inside, Finset.mem_image, Finset.mem_Icc, side_length, side_vertex]
  constructor
  · rintro ⟨j, hj, h⟩
    refine ⟨k.start i + j, by omega, ?_, h⟩
    have := k.bounds i
    dsimp [length] at hj
    omega
  · rintro ⟨t, hlow, hhigh, h⟩
    refine ⟨t - k.start i, ?_, ?_⟩
    · dsimp [length]
      constructor <;> omega
    · have he : k.start i + (t - k.start i) = t := by omega
      simpa [he] using h

omit [DecidableEq V] in
lemma interior_ranges_disjoint (i j : Fin 4) (hij : i ≠ j) (t : ℕ)
    (hi : k.start i < t ∧ t < k.stop i) :
    ¬ (k.start j < t ∧ t < k.stop j) := by
  have h₀ := k.lt₀
  have h₁ := k.lt₁
  have h₂ := k.lt₂
  have h₃ := k.lt₃
  fin_cases i <;> fin_cases j <;> simp_all [start, stop] <;> omega

lemma interiors_disjoint : Pairwise fun i j => Disjoint (k.side i).inside (k.side j).inside := by
  intro i j hij
  apply Finset.disjoint_left.mpr
  intro v hv hw
  obtain ⟨x, hx₁, hx₂, hx⟩ := (k.inside_iff i v).mp hv
  obtain ⟨y, hy₁, hy₂, hy⟩ := (k.inside_iff j v).mp hw
  have hi := k.bounds i
  have hj := k.bounds j
  have ha : k.a₀ < c.size := by have := k.lt₀; omega
  have hxy := (c.vertexAt_eq_iff ha (x := x) (y := y)
    ⟨by omega, by omega⟩ ⟨by omega, by omega⟩).mp (hx.trans hy.symm)
  subst y
  exact k.interior_ranges_disjoint i j hij x ⟨hx₁, hx₂⟩ ⟨hy₁, hy₂⟩

omit [DecidableEq V] in
lemma interior_not_corner_index (i j : Fin 4) (t : ℕ)
    (ht : k.start i < t ∧ t < k.stop i) : t ≠ k.start j := by
  have h₀ := k.lt₀
  have h₁ := k.lt₁
  have h₂ := k.lt₂
  have h₃ := k.lt₃
  fin_cases i <;> fin_cases j <;> simp_all [start, stop] <;> omega

lemma interior_ne_corner (i j : Fin 4) {v : V} (hv : v ∈ (k.side i).inside) :
    v ≠ (k.side j).vertex 0 := by
  intro heq
  obtain ⟨t, ht₁, ht₂, ht⟩ := (k.inside_iff i v).mp hv
  have hi := k.bounds i
  have hj := k.bounds j
  have ha : k.a₀ < c.size := by have := k.lt₀; omega
  have h := (c.vertexAt_eq_iff ha (x := t) (y := k.start j)
    ⟨by omega, by omega⟩ ⟨hj.1, by omega⟩).mp (ht.trans (by simpa [side_first] using heq))
  exact k.interior_not_corner_index i j t ⟨ht₁, ht₂⟩ h

lemma interior_ends_disjoint (i j : Fin 4) : Disjoint (k.side i).inside (k.side j).ends := by
  apply Finset.disjoint_left.mpr
  intro v hv hw
  simp only [OddPath.ends, Finset.mem_insert, Finset.mem_singleton, k.joins] at hw
  exact hw.elim (k.interior_ne_corner i j hv) (k.interior_ne_corner i (j+1) hv)

def cellPaths (chord : Fin 4 → E)
    (hchord : ∀ i v, inc (chord i) v ↔
      v = (k.side i).vertex 0 ∨ v = (k.side i).vertex (k.side i).length) : CellPaths inc where
  side := k.side
  joins := k.joins
  corners_injective := k.corners_injective
  interiors_disjoint := k.interiors_disjoint
  interior_ends_disjoint := k.interior_ends_disjoint
  chord := chord
  chord_incidence := hchord

end Corners

end IndexedCycle

end

variable {V E : Type*}

variable {inc : E → V → Prop}

namespace IndexedCycle

variable (c : IndexedCycle inc)

lemma edgeAt_mod (i : ℕ) : c.edgeAt (i % c.size) = c.edgeAt i := by
  exact congrArg c.edge (Fin.ext (Nat.mod_mod i c.size))

lemma consecutive_ne (i : ℕ) (hi : i < c.size) : c.edgeAt i ≠ c.edgeAt (i+1) := by
  intro he
  have hm : inc (c.edgeAt (i+1)) (c.vertexAt i) := he ▸
    (c.edgeAt_incidence i _).mpr (Or.inl rfl)
  rcases (c.edgeAt_incidence (i+1) _).mp hm with h | h
  · have := (c.vertexAt_eq_iff hi (x := i) (y := i+1)
      (by have := c.four_le; omega) (by have := c.four_le; omega)).mp h
    omega
  · have := (c.vertexAt_eq_iff hi (x := i) (y := i+1+1)
      (by have := c.four_le; omega) (by have := c.four_le; omega)).mp h
    omega

lemma edges_reachable (U : Finset E) (hU : ∀ i, c.edgeAt i ∈ U) (i : ℕ) :
    (overlayLineGraph inc U).Reachable (c.edgeAt 0) (c.edgeAt i) := by
  suffices hs : ∀ j, j < c.size →
      (overlayLineGraph inc U).Reachable (c.edgeAt 0) (c.edgeAt j) by
    simpa only [c.edgeAt_mod] using hs (i % c.size)
      (Nat.mod_lt i (by have := c.four_le; omega))
  intro j hj
  induction j with
  | zero => exact SimpleGraph.Reachable.refl _
  | succ j ih =>
      apply (ih (by omega)).trans
      apply SimpleGraph.Adj.reachable
      refine ⟨c.consecutive_ne j (by omega), hU j, hU (j+1), ?_⟩
      exact ⟨c.vertexAt (j+1), (c.edgeAt_incidence j _).mpr (Or.inr rfl),
        (c.edgeAt_incidence (j+1) _).mpr (Or.inl rfl)⟩

section

variable [Fintype V] [DecidableEq E]

lemma adjacent_mem_complement {M N : Finset E}
    (hM : MatchingOn inc M Finset.univ) (hN : MatchingOn inc N Finset.univ)
    (hU : ∀ i, c.edgeAt i ∈ M ∪ N) (i : ℕ) (hi : i < c.size) :
    c.edgeAt (i+1) ∈ M ↔ c.edgeAt i ∉ M := by
  have hein := (c.edgeAt_incidence i (c.vertexAt (i+1))).mpr (Or.inr rfl)
  have hfin := (c.edgeAt_incidence (i+1) (c.vertexAt (i+1))).mpr (Or.inl rfl)
  constructor
  · intro hf he
    exact c.consecutive_ne i hi (hM.unique (Finset.mem_univ _) he hein hf hfin)
  · intro he
    have heN := (Finset.mem_union.mp (hU i)).resolve_left he
    rcases Finset.mem_union.mp (hU (i+1)) with hf | hf
    · exact hf
    · exact False.elim (c.consecutive_ne i hi (hN.unique (Finset.mem_univ _) heN hein hf hfin))

lemma cycle_edge_mem_complement {M N : Finset E}
    (hM : MatchingOn inc M Finset.univ) (hN : MatchingOn inc N Finset.univ)
    (hU : ∀ i, c.edgeAt i ∈ M ∪ N) (i : ℕ) :
    c.edgeAt i ∈ N ↔ c.edgeAt i ∉ M := by
  have hm : i % c.size < c.size := Nat.mod_lt i (by have := c.four_le; omega)
  have heq := c.edgeAt_mod i
  have h := c.adjacent_mem_complement hM hN hU (i % c.size) hm
  have hn := c.adjacent_mem_complement hN hM
    (fun j => by rw [Finset.union_comm]; exact hU j) (i % c.size) hm
  constructor
  · intro hiN hiM
    have hjM : c.edgeAt (i % c.size + 1) ∉ M := fun hj => (h.mp hj) (heq.symm ▸ hiM)
    have hjN : c.edgeAt (i % c.size + 1) ∉ N := fun hj => (hn.mp hj) (heq.symm ▸ hiN)
    exact (Finset.mem_union.mp (hU _)).elim hjM hjN
  · intro hiM
    exact (Finset.mem_union.mp (hU i)).resolve_left hiM

lemma cycle_edge_mem_parity {M N : Finset E}
    (hM : MatchingOn inc M Finset.univ) (hN : MatchingOn inc N Finset.univ)
    (hU : ∀ i, c.edgeAt i ∈ M ∪ N) (i : ℕ) :
    c.edgeAt i ∈ M ↔ if i % 2 = 0 then c.edgeAt 0 ∈ M else c.edgeAt 0 ∉ M := by
  have hb : ∀ j, j < c.size →
      (c.edgeAt j ∈ M ↔ if j % 2 = 0 then c.edgeAt 0 ∈ M else c.edgeAt 0 ∉ M) := by
    intro j hj
    induction j with
    | zero => simp
    | succ j ih =>
        rw [c.adjacent_mem_complement hM hN hU j (by omega), ih (by omega)]
        split_ifs <;> first | omega | tauto
  have hh := hb (i % c.size) (Nat.mod_lt i (by have := c.four_le; omega))
  have hdiv : 2 ∣ c.size := Nat.dvd_of_mod_eq_zero c.even
  have hmod : (i % c.size) % 2 = i % 2 := Nat.mod_mod_of_dvd i hdiv
  simpa only [c.edgeAt_mod, hmod] using hh

end

namespace Corners

variable {c} (k : c.Corners)

lemma parity_start (i : Fin 4) :
    k.start i % 2 = if CellPaths.sideBit i then k.a₀ % 2 else 1 - k.a₀ % 2 := by
  have h₀ := k.lt₀
  have h₁ := k.lt₁
  have h₂ := k.lt₂
  have ho₀ := k.odd₀
  have ho₁ := k.odd₁
  have ho₂ := k.odd₂
  fin_cases i <;> simp [start, CellPaths.sideBit] <;> omega

variable [DecidableEq V] [DecidableEq E]

lemma cell_orientation_subset (chord : Fin 4 → E)
    (hc : ∀ i v, inc (chord i) v ↔
      v = (k.side i).vertex 0 ∨ v = (k.side i).vertex (k.side i).length)
    (S : Finset E) (a : ℕ) (ha : a < 2)
    (hS : ∀ t, t % 2 = a → c.edgeAt t ∈ S) :
    (k.cellPaths chord hc).orientation (decide (k.a₀ % 2 = a)) ⊆ S := by
  have hh : ∀ i, (k.cellPaths chord hc).orientationPieces (decide (k.a₀ % 2 = a)) i ⊆ S := by
    intro i e he
    simp only [CellPaths.orientationPieces, CellPaths.pieces] at he
    split_ifs at he with hi
    · obtain ⟨j, hj, rfl⟩ := Finset.mem_image.mp he
      obtain ⟨hb, hp⟩ := Finset.mem_filter.mp hj
      obtain ⟨hjl, hjr⟩ := Finset.mem_Ico.mp hb
      apply hS
      have hs := k.parity_start i
      have hp' : j % 2 = 0 := hp
      change CellPaths.sideBit i = decide (k.a₀ % 2 = a) at hi
      change (k.start i + j) % 2 = a
      rw [Nat.add_mod, hs, hp']
      cases hbit : CellPaths.sideBit i <;> simp_all
      omega
    · obtain ⟨j, hj, rfl⟩ := Finset.mem_image.mp he
      obtain ⟨hb, hp⟩ := Finset.mem_filter.mp hj
      obtain ⟨hjl, hjr⟩ := Finset.mem_Ico.mp hb
      apply hS
      have hs := k.parity_start i
      have hp' : j % 2 = 1 := hp
      change CellPaths.sideBit i ≠ decide (k.a₀ % 2 = a) at hi
      change (k.start i + j) % 2 = a
      rw [Nat.add_mod, hs, hp']
      cases hbit : CellPaths.sideBit i <;> simp_all <;> omega
  intro e he
  change e ∈ CellPaths.assemble _ at he
  simp only [CellPaths.assemble, Finset.mem_union] at he
  rcases he with (he | he) | (he | he)
  · exact hh 0 he
  · exact hh 2 he
  · exact hh 1 he
  · exact hh 3 he

lemma cell_orientation_reachable (chord : Fin 4 → E)
    (hc : ∀ i v, inc (chord i) v ↔
      v = (k.side i).vertex 0 ∨ v = (k.side i).vertex (k.side i).length)
    (U : Finset E) (hU : ∀ i, c.edgeAt i ∈ U) (b : Bool) :
    ∀ e ∈ (k.cellPaths chord hc).orientation b,
      (overlayLineGraph inc U).Reachable (c.edgeAt 0) e := by
  have hh : ∀ i e, e ∈ (k.cellPaths chord hc).orientationPieces b i →
      (overlayLineGraph inc U).Reachable (c.edgeAt 0) e := by
    intro i e he
    simp only [CellPaths.orientationPieces, CellPaths.pieces] at he
    split_ifs at he <;>
      obtain ⟨j, _, rfl⟩ := Finset.mem_image.mp he <;>
      exact c.edges_reachable U hU (k.start i + j)
  intro e he
  change e ∈ CellPaths.assemble _ at he
  simp only [CellPaths.assemble, Finset.mem_union] at he
  rcases he with (he | he) | (he | he)
  · exact hh 0 e he
  · exact hh 2 e he
  · exact hh 1 e he
  · exact hh 3 e he

end Corners

end IndexedCycle

end MatchingFPRAS.Transport

end OAI