import Mathlib
import OAI.Probability.LatticeSurface.Convexity.BoundedBase
import OAI.Probability.LatticeSurface.Geometry.CapReflection
import OAI.Probability.LatticeSurface.Geometry.CapSplit
import OAI.Probability.LatticeSurface.Geometry.CapUnpin
import OAI.Probability.LatticeSurface.Geometry.CapWeld

namespace OAI

noncomputable section

open MeasureTheory Set

open scoped ENNReal

namespace ExtremalEdges

attribute [local instance] Classical.propDecidable

variable {V : Type*}

def squash (w v x : V) : V := if x = w then v else x

def contract (G : SimpleGraph V) (w v : V) : SimpleGraph V := G.map (squash w v)

lemma graph_constraint_map (G : SimpleGraph V) (f : V → V) (h : V → ℝ) :
    (∀ x y, (G.map f).Adj x y → |h x-h y| ≤ 1) ↔
      (∀ x y, G.Adj x y → |h (f x)-h (f y)| ≤ 1) := by
  constructor
  · intro hh x y hxy
    by_cases he : f x = f y
    · simp [he]
    · exact hh _ _ (SimpleGraph.map_adj_apply' hxy he)
  · rintro hh x y ⟨hne,a,b,hab,rfl,rfl⟩
    exact hh a b hab

lemma contracted_body (G : SimpleGraph V) (pins : Set V) (w v : V) :
    conditionalBody (contract G w v) pins (fun _ => 0) = weldBody G pins w v := by
  ext h
  rw [conditionalBody, mem_ofPred_eq, contract, graph_constraint_map]
  have hf : ∀ x, restore pins (fun _ => 0) h (squash w v x) = weldHeight pins w v h x := by
    intro x
    by_cases hx : x = w <;> simp [squash, weldHeight, hx]
  simp only [hf, weldBody, mem_ofPred_eq]

lemma degree_map_singleton [Fintype V] (G : SimpleGraph V) [DecidableRel G.Adj]
    (f : V → V) (a : V) (hf : ∀ x, f x = a → x = a) :
    (G.map f).degree a ≤ G.degree a := by
  classical
  rw [← SimpleGraph.card_neighborFinset_eq_degree, ← SimpleGraph.card_neighborFinset_eq_degree]
  refine (Finset.card_le_card (t := (G.neighborFinset a).image f) ?_).trans (Finset.card_image_le)
  intro y hy
  have hh : (G.map f).Adj a y := by simpa using hy
  rcases hh with ⟨hne,x,z,hxz,hxa,hzy⟩
  have hxa' := hf x hxa
  subst x
  exact Finset.mem_image.mpr ⟨z, by simpa using hxz, hzy⟩

def collapse (W : Finset V) (r : V → V) (x : V) : V := if x ∈ W then r x else x

lemma collapse_empty (r : V → V) : collapse ∅ r = id := by
  funext x; simp [collapse]

lemma collapse_insert {W : Finset V} {w : V} {r : V → V}
    (hw : w ∉ W) (hr : ∀ x ∈ insert w W, r x ∉ insert w W) :
    collapse (insert w W) r = squash w (r w) ∘ collapse W r := by
  classical
  funext x
  have hrr : ∀ y ∈ insert w W, r y ≠ w := fun y hy hh => hr y hy (by simp [hh])
  by_cases hxw : x = w
  · subst x; simp [collapse, squash, hw]
  · by_cases hx : x ∈ W
    · have hn := hrr x (Finset.mem_insert_of_mem hx)
      simp [collapse, squash, hx, hxw, hn]
    · simp [collapse, squash, hx, hxw]

lemma collapse_unique [DecidableEq V] {W : Finset V} {w : V} {r : V → V}
    (_hw : w ∉ W) (hr : ∀ x ∈ W, r x ≠ w) :
    ∀ x, collapse W r x = w → x = w := by
  intro x hh
  by_cases hx : x ∈ W
  · exact False.elim (hr x hx (by simpa [collapse, hx] using hh))
  · simpa [collapse, hx] using hh

lemma volume_graph_body_congr [Fintype V] {G H : SimpleGraph V} (h : G = H)
    (pins : Set V) (b : V → ℝ) :
    volume (conditionalBody G pins b) = volume (conditionalBody H pins b) := by rw [h]

theorem volume_collapsed_body_le [Fintype V] (G : SimpleGraph V) [DecidableRel G.Adj]
    (pins : Set V) (W : Finset V) (r : V → V) (D : ℕ)
    (hwp : ∀ w ∈ W, w ∉ pins) (hr : ∀ w ∈ W, r w ∉ W)
    (hd : ∀ w ∈ W, G.degree w ≤ D) :
    volume (conditionalBody (G.map (collapse W r)) (pins ∪ (W : Set V)) (fun _ => 0)) ≤
      (2 ^ D) ^ W.card * volume (conditionalBody G pins (fun _ => 0)) := by
  classical
  induction W using Finset.induction_on with
  | empty =>
    have hg : G.map (collapse ∅ r) = G := by simp [collapse_empty]
    rw [hg, volume_body_pin_congr G (show pins ∪ (∅ : Finset V) = pins by simp) _]
    simp
  | @insert w W hw ih =>
    have hwp' : ∀ x ∈ W, x ∉ pins := fun x hx => hwp x (Finset.mem_insert_of_mem hx)
    have hr' : ∀ x ∈ W, r x ∉ W := fun x hx ht => hr x (Finset.mem_insert_of_mem hx)
      (Finset.mem_insert_of_mem ht)
    have hd' : ∀ x ∈ W, G.degree x ≤ D := fun x hx => hd x (Finset.mem_insert_of_mem hx)
    have ihh := ih hwp' hr' hd'
    let H := G.map (collapse W r)
    let P : Set V := pins ∪ (insert w W : Finset V)
    have hwP : w ∈ P := Or.inr (by simp)
    have hvw : r w ≠ w := fun he => hr w (by simp) (by simp [he])
    have heG : G.map (collapse (insert w W) r) = contract H w (r w) := by
      rw [collapse_insert hw hr]
      exact (SimpleGraph.map_map _ _ _).symm
    have hPr : P \ {w} = pins ∪ (W : Set V) := by
      ext x
      have hnp := hwp w (by simp)
      simp only [P, mem_sdiff, mem_union, Finset.mem_coe, Finset.mem_insert, mem_singleton_iff]
      constructor
      · rintro ⟨hp | hx,hn⟩
        · exact Or.inl hp
        · exact Or.inr (hx.resolve_left hn)
      · intro hh
        refine ⟨?_, ?_⟩
        · exact hh.elim Or.inl (fun hx => Or.inr (Or.inr hx))
        · intro he
          subst x
          exact hh.elim hnp hw
    have hdeg : H.degree w ≤ D :=
      (degree_map_singleton G (collapse W r) w (collapse_unique hw
        (fun x hx hh => hr x (Finset.mem_insert_of_mem hx) (by simp [hh])))).trans
          (hd w (by simp))
    have hv := volume_weld_le H P w (r w) hwP hvw
    rw [← contracted_body] at hv
    rw [volume_body_pin_congr H hPr _] at hv
    calc
      volume (conditionalBody (G.map (collapse (insert w W) r))
          (pins ∪ (insert w W : Finset V)) (fun _ => 0)) =
        volume (conditionalBody (contract H w (r w)) P (fun _ => 0)) :=
          volume_graph_body_congr heG _ _
      _ ≤ 2 ^ H.degree w * volume (conditionalBody H (pins ∪ (W : Set V)) (fun _ => 0)) := hv
      _ ≤ 2 ^ D * ((2 ^ D) ^ W.card * volume (conditionalBody G pins (fun _ => 0))) := by
        apply mul_le_mul' ?_ ihh
        exact pow_le_pow_right' (by norm_num) hdeg
      _ = _ := by rw [Finset.card_insert_of_notMem hw, pow_succ]; ring

end ExtremalEdges

end

end OAI