import Mathlib
import OAI.GroupTheory.SimpleAmenable.PolygonGeometry.TorusStepFunctions

namespace OAI

section
section
open scoped symmDiff
namespace SimpleAmenable
open scoped commutatorElement
open scoped commutatorElement
section FlagGerms
open Classical

def FlagDirections (a : ℕ) (v w : ℝ × ℝ) : Prop :=
  ∀ j : Fin 4, cutForm a j v ≠ 0 ∨ cutForm a j w ≠ 0

theorem flagDirections_sector {a : ℕ} {v w : ℝ×ℝ} (h : FlagDirections a v w) :
    ∃ d : ℝ×ℝ, TransverseDirection a d ∧ ∀ j,
      (cutForm a j d<0 ↔ if cutForm a j v=0 then cutForm a j w<0 else cutForm a j v<0) := by
  let σ : Fin 4 → Bool := fun j =>
    decide (if cutForm a j v=0 then cutForm a j w<0 else cutForm a j v<0)
  have ha (j : Fin 4) (hj : cutForm a j v=0) :
      if σ j then cutForm a j (v+w)<0 else 0<cutForm a j (v+w) := by
    have hw : cutForm a j w≠0 := (h j).resolve_left (not_not.mpr hj)
    simp only [σ,hj,ite_eq_left,cutForm_add,zero_add]
    split_ifs with ht
    · exact of_decide_eq_true ht
    · exact lt_of_le_of_ne (le_of_not_gt (of_decide_eq_false (Bool.eq_false_iff.mpr ht))) hw.symm
  have hi (j : Fin 4) (hj : cutForm a j v≠0) :
      if σ j then cutForm a j v<0 else 0<cutForm a j v := by
    simp only [σ,ite_eq_right hj]
    split_ifs with ht
    · exact of_decide_eq_true ht
    · exact lt_of_le_of_ne (le_of_not_gt (of_decide_eq_false (Bool.eq_false_iff.mpr ht))) hj.symm
  obtain ⟨d,_,hd,hg⟩ := finite_arrangement_germ a id (fun _ => 0) v (v+w) σ
    ha hi Set.univ isOpen_univ (Set.mem_univ _)
  refine ⟨d,fun j => ?_,fun j => ?_⟩
  · simpa using hg j 0
  · have hh := hd j
    by_cases ht : if cutForm a j v=0 then cutForm a j w<0 else cutForm a j v<0
    · simpa [σ,ht] using hh
    · have hh' : 0<cutForm a j d := by simpa [σ,ht] using hh
      exact iff_of_false (not_lt_of_gt hh') ht

def SquareBoundary (v z : ℝ × ℝ) : Prop :=
  z.1 ∈ Set.Icc (0:ℝ) 1 ∧ z.2 ∈ Set.Icc (0:ℝ) 1 ∧
  (z.1=0 → 0<v.1) ∧ (z.1=1 → v.1<0) ∧
  (z.2=0 → 0<v.2) ∧ (z.2=1 → v.2<0)

def SquareFlag (a : ℕ) (v : ℝ × ℝ) :=
  {z : ℝ × ℝ // TransverseDirection a v ∧ SquareBoundary v z}

theorem sector_enters_square {a : ℕ} {v z : ℝ × ℝ}
    (hz : SquareBoundary v z) {p : GenericPlane a}
    (hp : p.val ∈ arrangementNeighborhood a SquareStep.squareEdgeCuts z)
    (hv : p.val ∈ planeSector a z v) : SquareStep.InSquare p := by
  have h₀ (x d : ℝ) (hx : x∈Set.Icc (0:ℝ) 1) (hd : x=0 → 0<d) :
      ¬(if x=0 then d<0 else x<0) := by
    split_ifs with he
    · exact not_lt_of_gt (hd he)
    · exact not_lt_of_ge hx.1
  have h₁ (x d : ℝ) (hx : x∈Set.Icc (0:ℝ) 1) (hd : x=1 → d<0) :
      (if x=1 then d<0 else x<1) := by
    split_ifs with he
    · exact hd he
    · exact lt_of_le_of_ne hx.2 he
  have h l (hl : l∈SquareStep.squareEdgeCuts) := planeSign_neighborhood hp hv hl
  have hx₀ : ¬p.val.1<0 := by
    have hh := h (0,0) (by simp [SquareStep.squareEdgeCuts])
    have hh' := decide_eq_decide.mp hh
    simpa [planeSign,cutForm,h₀ z.1 v.1 hz.1 hz.2.2.1] using hh'
  have hx₁ : p.val.1<1 := by
    have hh := h (0,1) (by simp [SquareStep.squareEdgeCuts])
    have hh' := decide_eq_decide.mp hh
    simpa [planeSign,cutForm,h₁ z.1 v.1 hz.1 hz.2.2.2.1] using hh'
  have hy₀ : ¬p.val.2<0 := by
    have hh := h (1,0) (by simp [SquareStep.squareEdgeCuts])
    have hh' := decide_eq_decide.mp hh
    simpa [planeSign,cutForm,h₀ z.2 v.2 hz.2.1 hz.2.2.2.2.1] using hh'
  have hy₁ : p.val.2<1 := by
    have hh := h (1,1) (by simp [SquareStep.squareEdgeCuts])
    have hh' := decide_eq_decide.mp hh
    simpa [planeSign,cutForm,h₁ z.2 v.2 hz.2.1 hz.2.2.2.2.2] using hh'
  exact ⟨⟨le_of_not_gt hx₀,hx₁⟩,⟨le_of_not_gt hy₀,hy₁⟩⟩

theorem squareSector_generic {a : ℕ} {v : ℝ × ℝ} (z : SquareFlag a v)
    {N : Set (ℝ×ℝ)} (hN : IsOpen N) (hz : z.val∈N) :
    ∃ p : GenericSquare a, p.val∈N ∧ p.val∈planeSector a z.val v := by
  obtain ⟨p,hp,hpv⟩ := planeSector_generic z.property.1
    (hN.inter (arrangementNeighborhood_open a SquareStep.squareEdgeCuts z.val))
    ⟨hz,self_mem_arrangementNeighborhood a SquareStep.squareEdgeCuts z.val⟩
  have hps := sector_enters_square z.property.2 hp.2 hpv
  exact ⟨⟨p.val,hps.1,hps.2,p.property⟩,hp.1,hpv⟩

def IsSquareGerm {a : ℕ} {v : ℝ×ℝ} {K : Type*} (f : GenericSquare a → K)
    (z : SquareFlag a v) (c : K) : Prop :=
  ∃ N : Set (ℝ×ℝ), IsOpen N ∧ z.val∈N ∧
    ∀ p : GenericSquare a, p.val∈N → p.val∈planeSector a z.val v → f p=c

theorem exists_squareGerm {a : ℕ} {v : ℝ×ℝ} {K : Type*}
    (f : GenericSquare a → K) (hf : HasSquareArrangement f) (z : SquareFlag a v) :
    ∃ c, IsSquareGerm f z c := by
  obtain ⟨S,hS⟩ := hf
  obtain ⟨p,hp,hpv⟩ := squareSector_generic z (arrangementNeighborhood_open a S z.val)
    (self_mem_arrangementNeighborhood a S z.val)
  refine ⟨f p,arrangementNeighborhood a S z.val,arrangementNeighborhood_open a S z.val,
    self_mem_arrangementNeighborhood a S z.val,fun q hq hqv => hS q p ?_⟩
  intro l hl
  exact (planeSign_neighborhood (p:=⟨q.val,q.property.2.2⟩) hq hqv hl).trans
    (planeSign_neighborhood (p:=⟨p.val,p.property.2.2⟩) hp hpv hl).symm

theorem IsSquareGerm.unique {a : ℕ} {v : ℝ×ℝ} {K : Type*}
    {f : GenericSquare a → K} {z : SquareFlag a v} {c d : K}
    (hc : IsSquareGerm f z c) (hd : IsSquareGerm f z d) : c=d := by
  obtain ⟨N,hN,hz,hc⟩ := hc
  obtain ⟨M,hM,hz',hd⟩ := hd
  obtain ⟨p,hp,hpv⟩ := squareSector_generic z (hN.inter hM) ⟨hz,hz'⟩
  exact (hc p hp.1 hpv).symm.trans (hd p hp.2 hpv)

noncomputable def flagValue {a : ℕ} {v : ℝ×ℝ} {K : Type*}
    (f : GenericSquare a → K) (hf : HasSquareArrangement f) (z : SquareFlag a v) : K :=
  Classical.choose (exists_squareGerm f hf z)

theorem flagValue_spec {a : ℕ} {v : ℝ×ℝ} {K : Type*}
    (f : GenericSquare a → K) (hf : HasSquareArrangement f) (z : SquareFlag a v) :
    IsSquareGerm f z (flagValue f hf z) := Classical.choose_spec (exists_squareGerm f hf z)

theorem flagValue_eq {a : ℕ} {v : ℝ×ℝ} {K : Type*}
    (f : GenericSquare a → K) (hf : HasSquareArrangement f) (z : SquareFlag a v)
    {c : K} (hc : IsSquareGerm f z c) : flagValue f hf z=c := (flagValue_spec f hf z).unique hc

theorem flagValue_map {a : ℕ} {v : ℝ×ℝ} {K J : Type*}
    (f : GenericSquare a → K) (hf : HasSquareArrangement f) (t : K → J)
    (ht : HasSquareArrangement (t ∘ f)) (z : SquareFlag a v) :
    flagValue (t ∘ f) ht z=t (flagValue f hf z) := by
  obtain ⟨N,hN,hz,hf'⟩ := flagValue_spec f hf z
  exact flagValue_eq _ _ _ ⟨N,hN,hz,fun p hp hpv => congrArg t (hf' p hp hpv)⟩

theorem flagValue_finite {a : ℕ} {v : ℝ×ℝ} {ι K : Type*} [Finite ι]
    (f : ι → GenericSquare a → K) (hf : ∀ i, HasSquareArrangement (f i))
    (z : SquareFlag a v) {N : Set (ℝ×ℝ)} (hN : IsOpen N) (hz : z.val∈N) :
    ∃ p : GenericSquare a, p.val∈N ∧ p.val∈planeSector a z.val v ∧
      ∀ i, f i p=flagValue (f i) (hf i) z := by
  choose M hM hzM hfg using fun i => flagValue_spec (f i) (hf i) z
  obtain ⟨p,hp,hpv⟩ := squareSector_generic z
    (hN.inter (isOpen_iInter_of_finite hM)) ⟨hz,Set.mem_iInter.mpr hzM⟩
  exact ⟨p,hp.1,hpv,fun i => hfg i p (Set.mem_iInter.mp hp.2 i) hpv⟩

noncomputable def flagMem {a : ℕ} {v : ℝ×ℝ} (U : polygonAlgebra a)
    (z : SquareFlag a v) : Prop :=
  flagValue (fun p => decide (p∈U.val)) (polygon_hasSquareArrangement U.property) z=true

theorem flagMem_iff {a : ℕ} {v : ℝ×ℝ} (U : polygonAlgebra a) (z : SquareFlag a v) :
    ∃ N : Set (ℝ×ℝ), IsOpen N ∧ z.val∈N ∧
      ∀ p : GenericSquare a, p.val∈N → p.val∈planeSector a z.val v →
        (p∈U.val ↔ flagMem U z) := by
  obtain ⟨N,hN,hz,hf⟩ := flagValue_spec (fun p => decide (p∈U.val))
    (polygon_hasSquareArrangement U.property) z
  refine ⟨N,hN,hz,fun p hp hpv => ?_⟩
  unfold flagMem
  rw [← hf p hp hpv]
  simp

@[simp] theorem flagMem_bot {a : ℕ} {v : ℝ×ℝ} (z : SquareFlag a v) :
    ¬flagMem (⊥ : polygonAlgebra a) z := by
  have h := flagValue_eq (fun p : GenericSquare a => decide (p∈(⊥ : polygonAlgebra a).val))
    (polygon_hasSquareArrangement (⊥ : polygonAlgebra a).property) z
    (c:=false) ⟨Set.univ,isOpen_univ,Set.mem_univ _,fun _ _ _ => by simp⟩
  intro hm
  exact Bool.false_ne_true (h.symm.trans hm)

theorem flagMem_sup {a : ℕ} {v : ℝ×ℝ} (U V : polygonAlgebra a) (z : SquareFlag a v) :
    flagMem (U⊔V) z ↔ flagMem U z ∨ flagMem V z := by
  obtain ⟨N,hN,hz,h⟩ := flagMem_iff (U⊔V) z
  obtain ⟨M,hM,hz',h'⟩ := flagMem_iff U z
  obtain ⟨L,hL,hz'',h''⟩ := flagMem_iff V z
  obtain ⟨p,hp,hpv⟩ := squareSector_generic z ((hN.inter hM).inter hL) ⟨⟨hz,hz'⟩,hz''⟩
  rw [← h p hp.1.1 hpv,← h' p hp.1.2 hpv,← h'' p hp.2 hpv]
  rfl

theorem flagMem_compl {a : ℕ} {v : ℝ×ℝ} (U : polygonAlgebra a) (z : SquareFlag a v) :
    flagMem Uᶜ z ↔ ¬flagMem U z := by
  obtain ⟨N,hN,hz,h⟩ := flagMem_iff Uᶜ z
  obtain ⟨M,hM,hz',h'⟩ := flagMem_iff U z
  obtain ⟨p,hp,hpv⟩ := squareSector_generic z (hN.inter hM) ⟨hz,hz'⟩
  rw [← h p hp.1 hpv,← h' p hp.2 hpv]
  rfl

theorem flagMem_halfPlane {a : ℕ} {v : ℝ×ℝ} (j : Fin 4) (c : CutRing)
    (z : SquareFlag a v) :
    flagMem ⟨halfPlane a j c,halfPlane_mem a j c⟩ z ↔
      (if cutForm a j z.val=ordinary c then cutForm a j v<0
        else cutForm a j z.val<ordinary c) := by
  let U : polygonAlgebra a := ⟨halfPlane a j c,halfPlane_mem a j c⟩
  have hg : flagValue (fun p => decide (p∈U.val))
      (polygon_hasSquareArrangement U.property) z =
      decide (if cutForm a j z.val=ordinary c then cutForm a j v<0
        else cutForm a j z.val<ordinary c) := by
    apply flagValue_eq
    refine ⟨arrangementNeighborhood a {(j,c)} z.val,
      arrangementNeighborhood_open a {(j,c)} z.val,
      self_mem_arrangementNeighborhood a {(j,c)} z.val, fun p hp hpv => ?_⟩
    exact planeSign_neighborhood (p:=⟨p.val,p.property.2.2⟩) hp hpv (Finset.mem_singleton_self _)
  change flagValue _ _ z=true ↔ _
  rw [hg]
  simp

end FlagGerms

end SimpleAmenable
end
end

end OAI