import OAI.Geometry.RuledCovering.ConeVolume

namespace OAI

noncomputable section

open Set MeasureTheory Filter Metric
open scoped Topology ContDiff Pointwise

namespace RuledApproximation

lemma IsTriangle.linear_image {E F : Type*}
    [AddCommGroup E] [Module ℝ E] [AddCommGroup F] [Module ℝ F]
    {P : Set E} (hP : IsTriangle P) (f : E →ₗ[ℝ] F) (hf : Function.Injective f) :
    IsTriangle (f '' P) := by
  obtain ⟨c,u,v,hli,rfl⟩ := hP
  refine ⟨f c,f u,f v,?_,?_⟩
  · have hli' := hli.map' f (LinearMap.ker_eq_bot.mpr hf)
    have heq : f ∘ ![u,v] = ![f u,f v] := by funext i; fin_cases i <;> rfl
    rwa [heq] at hli'
  · ext x
    constructor
    · rintro ⟨_,⟨s,t,hs,ht,hst,rfl⟩,rfl⟩
      exact ⟨s,t,hs,ht,hst,by simp⟩
    · rintro ⟨s,t,hs,ht,hst,rfl⟩
      exact ⟨c+s•u+t•v,⟨s,t,hs,ht,hst,rfl⟩,by simp⟩

lemma IsTriangle.translate {E : Type*} [AddCommGroup E] [Module ℝ E]
    {P : Set E} (hP : IsTriangle P) (a : E) :
    IsTriangle ((fun x => a+x) '' P) := by
  obtain ⟨c,u,v,hli,rfl⟩ := hP
  refine ⟨a+c,u,v,hli,?_⟩
  ext x
  constructor
  · rintro ⟨_,⟨s,t,hs,ht,hst,rfl⟩,rfl⟩
    exact ⟨s,t,hs,ht,hst,by abel_nf⟩
  · rintro ⟨s,t,hs,ht,hst,rfl⟩
    exact ⟨c+s•u+t•v,⟨s,t,hs,ht,hst,rfl⟩,by abel_nf⟩

lemma Cylinder.rotate_triangle {C : Cylinder} (hC : C.triangle)
    (R : Space ≃ₗᵢ[ℝ] Space) : (C.rotate R).triangle :=
  hC.linear_image (rotatedPlane C.axis R).toLinearMap (rotatedPlane C.axis R).injective

lemma Cylinder.translate_triangle {C : Cylinder} (hC : C.triangle) (q : Space) :
    (C.translate q).triangle := hC.translate (C.transversePart q)

lemma coneTriangle_triangle {a : ℝ} (ha : 0 < a) : IsTriangle (coneTriangle a) := by
  refine ⟨0,vec2 a a,vec2 (-a) a,?_,?_⟩
  · rw [LinearIndependent.pair_iff]
    intro s t he
    have h0 := congrArg (fun z : Plane => z 0) he
    have h1 := congrArg (fun z : Plane => z 1) he
    simp only [PiLp.add_apply,PiLp.smul_apply,smul_eq_mul,vec2_apply_zero,vec2_apply_one,
      PiLp.zero_apply] at h0 h1
    constructor
    · exact (mul_eq_zero.mp (by linarith : s*a=0)).resolve_right ha.ne'
    · exact (mul_eq_zero.mp (by linarith : t*a=0)).resolve_right ha.ne'
  · ext z
    constructor
    · intro hz
      have hab := abs_le.mp hz.2.2
      refine ⟨(z 1+z 0)/(2*a),(z 1-z 0)/(2*a),
        div_nonneg (by linarith [hab.1]) (by positivity),
        div_nonneg (by linarith [hab.2]) (by positivity),?_,?_⟩
      · rw [← add_div,div_le_one (by positivity : 0 < 2*a)]
        linarith [hz.2.1]
      · ext i
        fin_cases i <;> simp [vec2] <;> field_simp <;> ring
    · rintro ⟨s,t,hs,ht,hst,rfl⟩
      simp only [coneTriangle,mem_ofPred_eq,PiLp.add_apply,PiLp.smul_apply,smul_eq_mul,
        vec2_apply_one,vec2_apply_zero,zero_add]
      refine ⟨by positivity,by nlinarith,abs_le.mpr ⟨by nlinarith,by nlinarith⟩⟩

def lowerTipCylinder (d : ℝ) : Cylinder :=
  projectedCylinder (Real.sqrt 2) 0 (coneTriangle (2*d))

def upperTipCylinder (d : ℝ) : Cylinder :=
  ((lowerTipCylinder d).rotate swapReflect).translate (vec3 0 0 (Real.sqrt 2))

lemma lowerTipCylinder_triangle {d : ℝ} (hd : 0 < d) : (lowerTipCylinder d).triangle :=
  (coneTriangle_triangle (by positivity : 0 < 2*d)).linear_image _
    (perpendicularProjection_injective (Real.sqrt_pos.mpr (by norm_num)) 0)

lemma upperTipCylinder_triangle {d : ℝ} (hd : 0 < d) : (upperTipCylinder d).triangle :=
  Cylinder.translate_triangle (Cylinder.rotate_triangle (lowerTipCylinder_triangle hd) swapReflect) _

lemma lowerTipCylinder_area {d : ℝ} (hd : 0 ≤ d) :
    (lowerTipCylinder d).area = 4*Real.sqrt 2*d^2 := by
  rw [lowerTipCylinder,projectedCylinder_area (Real.sqrt_pos.mpr (by norm_num)),
    coneTriangle_volume (by positivity : 0 ≤ 2*d)]
  simp only [physicalWeight,PiLp.zero_apply,zero_pow (by norm_num : 2 ≠ 0),add_zero,
    mul_zero,Real.sqrt_one,div_one,mul_one]
  ring

lemma upperTipCylinder_area {d : ℝ} (hd : 0 ≤ d) :
    (upperTipCylinder d).area = 4*Real.sqrt 2*d^2 := by
  rw [upperTipCylinder,Cylinder.translate_area,Cylinder.rotate_area,lowerTipCylinder_area hd]

lemma lowerTipCylinder_carrier (d : ℝ) : (lowerTipCylinder d).carrier = lowerTip d := by
  ext z
  rw [lowerTipCylinder,projectedCylinder_mem_iff]
  constructor
  · rintro ⟨b,hb,s,rfl⟩
    exact ⟨b 1,hb.1,hb.2.1,by simpa [planeEmbedding,physicalDirection,vec3] using hb.2.2,
      by simp [planeEmbedding,physicalDirection,vec3]⟩
  · rintro ⟨t,ht0,htd,hy,hz⟩
    refine ⟨vec2 (z 1) t,⟨ht0,htd,hy⟩,z 0,?_⟩
    ext i
    fin_cases i <;> simp [planeEmbedding,physicalDirection,vec3,hz]

lemma upperTip_image (d : ℝ) :
    (fun z => vec3 0 0 (Real.sqrt 2)+z) '' (swapReflect '' lowerTip d) = upperTip d := by
  ext z
  constructor
  · rintro ⟨_,⟨w,⟨t,ht0,htd,hy,hz⟩,rfl⟩,rfl⟩
    refine ⟨t,ht0,htd,by simpa [swapReflect,vec3] using hy,?_⟩
    change Real.sqrt 2 + -(w 2) = Real.sqrt 2*(1-t)
    rw [hz]
    ring
  · rintro ⟨t,ht0,htd,hx,hz⟩
    refine ⟨swapReflect (vec3 (z 1) (z 0) (Real.sqrt 2*t)),
      ⟨vec3 (z 1) (z 0) (Real.sqrt 2*t),⟨t,ht0,htd,hx,rfl⟩,rfl⟩,?_⟩
    ext i
    fin_cases i <;> simp [swapReflect,vec3,hz]
    ring

lemma upperTipCylinder_carrier (d : ℝ) : (upperTipCylinder d).carrier = upperTip d := by
  rw [upperTipCylinder,Cylinder.translate_carrier,Cylinder.rotate_carrier,lowerTipCylinder_carrier,
    upperTip_image]

end RuledApproximation

end

end OAI