import OAI.Geometry.ProjectionVolume.PolytopeCauchy
import OAI.Geometry.ProjectionVolume.EuclideanVolume
import OAI.Geometry.ProjectionVolume.FacetAreas

namespace OAI

open Set MeasureTheory
open scoped RealInnerProductSpace Pointwise

noncomputable section

namespace Paper092

def euclideanCube (d : ℕ) : Set (Euclidean d) :=
  WithLp.toLp 2 '' Icc (0 : Fin d → ℝ) 1

theorem mem_euclideanCube {d : ℕ} (x : Euclidean d) :
    x ∈ euclideanCube d ↔ (∀ i, 0 ≤ x i) ∧ ∀ i, x i ≤ 1 := by
  constructor
  · rintro ⟨y, hy, rfl⟩
    exact hy
  · intro hx
    exact ⟨WithLp.ofLp x, hx, WithLp.toLp_ofLp 2 x⟩

theorem euclideanCube_isCompact (d : ℕ) : IsCompact (euclideanCube d) :=
  isCompact_Icc.image (PiLp.continuous_toLp 2 _)

theorem euclideanCube_volume (d : ℕ) : volume (euclideanCube d) = 1 := by
  rw [euclideanCube, volume_euclidean_image]
  simp [Real.volume_Icc_pi]

def cubeNormal {d : ℕ} : Fin d ⊕ Fin d → Euclidean d
  | .inl i => -EuclideanSpace.single i 1
  | .inr i => EuclideanSpace.single i 1

def cubeOffset {d : ℕ} : Fin d ⊕ Fin d → ℝ
  | .inl _ => 0
  | .inr _ => 1

theorem cube_constraints (d : ℕ) :
    {x : Euclidean d | ∀ i, ⟪cubeNormal i, x⟫ ≤ cubeOffset i} = euclideanCube d := by
  ext x
  simp [mem_euclideanCube, Sum.forall, cubeNormal, cubeOffset,
    EuclideanSpace.inner_single_left]

def cubePolytope (d : ℕ) : HPolytope d (Fin d ⊕ Fin d) where
  normal := cubeNormal
  offset := cubeOffset
  normal_unit i := by cases i <;> simp [cubeNormal]
  compact := by rw [cube_constraints]; exact euclideanCube_isCompact d
  strict_feasible := by
    refine ⟨WithLp.toLp 2 (fun _ => (1 / 2 : ℝ)), ?_⟩
    intro i
    cases i <;> norm_num [cubeNormal, cubeOffset, EuclideanSpace.inner_single_left]
  distinct := by
    intro i j hij
    rcases i with i | i <;> rcases j with j | j
    · congr 1
      by_contra h
      have hc := congrArg (fun p : Euclidean d × ℝ => p.1 i) hij
      simp [cubeNormal, h] at hc
    · have hc := congrArg Prod.snd hij
      norm_num [cubeOffset] at hc
    · have hc := congrArg Prod.snd hij
      norm_num [cubeOffset] at hc
    · congr 1
      by_contra h
      have hc := congrArg (fun p : Euclidean d × ℝ => p.1 i) hij
      simp [cubeNormal, h] at hc

theorem cubePolytope_body (d : ℕ) : (cubePolytope d).body = euclideanCube d :=
  cube_constraints d

theorem cubePolytope_face_lower {d : ℕ} (i : Fin d) :
    (cubePolytope d).face (.inl i) = {x | x ∈ euclideanCube d ∧ x i = 0} := by
  ext x
  change (x ∈ (cubePolytope d).body ∧ ⟪-EuclideanSpace.single i 1, x⟫ = 0) ↔ _
  rw [cubePolytope_body]
  simp [EuclideanSpace.inner_single_left]

theorem cubePolytope_face_upper {d : ℕ} (i : Fin d) :
    (cubePolytope d).face (.inr i) = {x | x ∈ euclideanCube d ∧ x i = 1} := by
  ext x
  change (x ∈ (cubePolytope d).body ∧ ⟪EuclideanSpace.single i 1, x⟫ = 1) ↔ _
  rw [cubePolytope_body]
  simp [EuclideanSpace.inner_single_left]

theorem cube_lower_face_chart (n : ℕ) (i : Fin (n + 1)) :
    facetEmbedding n i 0 '' euclideanCube n = (cubePolytope (n + 1)).face (.inl i) := by
  rw [cubePolytope_face_lower]
  ext y
  constructor
  · rintro ⟨x, hx, rfl⟩
    change facetEmbedding n i 0 x ∈ euclideanCube (n + 1) ∧ facetEmbedding n i 0 x i = 0
    rw [mem_euclideanCube] at hx ⊢
    simp [facetEmbedding, Fin.forall_iff_succAbove i, hx]
  · rintro ⟨hy, hi⟩
    refine ⟨WithLp.toLp 2 (i.removeNth y), ?_, ?_⟩
    · rw [mem_euclideanCube] at hy ⊢
      exact ⟨fun j => hy.1 (i.succAbove j), fun j => hy.2 (i.succAbove j)⟩
    · ext j
      induction j using i.succAboveCases <;> simp [facetEmbedding, hi]

theorem cube_lower_face_area (n : ℕ) (i : Fin (n + 1)) :
    μHE[n] ((cubePolytope (n + 1)).face (.inl i)) = 1 := by
  rw [← cube_lower_face_chart]
  have h := (facetEmbedding n i 0).euclideanHausdorffMeasure_image_eq_normDet_mul_volume
    (euclideanCube n)
  simpa only [finrank_euclideanSpace_fin, facetEmbedding_normDet_zero,
    ENNReal.ofReal_one, euclideanCube_volume, mul_one] using h

theorem cube_upper_face_eq_vadd {d : ℕ} (i : Fin d) :
    (cubePolytope d).face (.inr i) =
      EuclideanSpace.single i (1 : ℝ) +ᵥ (cubePolytope d).face (.inl i) := by
  rw [cubePolytope_face_upper, cubePolytope_face_lower]
  ext y
  constructor
  · rintro ⟨hy, hi⟩
    refine ⟨y - EuclideanSpace.single i 1, ⟨?_, ?_⟩, ?_⟩
    · rw [mem_euclideanCube] at hy ⊢
      constructor <;> intro j
      · by_cases hj : j = i
        · subst j; simp [PiLp.sub_apply, hi]
        · simpa [PiLp.sub_apply, PiLp.single_apply, hj] using hy.1 j
      · by_cases hj : j = i
        · subst j; simp [PiLp.sub_apply, hi]
        · simpa [PiLp.sub_apply, PiLp.single_apply, hj] using hy.2 j
    · simp [PiLp.sub_apply, hi]
    · change EuclideanSpace.single i 1 + (y - EuclideanSpace.single i 1) = y
      abel
  · rintro ⟨x, ⟨hx, hi⟩, rfl⟩
    refine ⟨?_, ?_⟩
    · rw [mem_euclideanCube] at hx ⊢
      constructor <;> intro j
      · by_cases hj : j = i
        · subst j; simp [vadd_eq_add, PiLp.add_apply, hi]
        · simpa [vadd_eq_add, PiLp.add_apply, PiLp.single_apply, hj] using hx.1 j
      · by_cases hj : j = i
        · subst j; simp [vadd_eq_add, PiLp.add_apply, hi]
        · simpa [vadd_eq_add, PiLp.add_apply, PiLp.single_apply, hj] using hx.2 j
    · simp [vadd_eq_add, PiLp.add_apply, hi]

theorem cube_upper_face_area (n : ℕ) (i : Fin (n + 1)) :
    μHE[n] ((cubePolytope (n + 1)).face (.inr i)) = 1 := by
  rw [cube_upper_face_eq_vadd, measure_vadd, cube_lower_face_area]

theorem cube_faceArea {d : ℕ} (hd : 0 < d) (i : Fin d ⊕ Fin d) :
    (cubePolytope d).faceArea i = 1 := by
  obtain ⟨n, rfl⟩ := Nat.exists_eq_succ_of_ne_zero (Nat.ne_of_gt hd)
  cases i with
  | inl i =>
    change (μHE[n] ((cubePolytope (n + 1)).face (.inl i))).toReal = 1
    rw [cube_lower_face_area, ENNReal.toReal_one]
  | inr i =>
    change (μHE[n] ((cubePolytope (n + 1)).face (.inr i))).toReal = 1
    rw [cube_upper_face_area, ENNReal.toReal_one]

theorem euclideanCube_brightness {d : ℕ} (hd : 0 < d) (u : Euclidean d) :
    brightness (euclideanCube d) u = ∑ i, |u i| := by
  rw [← cubePolytope_body, (cubePolytope d).brightness_eq_sum]
  simp only [cube_faceArea hd, one_mul, Fintype.sum_sum_type]
  simp only [cubePolytope, cubeNormal, inner_neg_right, abs_neg,
    EuclideanSpace.inner_single_right, one_mul, starRingEnd_apply, star_trivial]
  ring

theorem euclideanCube_diagonal_brightness {d : ℕ} (hd : 0 < d) :
    brightness (euclideanCube d) (WithLp.toLp 2 (1 : Fin d → ℝ)) = d := by
  rw [euclideanCube_brightness hd]
  simp

theorem euclideanCube_diagonal_extrusion {d : ℕ} (hd : 0 < d) :
    (volume (euclideanCube d +
      segment ℝ (0 : Euclidean d) (WithLp.toLp 2 (1 : Fin d → ℝ)))).toReal =
        (volume (euclideanCube d)).toReal +
          brightness (euclideanCube d) (WithLp.toLp 2 (1 : Fin d → ℝ)) := by
  rw [euclideanCube_volume, ENNReal.toReal_one, euclideanCube_diagonal_brightness hd]
  rw [euclideanCube, volume_euclidean_cube_add_diagonal d hd]
  rw [ENNReal.toReal_add (by simp) (by simp), ENNReal.toReal_natCast, ENNReal.toReal_one]
  ring

theorem euclideanCube_diagonal_projectionBody_support {d : ℕ} (hd : 0 < d) :
    SupportGeometry.support (projectionBody (euclideanCube d))
      (innerSL ℝ (WithLp.toLp 2 (1 : Fin d → ℝ))) = d := by
  rw [← cubePolytope_body, (cubePolytope d).projectionBody_support, cubePolytope_body,
    euclideanCube_diagonal_brightness hd]

end Paper092

end

end OAI