import OAI.Geometry.Relativity.CKS.ComparatorDefinitions
import OAI.Geometry.Relativity.CKS.ConstraintCanonical
import OAI.Geometry.Relativity.CKS.SchwarzschildRoundMetric
import OAI.Geometry.Relativity.CKS.SchwarzschildBoundary
import OAI.Geometry.Relativity.CKS.SchwarzschildHorizon
import OAI.Geometry.Relativity.CKS.SurfaceBarrier
import OAI.Geometry.Relativity.CKS.SurfaceParameter
import OAI.Geometry.Relativity.CKS.TransferDefinitions
import OAI.Geometry.Relativity.CKS.SchwarzschildRadialDecay

namespace OAI

noncomputable section
open Set Filter Manifold Bundle CKSLorentz CKSMetricGluing CKSSpatialManifold
open CKSBoundarySurface CKSIntrinsicConstraints CKSSourceExterior
open scoped ContDiff Topology InnerProductSpace
namespace CKSMain
open CKSSchwarzschild
attribute [local instance] manifold_regular
attribute [local instance] CKSIntrinsicConstraints.halfSpaceDimension_neZero
attribute [local instance] CKSSpatialManifold.real_id_isometric
  CKSLorentz.real_smulCommClass CKSLorentz.spatialDual_smulCommClass

lemma coefficientAtlas_exists {N : Type*} [TopologicalSpace N] [ChartedSpace H3 N]
    [IsManifold I3 ∞ N] {q : SmoothMetric I3 (M := N)} {k : InnerField I3 (M := N)}
    (h : PhysicalDEC I3 q.inner k) : Nonempty (CoefficientAtlas q k) := by
  classical
  exact ⟨fun x => Classical.choose (chart_exists_of_DECAt (h x))⟩

def schwarzschildAtlas {m : ℝ} (hm : 0 < m) :
    CoefficientAtlas (smoothMetric hm) (tensorInner m) :=
  let atlas : ∀ p, ConstraintChart (metricInner m) (tensorInner m) p := fun p => {
    domain := univ
    coordinate := position m
    metric := cartMetric m
    tensor := cartTensor m
    isOpen := isOpen_univ
    mem := mem_univ p
    smooth := by
      run_tac do
        let goal ← Lean.Elab.Tactic.getMainGoal
        goal.setType (← Lean.Core.betaReduce (← Lean.instantiateMVars (← goal.getType)))
        let mass := Lean.mkIdent `m
        Lean.Elab.Tactic.evalTactic (← `(tactic| exact (position_smooth $mass).contMDiffOn))
    fullRank := by
      run_tac do
        let goal ← Lean.Elab.Tactic.getMainGoal
        goal.setType (← Lean.Core.betaReduce (← Lean.instantiateMVars (← goal.getType)))
        let mass := Lean.mkIdent `m
        let massPositive := Lean.mkIdent `hm
        Lean.Elab.Tactic.evalTactic (← `(tactic|
          exact fun _ _ =>
            endInner_fullRank (smoothMetric $massPositive) (position $mass) (cartMetric $mass) rfl))
    coefficientSmooth := by
      run_tac do
        let goal ← Lean.Elab.Tactic.getMainGoal
        goal.setType (← Lean.Core.betaReduce (← Lean.instantiateMVars (← goal.getType)))
        let mass := Lean.mkIdent `m
        let massPositive := Lean.mkIdent `hm
        Lean.Elab.Tactic.evalTactic (← `(tactic|
          exact fun y _ =>
            ⟨cartMetric_smoothAt $massPositive
              (by rw [norm_position $massPositive]; exact radius_ge $mass y),
             cartTensor_smoothAt $massPositive
              (by rw [norm_position $massPositive]; exact radius_ge $mass y)⟩))
    positiveSymmetric := by
      run_tac do
        let goal ← Lean.Elab.Tactic.getMainGoal
        goal.setType (← Lean.Core.betaReduce (← Lean.instantiateMVars (← goal.getType)))
        let mass := Lean.mkIdent `m
        let massPositive := Lean.mkIdent `hm
        Lean.Elab.Tactic.evalTactic (← `(tactic|
          exact fun y _ => ⟨cartMetric_symm $mass _,
            cartMetric_pos $massPositive
              (by rw [norm_position $massPositive]; exact radius_ge $mass y),
            cartTensor_symm $mass _⟩))
    represents := by
      exact fun _ _ => ⟨rfl,rfl⟩ }
  atlas

def horizonNormal (p : Boundary Exterior) : TangentSpace I3 p.val :=
  EuclideanSpace.single 0 1

lemma horizon_radius {m : ℝ} (hm : 0 < m) (p : Boundary Exterior) :
    ‖position m p.val‖ = 2*m := by simp [norm_position hm,radius,boundary_height p]

lemma horizonNormal_coordinate {m : ℝ} (hm : 0 < m) (p : Boundary Exterior) :
    mfderiv I3 𝓘(ℝ,E3) (position m) p.val (horizonNormal p) =
      radialNormal m (position m p.val) := by
  have hd : dropPlane (EuclideanSpace.single 0 1) = 0 := by
    ext i
    simp [dropPlane_apply]
  have hz : ambientDerivative directionAmbient p.val (EuclideanSpace.single 0 1) = 0 := by
    change mfderiv I3 𝓘(ℝ,E3) directionAmbient p.val (EuclideanSpace.single 0 1) = 0
    rw [mfderiv_directionAmbient]
    change mfderiv I2 𝓘(ℝ,E3) (Subtype.val : CKSSchwarzschild.Sphere → E3) p.val.2
      (dropPlane (EuclideanSpace.single 0 1)) = 0
    rw [hd]
    change (mfderiv I2 𝓘(ℝ,E3) (Subtype.val : CKSSchwarzschild.Sphere → E3) p.val.2)
      (0 : TangentSpace I2 p.val.2) = 0
    exact map_zero _
  change ambientDerivative (position m) p.val (EuclideanSpace.single 0 1) = _
  rw [mfderiv_position,hz]
  simp [radialNormal,horizon_radius hm p,lapse_horizon hm,radialUnit_position hm]

def schwarzschildBoundary {m : ℝ} (hm : 0 < m) :
    BoundaryGeometry (smoothMetric hm) (tensorInner m) where
  normal := horizonNormal
  unit p := by
    change cartMetric m (position m p.val)
      (mfderiv I3 𝓘(ℝ,E3) (position m) p.val (horizonNormal p))
      (mfderiv I3 𝓘(ℝ,E3) (position m) p.val (horizonNormal p)) = 1
    rw [horizonNormal_coordinate hm p]
    exact radialNormal_unit hm (by rw [horizon_radius hm p])
  orthogonal p a := by
    change cartMetric m (position m p.val)
      (mfderiv I3 𝓘(ℝ,E3) (position m) p.val (horizonNormal p))
      (mfderiv I3 𝓘(ℝ,E3) (position m) p.val
        (mfderiv I2 I3 (Subtype.val : Boundary Exterior → Exterior) p a)) = 0
    rw [horizonNormal_coordinate hm p,(CKSBoundarySurface.inclusion_hasMFDeriv p).mfderiv]
    apply radialNormal_orthogonal
    exact (position_radial_inner hm p.val (liftPlane a)).trans (liftPlane_zero a)
  inward p := by change 0 < (EuclideanSpace.single 0 1 : E3) 0; simp
  chart p := schwarzschildAtlas hm p.val
  normal_smooth p := by
    change ContMDiffAt I2 𝓘(ℝ,E3) ∞
      (fun z : Boundary Exterior =>
        mfderiv I3 𝓘(ℝ,E3) (position m) z.val (horizonNormal z)) p
    have he : (fun z : Boundary Exterior =>
        mfderiv I3 𝓘(ℝ,E3) (position m) z.val (horizonNormal z)) =
        directionAmbient ∘ (Subtype.val : Boundary Exterior → Exterior) := by
      funext z
      rw [horizonNormal_coordinate hm z]
      simp [radialNormal,horizon_radius hm z,lapse_horizon hm,radialUnit_position hm]
      rfl
    rw [he]
    exact (directionAmbient_smooth.comp CKSBoundarySurface.inclusion_smooth) p

lemma constant_radius_hessian {f : E2 → E3} {y : E2}
    (hf : ContDiffAt ℝ ∞ f y) (hn : ∀ z, ‖f z‖ = ‖f y‖) (a : E2) :
    ⟪f y, fderiv ℝ (fun z => fderiv ℝ f z a) y a⟫_ℝ =
      -⟪fderiv ℝ f y a,fderiv ℝ f y a⟫_ℝ := by
  have hc : ContDiffAt ℝ ∞ (fun t : ℝ => f (y+t•a)) 0 := by
    have hh : ContDiffAt ℝ ∞ f (y+(0:ℝ)•a) := by simpa using hf
    exact hh.comp 0 (contDiffAt_const.add (contDiffAt_id.smul contDiffAt_const))
  have he : (fun t : ℝ => ‖f (y+t•a)‖^2) = (fun _ : ℝ => ‖f y‖^2) :=
    funext (fun t => congrArg (fun r : ℝ => r^2) (hn (y+t•a)))
  have h := curve_normSq_second hc
  rw [he,line_second_deriv hf a,line_deriv (hf.differentiableAt (by simp)) a] at h
  simp only [deriv_const',deriv_const,zero_smul,add_zero] at h
  linarith

lemma constant_radius_second_form {m : ℝ} (hm : 0 < m)
    {f : E2 → E3} {y : E2} (hf : ContDiffAt ℝ ∞ f y)
    (hn : ∀ z, ‖f z‖ = ‖f y‖) (hr : 2*m ≤ ‖f y‖)
    (a : E2) (ha : cartMetric m (f y) (fderiv ℝ f y a) (fderiv ℝ f y a) = 1) :
    parameterSecondForm m f y (radialNormal m (f y)) a a = lapse m ‖f y‖/‖f y‖ := by
  have hmax : IsLocalMax (fun z => ‖f z‖^2) y :=
    Filter.Eventually.of_forall (fun z => by dsimp; rw [hn z])
  have ht := maximum_radius_tangent (hf.differentiableAt (by simp)) hmax a
  have hau : ⟪fderiv ℝ f y a,fderiv ℝ f y a⟫_ℝ = 1 := by
    rwa [cartMetric_tangent m _ _ _ ht] at ha
  have hh := constant_radius_hessian hf hn a
  rw [hau] at hh
  have hs : ⟪radialUnit (f y),fderiv ℝ (fun z => fderiv ℝ f z a) y a⟫_ℝ = -1/‖f y‖ := by
    simp only [radialUnit,real_inner_smul_left,hh,div_eq_mul_inv]
    ring
  rw [parameterSecondForm,metric_normal_pair hm hr,christoffel_tangent_radial hm hr _ _ ht ht,
    hau,mul_one,hs]
  have hu := lapse_pos hm hr
  have hp : 0 < ‖f y‖ := lt_of_lt_of_le (by positivity) hr
  field_simp
  ring

lemma constant_radius_mean {m : ℝ} (hm : 0 < m)
    {f : E2 → E3} {y : E2} (hf : ContDiffAt ℝ ∞ f y)
    (hn : ∀ z, ‖f z‖ = ‖f y‖) (hr : 2*m ≤ ‖f y‖)
    (hi : Function.Injective (fderiv ℝ f y)) :
    parameterMeanCurvature m f y (radialNormal m (f y)) = 2*lapse m ‖f y‖/‖f y‖ := by
  have ha := constant_radius_second_form hm hf hn hr _ (firstFrame_unit _ _ (cartMetric_pos hm hr) hi)
  have hb := constant_radius_second_form hm hf hn hr _ (secondFrame_unit _ _ (cartMetric_pos hm hr) hi)
  dsimp only [parameterMeanCurvature]
  rw [ha,hb]
  ring

lemma schwarzschildMarginal {m : ℝ} (hm : 0 < m) :
    MarginalBoundary (smoothMetric hm) (tensorInner m) := by
  refine ⟨schwarzschildBoundary hm,?_⟩
  intro p
  let F : Boundary Exterior → E3 := position m ∘ Subtype.val
  let f := surfaceParameter F p
  let y := (extChartAt I2 p) p
  have hf := surfaceParameter_smooth ((position_smooth m).comp CKSBoundarySurface.inclusion_smooth) p
  change ContDiffAt ℝ ∞ f y at hf
  have hy : f y = position m p.val := surfaceParameter_center F p
  have hn (z : E2) : ‖f z‖ = 2*m := horizon_radius hm ((extChartAt I2 p).symm z)
  have hc : ∀ z, ‖f z‖ = ‖f y‖ := fun z => (hn z).trans (hn y).symm
  have hi : Function.Injective (fderiv ℝ f y) := by
    rw [surfaceParameter_derivative ((position_smooth m).comp CKSBoundarySurface.inclusion_smooth)]
    rw [mfderiv_comp p ((position_smooth m).mdifferentiable (by simp) _)
      (CKSBoundarySurface.inclusion_smooth.mdifferentiable (by simp) _)]
    exact (position_derivative_injective hm _).comp (CKSBoundarySurface.inclusion_mfderiv_injective p)
  have hr : 2*m ≤ ‖f y‖ := (hn y).ge
  have hH := constant_radius_mean hm hf hc hr hi
  have hmax : IsLocalMax (fun z => ‖f z‖^2) y :=
    Filter.Eventually.of_forall (fun z => by dsimp; rw [hc z])
  have hK := tangent_surface_tensor_trace hm (hf.differentiableAt (by simp)) hmax hr hi
  change parameterMeanCurvature m f y
      (mfderiv I3 𝓘(ℝ,E3) (position m) p.val (horizonNormal p)) + parameterTensorTrace m f y = 0
  rw [horizonNormal_coordinate hm p,← hy,hH,hK,hn y,lapse_horizon hm,velocity_near m _ (by linarith)]
  ring

end CKSMain

end

end OAI