import Mathlib
import OAI.GroupTheory.SimpleAmenable.PolygonGeometry.PeriodicSlotStars
import OAI.GroupTheory.SimpleAmenable.PolygonGeometry.FlagGerms

namespace OAI

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

noncomputable def flagFloor (x d : ℝ) : ℤ :=
  if d<0 then -1-⌊-x⌋ else ⌊x⌋

noncomputable def flagFract (x d : ℝ) : ℝ :=
  if d<0 then 1-Int.fract (-x) else Int.fract x

theorem flagFract_eq (x d : ℝ) : flagFract x d=x-(flagFloor x d:ℝ) := by
  unfold flagFract flagFloor
  split_ifs <;> simp only [Int.fract,Int.cast_sub,Int.cast_neg,Int.cast_one]
  ring

theorem flagFract_add_int (x d : ℝ) (n : ℤ) : flagFract (x+n) d=flagFract x d := by
  unfold flagFract
  split_ifs
  · rw [neg_add,← sub_eq_add_neg,Int.fract_sub_intCast]
  · rw [Int.fract_add_intCast]

theorem flagFract_sub_int (x d : ℝ) (n : ℤ) : flagFract (x-n) d=flagFract x d := by
  simpa [sub_eq_add_neg] using flagFract_add_int x d (-n)

theorem flagFract_flagFract_add (x y d : ℝ) :
    flagFract (flagFract x d+y) d=flagFract (x+y) d := by
  rw [flagFract_eq x d,sub_add_eq_add_sub,flagFract_sub_int]

theorem flagFract_boundary (x d : ℝ) (hd : d≠0) :
    flagFract x d∈Set.Icc (0:ℝ) 1 ∧
      (flagFract x d=0 → 0<d) ∧ (flagFract x d=1 → d<0) := by
  have h₀ := Int.fract_nonneg x
  have h₁ := Int.fract_lt_one x
  have h₀' := Int.fract_nonneg (-x)
  have h₁' := Int.fract_lt_one (-x)
  unfold flagFract
  split_ifs with ht
  · exact ⟨⟨by linarith,by linarith⟩,fun he => by linarith,fun _ => ht⟩
  · exact ⟨⟨h₀,le_of_lt h₁⟩,fun _ => lt_of_le_of_ne (le_of_not_gt ht) hd.symm,
      fun he => by linarith⟩

theorem flagFract_self {x d : ℝ} (hx : x∈Set.Icc (0:ℝ) 1)
    (h₀ : x=0 → 0<d) (h₁ : x=1 → d<0) : flagFract x d=x := by
  unfold flagFract
  split_ifs with ht
  · have hx₀ : 0<x := lt_of_le_of_ne hx.1 (by intro he; have := h₀ he.symm; linarith)
    have hf : Int.fract (-x)=1-x := Int.fract_eq_iff.mpr
      ⟨by linarith [hx.2],by linarith,⟨-1,by norm_num; ring⟩⟩
    rw [hf]; ring
  · exact Int.fract_eq_self.mpr ⟨hx.1,lt_of_le_of_ne hx.2 (fun he => ht (h₁ he))⟩

noncomputable def flagTranslate {a : ℕ} {v : ℝ×ℝ} (u : CutRing×CutRing)
    (z : SquareFlag a v) : SquareFlag a v := by
  have hv₁ : v.1≠0 := by simpa [cutForm] using z.property.1 0
  have hv₂ : v.2≠0 := by simpa [cutForm] using z.property.1 1
  have hx := flagFract_boundary (z.val.1+ordinary u.1) v.1 hv₁
  have hy := flagFract_boundary (z.val.2+ordinary u.2) v.2 hv₂
  exact ⟨(flagFract (z.val.1+ordinary u.1) v.1,flagFract (z.val.2+ordinary u.2) v.2),
    z.property.1,hx.1,hy.1,hx.2.1,hx.2.2,hy.2.1,hy.2.2⟩

@[simp] theorem flagTranslate_val {a : ℕ} {v : ℝ×ℝ} (u : CutRing×CutRing)
    (z : SquareFlag a v) : (flagTranslate u z).val=
      (flagFract (z.val.1+ordinary u.1) v.1,flagFract (z.val.2+ordinary u.2) v.2) := rfl

@[simp] theorem flagTranslate_zero {a : ℕ} {v : ℝ×ℝ} (z : SquareFlag a v) :
    flagTranslate 0 z=z := by
  apply Subtype.ext
  simp only [flagTranslate_val,Prod.fst_zero,Prod.snd_zero,map_zero,add_zero]
  exact Prod.ext (flagFract_self z.property.2.1 z.property.2.2.2.1 z.property.2.2.2.2.1)
    (flagFract_self z.property.2.2.1 z.property.2.2.2.2.2.1 z.property.2.2.2.2.2.2)

theorem flagTranslate_add {a : ℕ} {v : ℝ×ℝ} (u w : CutRing×CutRing)
    (z : SquareFlag a v) : flagTranslate (u+w) z=flagTranslate u (flagTranslate w z) := by
  apply Subtype.ext
  simp only [flagTranslate_val,Prod.fst_add,Prod.snd_add,map_add]
  rw [flagFract_flagFract_add,flagFract_flagFract_add]
  congr 1 <;> congr 1 <;> ring

theorem flagTranslate_period {a : ℕ} {v : ℝ×ℝ} (u : CutRing×CutRing) (k : ℤ×ℤ)
    (z : SquareFlag a v) : flagTranslate (u+SquareStep.intPair k) z=flagTranslate u z := by
  apply Subtype.ext
  simp only [flagTranslate_val,SquareStep.intPair,Prod.fst_add,Prod.snd_add,map_add,map_intCast]
  rw [← add_assoc,← add_assoc,flagFract_add_int,flagFract_add_int]

theorem flagTranslate_reduce {a : ℕ} {v : ℝ×ℝ} (u : CutRing×CutRing)
    (z : SquareFlag a v) : flagTranslate u z=flagTranslate (orbitRepresentative u) z := by
  have hu : u=orbitRepresentative u+SquareStep.intPair (u.1.re,u.2.re) := by
    apply Prod.ext <;> apply QuadraticAlgebra.ext <;> simp [orbitRepresentative,SquareStep.intPair,cutTau]
  calc
    _ = flagTranslate (orbitRepresentative u+SquareStep.intPair (u.1.re,u.2.re)) z := congrArg (fun t => flagTranslate t z) hu
    _ = _ := flagTranslate_period _ _ _

theorem planeSector_add_iff {a : ℕ} (z v t p : ℝ×ℝ) :
    p+t∈planeSector a (z+t) v ↔ p∈planeSector a z v := by
  unfold planeSector
  simp only [Set.mem_ofPred_eq,cutForm_add]
  apply forall_congr'
  intro j
  split_ifs <;> simp

theorem flagTranslate_neighborhood {a : ℕ} {v : ℝ×ℝ} (u : CutRing×CutRing)
    (z : SquareFlag a v) {N : Set (ℝ×ℝ)} (hN : IsOpen N)
    (hz : (flagTranslate u z).val∈N) :
    ∃ M : Set (ℝ×ℝ), IsOpen M ∧ z.val∈M ∧
      ∀ p : GenericSquare a, p.val∈M → p.val∈planeSector a z.val v →
        (translate a u p).val∈N ∧
          (translate a u p).val∈planeSector a (flagTranslate u z).val v := by
  let k : ℤ×ℤ := (flagFloor (z.val.1+ordinary u.1) v.1,
    flagFloor (z.val.2+ordinary u.2) v.2)
  let t : CutRing×CutRing := u-SquareStep.intPair k
  let b : ℝ×ℝ := (ordinary t.1,ordinary t.2)
  have hbase : (flagTranslate u z).val=z.val+b := by
    apply Prod.ext <;> simp only [flagTranslate_val,flagFract_eq,b,t,k,SquareStep.intPair,
      Prod.fst_sub,Prod.snd_sub,Prod.fst_add,Prod.snd_add,map_sub,map_intCast] <;> ring
  let L := N ∩ arrangementNeighborhood a SquareStep.squareEdgeCuts (flagTranslate u z).val
  let M : Set (ℝ×ℝ) := (fun p => p+b) ⁻¹' L
  have hL : IsOpen L := hN.inter (arrangementNeighborhood_open _ _ _)
  have hzL : (flagTranslate u z).val∈L := ⟨hz,self_mem_arrangementNeighborhood _ _ _⟩
  refine ⟨M,hL.preimage (continuous_id.add continuous_const),?_,fun p hp hpv => ?_⟩
  · change z.val+b∈L
    rw [← hbase]; exact hzL
  · let q : GenericPlane a := GenericPlane.shift t ⟨p.val,p.property.2.2⟩
    have hqv : q.val∈planeSector a (flagTranslate u z).val v := by
      rw [hbase]
      exact (planeSector_add_iff z.val v b p.val).mpr hpv
    have hqs : SquareStep.InSquare q := sector_enters_square (flagTranslate u z).property.2 hp.2 hqv
    have hqp : (translate a u p).val=q.val := by
      apply Prod.ext
      · change Int.fract (p.val.1+ordinary u.1)=p.val.1+ordinary t.1
        have he : p.val.1+ordinary t.1=p.val.1+ordinary u.1-(k.1:ℝ) := by
          simp only [t,SquareStep.intPair,Prod.fst_sub,map_sub,map_intCast]; ring
        rw [he]
        rw [← Int.fract_sub_intCast (p.val.1+ordinary u.1) k.1]
        exact Int.fract_eq_self.mpr (by simpa only [q,GenericPlane.shift,Prod.fst_add,he,Set.mem_Ico] using hqs.1)
      · change Int.fract (p.val.2+ordinary u.2)=p.val.2+ordinary t.2
        have he : p.val.2+ordinary t.2=p.val.2+ordinary u.2-(k.2:ℝ) := by
          simp only [t,SquareStep.intPair,Prod.snd_sub,map_sub,map_intCast]; ring
        rw [he]
        rw [← Int.fract_sub_intCast (p.val.2+ordinary u.2) k.2]
        exact Int.fract_eq_self.mpr (by simpa only [q,GenericPlane.shift,Prod.snd_add,he,Set.mem_Ico] using hqs.2)
    rw [hqp]
    exact ⟨hp.1,hqv⟩

theorem flagValue_translate {a : ℕ} {v : ℝ×ℝ} {K : Type*}
    (f : GenericSquare a → K) (hf : HasSquareArrangement f) (u : CutRing×CutRing)
    (z : SquareFlag a v) :
    flagValue (fun p => f (translate a u p)) (squareArrangement_translate hf u) z =
      flagValue f hf (flagTranslate u z) := by
  obtain ⟨N,hN,hz,hf'⟩ := flagValue_spec f hf (flagTranslate u z)
  obtain ⟨M,hM,hzM,hg⟩ := flagTranslate_neighborhood u z hN hz
  exact flagValue_eq _ _ _ ⟨M,hM,hzM,fun p hp hpv =>
    hf' (translate a u p) (hg p hp hpv).1 (hg p hp hpv).2⟩

theorem flagMem_preimage_translate {a : ℕ} {v : ℝ×ℝ} (U : polygonAlgebra a)
    (u : CutRing×CutRing) (z : SquareFlag a v) :
    flagMem ⟨translate a u ⁻¹' U.val,polygon_preimage_translate u U.property⟩ z ↔
      flagMem U (flagTranslate u z) := by
  change flagValue (fun p => decide (translate a u p∈U.val))
    (squareArrangement_translate (polygon_hasSquareArrangement U.property) u) z=true ↔ _
  rw [flagValue_translate (fun p => decide (p∈U.val)) (polygon_hasSquareArrangement U.property)]
  rfl

end FlagTranslation

end SimpleAmenable
end
end

end OAI