import Mathlib
import OAI.Combinatorics.MatchingCount.Graphs.ColoredEdge

namespace OAI

namespace MatchingFPRAS.Transport
variable {V L : Type*} [DecidableEq V]
variable {E : Type*} [DecidableEq E] (inc : E → V → Prop)
namespace OddPath

variable {inc}

variable (p : OddPath inc)

def span : Finset V := (Finset.Icc 0 p.length).image p.vertex

def inside : Finset V := (Finset.Icc 1 (p.length - 1)).image p.vertex

def ends : Finset V := {p.vertex 0, p.vertex p.length}

def through : Finset E := pathPattern p.edge 0 p.length

def interior : Finset E := pathPattern p.edge 1 (p.length - 1)

def closed (chord : E) : Finset E := p.interior ∪ {chord}

def boundary : Finset E := if p.length = 1 then {p.edge 0}
  else {p.edge 0, p.edge (p.length - 1)}

def repaired (repair : E) : Finset E := if p.length = 1 then ∅
  else pathPattern p.edge 2 (p.length - 2) ∪ {repair}

def repairAdded (repair : E) : Multiset E := if p.length = 1 then 0 else {repair}

lemma through_matching : MatchingOn inc p.through p.span := by
  apply pathPattern_matching inc p.vertex p.edge 0 p.length p.positive
  · simpa using p.odd
  · exact p.simple
  · intro i _ hi v
    exact p.incidence i hi v

lemma interior_matching : MatchingOn inc p.interior p.inside := by
  by_cases h : p.length = 1
  · simpa [interior, inside, h, pathPattern] using
      (empty_matching (V := V) (E := E) inc)
  · have hpos := p.positive
    have hodd := p.odd
    apply pathPattern_matching inc p.vertex p.edge 1 (p.length - 1)
    · omega
    · omega
    · intro i hi j hj heq
      simp only [Set.mem_Icc] at hi hj
      exact p.simple ⟨by omega, by omega⟩ ⟨by omega, by omega⟩ heq
    · intro i hi hj v
      exact p.incidence i (by omega) v

omit [DecidableEq E] in
lemma inside_disjoint_ends : Disjoint p.inside p.ends := by
  apply Finset.disjoint_left.mpr
  intro v hv hw
  obtain ⟨i, hi, rfl⟩ := Finset.mem_image.mp hv
  obtain ⟨hil, hih⟩ := Finset.mem_Icc.mp hi
  simp only [ends, Finset.mem_insert, Finset.mem_singleton] at hw
  rcases hw with h | h
  · have hh := p.simple ⟨by omega, by omega⟩ ⟨le_rfl, Nat.zero_le _⟩ h
    omega
  · have hh := p.simple ⟨by omega, by omega⟩ ⟨Nat.zero_le _, le_rfl⟩ h
    omega

omit [DecidableEq E] in
lemma inside_union_ends : p.inside ∪ p.ends = p.span := by
  ext v
  simp only [inside, ends, span, Finset.mem_union, Finset.mem_image,
    Finset.mem_Icc, Finset.mem_insert, Finset.mem_singleton]
  constructor
  · rintro (⟨i, hi, rfl⟩ | rfl | rfl)
    · exact ⟨i, ⟨by omega, by omega⟩, rfl⟩
    · exact ⟨0, ⟨le_rfl, Nat.zero_le _⟩, rfl⟩
    · exact ⟨p.length, ⟨Nat.zero_le _, le_rfl⟩, rfl⟩
  · rintro ⟨i, hi, rfl⟩
    by_cases h0 : i = 0
    · exact Or.inr (Or.inl (congrArg p.vertex h0))
    by_cases hh : i = p.length
    · exact Or.inr (Or.inr (congrArg p.vertex hh))
    · exact Or.inl ⟨i, ⟨by omega, by omega⟩, rfl⟩

lemma closed_matching (chord : E)
    (hc : ∀ v, inc chord v ↔ v = p.vertex 0 ∨ v = p.vertex p.length) :
    MatchingOn inc (p.closed chord) p.span := by
  have hm := p.interior_matching.union (singleton_matching inc chord _ _ hc)
    p.inside_disjoint_ends
  change MatchingOn inc (p.closed chord) (p.inside ∪ p.ends) at hm
  rwa [p.inside_union_ends] at hm

lemma repaired_matching (repair : E)
    (hr : p.length ≠ 1 → ∀ v,
      inc repair v ↔ v = p.vertex 1 ∨ v = p.vertex (p.length - 1)) :
    MatchingOn inc (p.repaired repair) p.inside := by
  by_cases h : p.length = 1
  · simpa [repaired, inside, h] using (empty_matching (V := V) (E := E) inc)
  · have hpos := p.positive
    have hodd := p.odd
    simp only [repaired, ite_eq_right h]
    simpa only [Nat.zero_add, inside] using repairedThrough_matching inc p.vertex p.edge 0
      p.length (by omega) (by simpa using p.odd) p.simple
      (fun i _ hi v => p.incidence i hi v) repair (hr h)

lemma closed_val (chord : E)
    (hc : ∀ v, inc chord v ↔ v = p.vertex 0 ∨ v = p.vertex p.length)
    (hinc : ∀ e, ∃ v, inc e v) :
    (p.closed chord).val = p.interior.val + {chord} := by
  apply union_val_add
  exact p.interior_matching.disjoint_edges (singleton_matching inc chord _ _ hc)
    hinc p.inside_disjoint_ends

omit [DecidableEq V] [DecidableEq E] in
lemma edge_injective : Set.InjOn p.edge (Set.Ico 0 p.length) := by
  intro i hi j hj heq
  simp only [Set.mem_Ico] at hi hj
  have hiinc : inc (p.edge i) (p.vertex i) := (p.incidence i hi.2 _).mpr (Or.inl rfl)
  rw [heq] at hiinc
  have hjinc : inc (p.edge j) (p.vertex (i+1)) := by
    rw [← heq]
    exact (p.incidence i hi.2 _).mpr (Or.inr rfl)
  have hi₁ := (p.incidence j hj.2 _).mp hiinc
  have hi₂ := (p.incidence j hj.2 _).mp hjinc
  have hs₁ : i = j ∨ i = j + 1 := hi₁.imp
    (p.simple ⟨by omega, by omega⟩ ⟨by omega, by omega⟩)
    (p.simple ⟨by omega, by omega⟩ ⟨by omega, by omega⟩)
  have hs₂ : i+1 = j ∨ i+1 = j+1 := hi₂.imp
    (p.simple ⟨by omega, by omega⟩ ⟨by omega, by omega⟩)
    (p.simple ⟨by omega, by omega⟩ ⟨by omega, by omega⟩)
  omega

omit [DecidableEq V] in
lemma boundary_card : p.boundary.card = if p.length = 1 then 1 else 2 := by
  by_cases h : p.length = 1
  · simp [boundary, h]
  · have hpos := p.positive
    have hodd := p.odd
    have hneq : p.edge 0 ≠ p.edge (p.length - 1) := by
      intro heq
      have hh := p.edge_injective ⟨le_rfl, hpos⟩ ⟨by omega, by omega⟩ heq
      omega
    simp [boundary, h, hneq]

omit [DecidableEq V] in
lemma repair_conservation (repair : E)
    (hr : p.length ≠ 1 → ∀ v,
      inc repair v ↔ v = p.vertex 1 ∨ v = p.vertex (p.length - 1))
    (_hinc : ∀ e, ∃ v, inc e v) :
    (p.repaired repair).val + p.boundary.val = p.through.val + p.repairAdded repair := by
  by_cases h : p.length = 1
  · have ht : p.through = {p.edge 0} := by simp [through, pathPattern, h, Finset.filter_singleton]
    simp only [repaired, boundary, repairAdded, ite_eq_left h, ht, Finset.empty_val,
      zero_add, add_zero]
  · have hpos := p.positive
    have hodd := p.odd
    have hlen : 3 ≤ p.length := by omega
    let trim := pathPattern p.edge 2 (p.length - 2)
    have ht : p.through = trim ∪ p.boundary := by
      simpa only [through, trim, Nat.zero_add, boundary, ite_eq_right h] using
        pathPattern_boundary p.edge 0 p.length hlen (by simpa using hodd)
    have hbdis : Disjoint trim p.boundary := by
      apply Finset.disjoint_left.mpr
      intro e he hb
      obtain ⟨i, hi, rfl⟩ := Finset.mem_image.mp he
      obtain ⟨hi, _⟩ := Finset.mem_filter.mp hi
      obtain ⟨hil, hih⟩ := Finset.mem_Ico.mp hi
      simp only [boundary, ite_eq_right h, Finset.mem_insert, Finset.mem_singleton] at hb
      rcases hb with hh | hh
      · have hh' := p.edge_injective ⟨by omega, by omega⟩ ⟨by omega, by omega⟩ hh
        omega
      · have hh' := p.edge_injective ⟨by omega, by omega⟩ ⟨by omega, by omega⟩ hh
        omega
    have hrdis : Disjoint trim {repair} := by
      apply Finset.disjoint_left.mpr
      intro e he hr'
      obtain ⟨i, hi, rfl⟩ := Finset.mem_image.mp he
      obtain ⟨hi, _⟩ := Finset.mem_filter.mp hi
      obtain ⟨hil, hih⟩ := Finset.mem_Ico.mp hi
      have heq := Finset.mem_singleton.mp hr'
      have hiinc : inc repair (p.vertex i) := by
        rw [← heq]
        exact (p.incidence i (by omega) _).mpr (Or.inl rfl)
      rcases (hr h _).mp hiinc with hh | hh
      · have hh' := p.simple ⟨by omega, by omega⟩ ⟨by omega, by omega⟩ hh
        omega
      · have hh' := p.simple ⟨by omega, by omega⟩ ⟨by omega, by omega⟩ hh
        omega
    rw [ht, union_val_add hbdis]
    simp only [repaired, ite_eq_right h, repairAdded]
    rw [union_val_add hrdis]
    simp only [Finset.singleton_val]
    ac_rfl

end OddPath

structure CellPaths where
  side : Fin 4 → OddPath inc
  joins : ∀ i, (side i).vertex (side i).length = (side (i+1)).vertex 0
  corners_injective : Function.Injective fun i => (side i).vertex 0
  interiors_disjoint : Pairwise fun i j => Disjoint (side i).inside (side j).inside
  interior_ends_disjoint : ∀ i j, Disjoint (side i).inside (side j).ends
  chord : Fin 4 → E
  chord_incidence : ∀ i v, inc (chord i) v ↔
    v = (side i).vertex 0 ∨ v = (side i).vertex (side i).length

end MatchingFPRAS.Transport

end OAI