import OAI.Geometry.ProjectionVolume.Basic
import Mathlib.Analysis.InnerProductSpace.NormDet
import Mathlib.LinearAlgebra.Matrix.Determinant.Basic
import Mathlib.Tactic.FieldSimp
import Mathlib.Tactic.FunProp
import Mathlib.Tactic.Ring

namespace OAI

universe uι

open Set MeasureTheory
open scoped RealInnerProductSpace

noncomputable section

namespace Paper092

private def normalFrameVector {n : ℕ} {ι : Type uι} [Fintype ι]
    (u : Euclidean n) (b : OrthonormalBasis ι ℝ (normalHyperplane u)) :
    Unit ⊕ ι → Euclidean n
  | .inl _ => ‖u‖⁻¹ • u
  | .inr i => b i

private theorem normalFrameVector_orthonormal {n : ℕ} {ι : Type uι} [Fintype ι]
    (u : Euclidean n) (hu : u ≠ 0)
    (b : OrthonormalBasis ι ℝ (normalHyperplane u)) :
    Orthonormal ℝ (normalFrameVector u b) := by
  classical
  have hn : ‖‖u‖⁻¹ • u‖ = 1 := by simp [norm_smul, hu]
  have hb (i : ι) : ⟪u, (b i : Euclidean n)⟫ = 0 :=
    Submodule.mem_orthogonal_singleton_iff_inner_right.mp (b i).property
  rw [orthonormal_iff_ite]
  intro i j
  rcases i with i | i <;> rcases j with j | j
  · simp [normalFrameVector, hn]
  · simp [normalFrameVector, real_inner_smul_left, hb]
  · have hbi : ⟪(b i : Euclidean n), u⟫ = 0 := by rw [real_inner_comm, hb]
    simp [normalFrameVector, real_inner_smul_right, hbi]
  · simpa only [normalFrameVector, Sum.inr.injEq, Submodule.coe_inner] using b.inner_eq_ite i j

private def normalFrame {n : ℕ} {ι : Type uι} [Fintype ι]
    (u : Euclidean n) (hu : u ≠ 0)
    (b : OrthonormalBasis ι ℝ (normalHyperplane u)) :
    OrthonormalBasis (Unit ⊕ ι) ℝ (Euclidean n) :=
  OrthonormalBasis.mk (normalFrameVector_orthonormal u hu b)
    ((normalFrameVector_orthonormal u hu b).linearIndependent.span_eq_top_of_card_eq_finrank'
      (by
        have h := (Submodule.span ℝ ({u} : Set (Euclidean n))).finrank_add_finrank_orthogonal
        rw [finrank_span_singleton hu] at h
        change 1 + Module.finrank ℝ (normalHyperplane u) = _ at h
        rw [Module.finrank_eq_card_basis b.toBasis] at h
        simpa only [Fintype.card_sum, Fintype.card_unique] using h)).ge

@[simp] private theorem normalFrame_inl {n : ℕ} {ι : Type uι} [Fintype ι]
    (u : Euclidean n) (hu : u ≠ 0)
    (b : OrthonormalBasis ι ℝ (normalHyperplane u)) (i : Unit) :
    normalFrame u hu b (.inl i) = ‖u‖⁻¹ • u := by
  simp [normalFrame, normalFrameVector]

@[simp] private theorem normalFrame_inr {n : ℕ} {ι : Type uι} [Fintype ι]
    (u : Euclidean n) (hu : u ≠ 0)
    (b : OrthonormalBasis ι ℝ (normalHyperplane u)) (i : ι) :
    normalFrame u hu b (.inr i) = (b i : Euclidean n) := by
  simp [normalFrame, normalFrameVector]

def projectionTransport {n : ℕ} (L : Euclidean n ≃ₗ[ℝ] Euclidean n) (u : Euclidean n) :
    normalHyperplane (L.symm u) →ₗ[ℝ] normalHyperplane u :=
  (normalHyperplane u).orthogonalProjectionOnto.toLinearMap ∘ₗ
    L.toLinearMap ∘ₗ (normalHyperplane (L.symm u)).subtype

private theorem projectionTransport_matrix {n : ℕ} {ι : Type uι} [Fintype ι] [DecidableEq ι]
    (L : Euclidean n ≃ₗ[ℝ] Euclidean n) (u : Euclidean n) (hu : u ≠ 0)
    (hv : L.symm u ≠ 0)
    (bv : OrthonormalBasis ι ℝ (normalHyperplane (L.symm u)))
    (bu : OrthonormalBasis ι ℝ (normalHyperplane u)) :
    L.toLinearMap.toMatrix (normalFrame (L.symm u) hv bv).toBasis
      (normalFrame u hu bu).toBasis =
      Matrix.fromBlocks (Matrix.of (fun _ _ : Unit => ‖u‖ / ‖L.symm u‖))
        (Matrix.of (fun (_ : Unit) j => ⟪‖u‖⁻¹ • u, L (bv j)⟫)) 0
        ((projectionTransport L u).toMatrix bv.toBasis bu.toBasis) := by
  ext i j
  simp only [LinearMap.toMatrix_apply, OrthonormalBasis.coe_toBasis,
    OrthonormalBasis.coe_toBasis_repr_apply, OrthonormalBasis.repr_apply_apply]
  rcases i with i | i <;> rcases j with j | j
  · simp only [normalFrame_inl]
    change ⟪‖u‖⁻¹ • u, L (‖L.symm u‖⁻¹ • L.symm u)⟫ = ‖u‖ / ‖L.symm u‖
    rw [map_smul, L.apply_symm_apply, real_inner_smul_left, real_inner_smul_right,
      real_inner_self_eq_norm_sq]
    field_simp
  · simp only [normalFrame_inl, normalFrame_inr]
    rfl
  · have hbi : ⟪(bu i : Euclidean n), u⟫ = 0 := by
      rw [real_inner_comm]
      exact Submodule.mem_orthogonal_singleton_iff_inner_right.mp (bu i).property
    simp only [normalFrame_inr, normalFrame_inl]
    change ⟪(bu i : Euclidean n), L (‖L.symm u‖⁻¹ • L.symm u)⟫ = 0
    rw [map_smul, L.apply_symm_apply, real_inner_smul_right, hbi, mul_zero]
  · simp only [normalFrame_inr]
    change ⟪(bu i : Euclidean n), L (bv j)⟫ =
      ((projectionTransport L u).toMatrix bv.toBasis bu.toBasis) i j
    rw [LinearMap.toMatrix_apply]
    rw [bu.coe_toBasis_repr_apply, bu.repr_apply_apply]
    change ⟪(bu i : Euclidean n), L (bv j)⟫ =
      ⟪bu i, (normalHyperplane u).orthogonalProjectionOnto (L (bv j))⟫
    exact (Submodule.inner_orthogonalProjectionOnto_eq_of_mem_left _ _).symm

theorem projectionTransport_normDet {n : ℕ}
    (L : Euclidean n ≃ₗ[ℝ] Euclidean n) (u : Euclidean n) (hu : u ≠ 0) :
    (projectionTransport L u).normDet =
      |L.toLinearMap.det| * ‖L.symm u‖ / ‖u‖ := by
  have hv : L.symm u ≠ 0 := by simpa using hu
  let bv := (stdOrthonormalBasis ℝ (normalHyperplane (L.symm u))).reindex
    (finCongr (normalHyperplane_finrank (L.symm u) hv))
  let bu := (stdOrthonormalBasis ℝ (normalHyperplane u)).reindex
    (finCongr (normalHyperplane_finrank u hu))
  have hL : |L.toLinearMap.det| =
      |(L.toLinearMap.toMatrix (normalFrame (L.symm u) hv bv).toBasis
        (normalFrame u hu bu).toBasis).det| := by
    rw [← L.toLinearMap.normDet_eq_abs_det]
    simpa only [Real.norm_eq_abs] using
      L.toLinearMap.normDet_eq_norm_det_toMatrix
        (normalFrame (L.symm u) hv bv) (normalFrame u hu bu)
  rw [projectionTransport_matrix L u hu hv bv bu,
    Matrix.det_fromBlocks_zero₂₁, Matrix.det_unique, Matrix.of_apply, abs_mul,
    abs_of_nonneg (div_nonneg (norm_nonneg _) (norm_nonneg _))] at hL
  have hA := (projectionTransport L u).normDet_eq_norm_det_toMatrix bv bu
  rw [Real.norm_eq_abs] at hA
  rw [← hA] at hL
  rw [hL]
  field_simp

theorem projectionTransport_project {n : ℕ}
    (L : Euclidean n ≃ₗ[ℝ] Euclidean n) (u x : Euclidean n) :
    projectionTransport L u ((normalHyperplane (L.symm u)).orthogonalProjectionOnto x) =
      (normalHyperplane u).orthogonalProjectionOnto (L x) := by
  have hmem := (normalHyperplane (L.symm u)).sub_starProjection_mem_orthogonal x
  have hspan : (normalHyperplane (L.symm u))ᗮ =
      Submodule.span ℝ ({L.symm u} : Set (Euclidean n)) := by
    simp [normalHyperplane]
  rw [hspan] at hmem
  obtain ⟨t, ht⟩ := Submodule.mem_span_singleton.mp hmem
  have huorth : L (x - (normalHyperplane (L.symm u)).starProjection x) ∈
      (normalHyperplane u)ᗮ := by
    rw [← ht, map_smul, L.apply_symm_apply]
    simpa only [normalHyperplane, Submodule.orthogonal_orthogonal] using
      (Submodule.span ℝ ({u} : Set (Euclidean n))).smul_mem t
        (Submodule.mem_span_singleton_self u)
  have hz := (normalHyperplane u).orthogonalProjectionOnto_apply_of_mem_orthogonal huorth
  rw [map_sub, map_sub] at hz
  exact (sub_eq_zero.mp hz).symm

theorem projection_image_linearEquiv {n : ℕ}
    (L : Euclidean n ≃ₗ[ℝ] Euclidean n) (K : Set (Euclidean n)) (u : Euclidean n) :
    (normalHyperplane u).orthogonalProjectionOnto '' (L '' K) =
      projectionTransport L u ''
        ((normalHyperplane (L.symm u)).orthogonalProjectionOnto '' K) := by
  simp only [Set.image_image, projectionTransport_project]

theorem projectionVolume_linearEquiv_image {n : ℕ}
    (L : Euclidean n ≃ₗ[ℝ] Euclidean n) (K : Set (Euclidean n))
    (u : Euclidean n) (hu : u ≠ 0) :
    projectionVolume (L '' K) u =
      ENNReal.ofReal (|L.toLinearMap.det| * ‖L.symm u‖ / ‖u‖) *
        projectionVolume K (L.symm u) := by
  have hv : L.symm u ≠ 0 := by simpa using hu
  have hrank : Module.finrank ℝ (normalHyperplane (L.symm u)) =
      Module.finrank ℝ (normalHyperplane u) := by
    rw [normalHyperplane_finrank (L.symm u) hv, normalHyperplane_finrank u hu]
  have h := (projectionTransport L u).euclideanHausdorffMeasure_image_eq_normDet_mul_volume
    ((normalHyperplane (L.symm u)).orthogonalProjectionOnto '' K)
  rw [hrank, InnerProductSpace.euclideanHausdorffMeasure_eq_volume,
    projectionTransport_normDet L u hu] at h
  simpa only [projectionVolume, projection_image_linearEquiv] using h

theorem brightness_linearEquiv_image {n : ℕ}
    (L : Euclidean n ≃ₗ[ℝ] Euclidean n) (K : Set (Euclidean n)) (u : Euclidean n) :
    brightness (L '' K) u = |L.toLinearMap.det| * brightness K (L.symm u) := by
  by_cases hu : u = 0
  · simp [hu, brightness]
  have hn : 0 ≤ |L.toLinearMap.det| * ‖L.symm u‖ / ‖u‖ :=
    div_nonneg (mul_nonneg (abs_nonneg _) (norm_nonneg _)) (norm_nonneg _)
  rw [brightness, projectionVolume_linearEquiv_image L K u hu,
    ENNReal.toReal_mul, ENNReal.toReal_ofReal hn, brightness]
  field_simp

end Paper092

end

end OAI