import OAI.Geometry.CylinderCovering.Singular.EdgeOneDifferentialDefinitions
import OAI.Geometry.CylinderCovering.Singular.EdgeOneGeometry

namespace OAI

noncomputable section
open Set Filter MeasureTheory
open scoped Topology
namespace SingularEdgeOne
open RuledApproximation

@[simp] lemma labelContinuous_apply (z : Plane) : labelContinuous z = labelMap z := rfl
@[simp] lemma labelContinuous_symm_apply (z : Plane) :
    labelContinuous.symm z = vec2 (2 * z 0) (z 1) := rfl

lemma edgeField_labelMap (p : ℝ) {z : Plane} (hz : 0 < z 1) :
    edgeField p (labelMap z) = (1 / 2 : ℝ) • labelMap (singularField p z) := by
  ext i
  fin_cases i
  · change edgeU p (labelMap z 0) (labelMap z 1) =
      (1 / 2 : ℝ) * (singularField p z 0 / 2)
    rw [edgeU_labelMap]
    ring
  · change edgeV p (labelMap z 0) (labelMap z 1) =
      (1 / 2 : ℝ) * singularField p z 1
    rw [edgeV_labelMap p hz]
    ring

lemma edgeField_conjugacy (p : ℝ) {z : Plane} (hz : 0 < z 1) :
    edgeField p z = (1 / 2 : ℝ) •
      labelContinuous (singularField p (labelContinuous.symm z)) := by
  have h := edgeField_labelMap p (z := labelContinuous.symm z) (by simpa using hz)
  simpa only [← labelContinuous_apply, ContinuousLinearEquiv.apply_symm_apply] using h

lemma edgeField_hasFDerivAt (p : ℝ) {z : Plane} (hz : 0 < z 1) :
    HasFDerivAt (edgeField p)
      ((1 / 2 : ℝ) • labelContinuous.toContinuousLinearMap.comp
        ((fderiv ℝ (singularField p) (labelContinuous.symm z)).comp
          labelContinuous.symm.toContinuousLinearMap)) z := by
  have hz' : 0 < (labelContinuous.symm z) 1 := by simpa using hz
  have hs := (singularField_contDiffAt p hz').differentiableAt (by norm_num)
  have hd := (labelContinuous.hasFDerivAt.comp z
    (hs.hasFDerivAt.comp z labelContinuous.symm.hasFDerivAt)).const_smul (1 / 2 : ℝ)
  apply hd.congr_of_eventuallyEq
  have hpos : ∀ᶠ w : Plane in 𝓝 z, 0 < w 1 :=
    (isOpen_lt continuous_const (by fun_prop : Continuous (fun w : Plane => w 1))).mem_nhds hz
  filter_upwards [hpos] with w hw
  exact edgeField_conjugacy p hw

lemma edgeField_fderiv (p : ℝ) {z : Plane} (hz : 0 < z 1) :
    fderiv ℝ (edgeField p) z =
      (1 / 2 : ℝ) • labelContinuous.toContinuousLinearMap.comp
        ((fderiv ℝ (singularField p) (labelContinuous.symm z)).comp
          labelContinuous.symm.toContinuousLinearMap) :=
  (edgeField_hasFDerivAt p hz).fderiv

lemma scaled_derivative_conjugacy (p c : ℝ) {z : Plane} (hz : 0 < z 1) :
    ((4 * c) / 2) • fderiv ℝ (edgeField p) (labelMap z) =
      c • labelContinuous.toContinuousLinearMap.comp
        ((fderiv ℝ (singularField p) z).comp labelContinuous.symm.toContinuousLinearMap) := by
  rw [edgeField_fderiv p (by exact hz)]
  change ((4 * c) / 2) • ((1 / 2 : ℝ) •
    labelContinuous.toContinuousLinearMap.comp
      ((fderiv ℝ (singularField p) (labelContinuous.symm (labelContinuous z))).comp
        labelContinuous.symm.toContinuousLinearMap)) = _
  rw [ContinuousLinearEquiv.symm_apply_apply, smul_smul,
    show (4 * c / 2) * (1 / 2 : ℝ) = c by ring]

lemma edgeHamiltonian_deriv_w (p w : ℝ) {l : ℝ} (hl : 0 < l) :
    deriv (fun v : ℝ => edgeHamiltonian p v l) w = edgeV p w l := by
  have hd : HasDerivAt (fun v : ℝ => edgeHamiltonian p v l)
      ((2 : ℝ) ^ (p - 3) * (2 * w * l ^ (p - 2))) w := by
    convert! (((hasDerivAt_pow 2 w).mul_const (l ^ (p - 2))).sub_const
      (l ^ p / 4)).const_mul ((2 : ℝ) ^ (p - 3)) using 1
    simp
  rw [hd.deriv, edgeV_eq p w hl, fieldQ,
    Real.mul_rpow (by norm_num : (0 : ℝ) ≤ 2) hl.le]
  have ht : (2 : ℝ) ^ (p - 2) = (2 : ℝ) ^ (p - 3) * 2 := by
    rw [show p - 2 = (p - 3) + 1 by ring, Real.rpow_add_one (by norm_num)]
  rw [ht]
  ring

lemma edgeHamiltonian_deriv_l (p w : ℝ) {l : ℝ} (hl : 0 < l) :
    -deriv (fun r : ℝ => edgeHamiltonian p w r) l = edgeU p w l := by
  have hd1 := Real.hasDerivAt_rpow_const (x := l) (p := p - 2) (Or.inl hl.ne')
  have hd2 := Real.hasDerivAt_rpow_const (x := l) (p := p) (Or.inl hl.ne')
  have hd : HasDerivAt (fun r : ℝ => edgeHamiltonian p w r)
      ((2 : ℝ) ^ (p - 3) *
        (w ^ 2 * ((p - 2) * l ^ (p - 3)) - p * l ^ (p - 1) / 4)) l := by
    convert! ((hd1.const_mul (w ^ 2)).sub (hd2.div_const 4)).const_mul
      ((2 : ℝ) ^ (p - 3)) using 1
    congr 3
    ring_nf
  rw [hd.deriv, edgeU, Real.mul_rpow (by norm_num : (0 : ℝ) ≤ 2) hl.le]
  have ht : (2 : ℝ) ^ (p - 1) = (2 : ℝ) ^ (p - 3) * 4 := by
    rw [show p - 1 = (p - 3) + 2 by ring,
      Real.rpow_add (by norm_num : (0 : ℝ) < 2), Real.rpow_two]
    norm_num
  have hlpow : l ^ (p - 1) = l ^ (p - 3) * l ^ 2 := by
    rw [show p - 1 = (p - 3) + 2 by ring, Real.rpow_add hl, Real.rpow_two]
  rw [ht, hlpow]
  field_simp
  ring

lemma hasEigenvalue_conjugacy (A : Plane →L[ℝ] Plane) (mu : ℝ) :
    Module.End.HasEigenvalue
      (labelContinuous.toContinuousLinearMap.comp
        (A.comp labelContinuous.symm.toContinuousLinearMap)).toLinearMap mu ↔
      Module.End.HasEigenvalue A.toLinearMap mu := by
  constructor
  · intro h
    obtain ⟨u, hu⟩ := h.exists_hasEigenvector
    apply Module.End.hasEigenvalue_of_hasEigenvector (x := labelContinuous.symm u)
    constructor
    · rw [Module.End.mem_eigenspace_iff]
      change A (labelContinuous.symm u) = mu • labelContinuous.symm u
      have hue : labelContinuous (A (labelContinuous.symm u)) = mu • u := hu.apply_eq_smul
      have he := congrArg labelContinuous.symm hue
      simpa only [ContinuousLinearEquiv.symm_apply_apply, map_smul] using he
    · intro hu0
      apply hu.2
      have he := congrArg labelContinuous hu0
      simpa only [ContinuousLinearEquiv.apply_symm_apply, map_zero] using he
  · intro h
    obtain ⟨u, hu⟩ := h.exists_hasEigenvector
    apply Module.End.hasEigenvalue_of_hasEigenvector (x := labelContinuous u)
    constructor
    · rw [Module.End.mem_eigenspace_iff]
      change labelContinuous (A (labelContinuous.symm (labelContinuous u))) =
        mu • labelContinuous u
      have hue : A u = mu • u := hu.apply_eq_smul
      rw [ContinuousLinearEquiv.symm_apply_apply, hue, map_smul]
    · intro hu0
      apply hu.2
      have he := congrArg labelContinuous.symm hu0
      simpa only [ContinuousLinearEquiv.symm_apply_apply, map_zero] using he

lemma scaled_eigenvalue_iff (p c mu : ℝ) {z : Plane} (hz : 0 < z 1) :
    Module.End.HasEigenvalue
      (((4 * c) / 2) • fderiv ℝ (edgeField p) (labelMap z)).toLinearMap mu ↔
      Module.End.HasEigenvalue ((c • fderiv ℝ (singularField p) z).toLinearMap) mu := by
  rw [scaled_derivative_conjugacy p c hz]
  have he : c • labelContinuous.toContinuousLinearMap.comp
      ((fderiv ℝ (singularField p) z).comp labelContinuous.symm.toContinuousLinearMap) =
      labelContinuous.toContinuousLinearMap.comp
        ((c • fderiv ℝ (singularField p) z).comp labelContinuous.symm.toContinuousLinearMap) := by
    ext u
    simp
  rw [he]
  exact hasEigenvalue_conjugacy _ _

lemma edgeField_Hamiltonian (p w : ℝ) {l : ℝ} (hl : 0 < l) :
    edgeField p (vec2 w l) =
      vec2 (-deriv (fun r : ℝ => edgeHamiltonian p w r) l)
        (deriv (fun v : ℝ => edgeHamiltonian p v l) w) := by
  rw [edgeHamiltonian_deriv_l p w hl, edgeHamiltonian_deriv_w p w hl]
  rfl

lemma labelContinuous_matrix : labelContinuous.toContinuousLinearMap =
    matrixCLM (1 / 2) 0 0 1 := by
  ext z i
  fin_cases i <;> simp [labelContinuous, labelLinear, labelMap, matrixCLM_apply, vec2]
  ring

lemma labelContinuous_det : labelContinuous.toContinuousLinearMap.det = (1 / 2 : ℝ) := by
  rw [labelContinuous_matrix]
  change LinearMap.det (matrixCLM (1 / 2) 0 0 1).toLinearMap = _
  rw [matrixCLM_det]
  norm_num

lemma labelMap_integral_image {D : Set Plane} (hD : MeasurableSet D) (f : Plane → ℝ) :
    (∫ z in labelMap '' D, f z) = (1 / 2 : ℝ) * (∫ z in D, f (labelMap z)) := by
  change (∫ z in labelContinuous '' D, f z) = _
  rw [integral_image_eq_integral_abs_det_fderiv_smul volume hD
    (fun z _ => labelContinuous.hasFDerivAt.hasFDerivWithinAt) labelContinuous.injective.injOn]
  simp_rw [labelContinuous_det]
  norm_num only [abs_of_pos (by norm_num : (0 : ℝ) < 1 / 2), smul_eq_mul]
  rw [integral_const_mul]
  rfl

lemma physicalWeight_dictionary (p c : ℝ) {z : Plane} (hz : 0 < z 1) :
    physicalWeight (1 / Real.sqrt 2) ((4 * c) • edgeField p (labelMap z)) =
      physicalWeight (Real.sqrt 2) (c • singularField p z) := by
  unfold physicalWeight
  simp only [PiLp.smul_apply, smul_eq_mul, edgeField, vec2_apply_zero, vec2_apply_one]
  rw [edgeU_labelMap, edgeV_labelMap p hz, physical_height_square,
    Real.sq_sqrt (by norm_num : (0 : ℝ) ≤ 2)]
  congr 2
  ring

lemma physical_cost_dictionary (p c : ℝ) {D : Set Plane} (hD : MeasurableSet D)
    (hpos : ∀ z ∈ D, 0 < z 1) :
    (1 / Real.sqrt 2) *
      (∫ z in labelMap '' D, physicalWeight (1 / Real.sqrt 2) ((4 * c) • edgeField p z)) =
      (Real.sqrt 2 * (∫ z in D, physicalWeight (Real.sqrt 2) (c • singularField p z))) / 4 := by
  rw [labelMap_integral_image hD]
  have hi : (∫ z in D, physicalWeight (1 / Real.sqrt 2) ((4 * c) • edgeField p (labelMap z))) =
      (∫ z in D, physicalWeight (Real.sqrt 2) (c • singularField p z)) := by
    apply setIntegral_congr_fun hD
    intro z hz
    exact physicalWeight_dictionary p c (hpos z hz)
  rw [hi, ← height_factor]
  ring

end SingularEdgeOne

end

end OAI