import OAI.Geometry.Convex.GeneralMahler.Kernel

namespace OAI
/-! p-to-indicator score and layer integration formulas. -/
noncomputable section
open MeasureTheory MeasureTheory.Measure Filter Set Matrix Real Metric
open scoped Topology NNReal ENNReal MatrixOrder Matrix.Norms.L2Operator RealInnerProductSpace
namespace GeneralMahler
open Layers Profile
def jump (z y:ℝ) := if y≤z then (1:ℝ) else 0
lemma jump_m : Measurable (Function.uncurry jump) :=
  Measurable.ite ((isClosed_le continuous_snd continuous_fst).measurableSet)
    measurable_const measurable_const
def score (z y:ℝ) := p z-jump z y

lemma score_m : Measurable score.uncurry := (cp.measurable.comp measurable_fst).sub jump_m

lemma score_rapid : mixed score := by
  let f := fun z (_:ℝ)=> p z-st z
  let g := fun z y=>st z-jump z y
  rw [show score=fun z y=> f z y+g z y from funext fun x=>funext fun y=>by unfold score f g; ring]
  apply (mixed.of_rapid rapid_p).add
  apply mixed.of_cutoff (show PolyBound g.uncurry from PolyBound.of_bound 1 fun ⟨x,y⟩=>by
    change ‖st x-jump x y‖≤1; unfold st jump; split_ifs <;> norm_num)
    (show PolyBound (fun x:ℝ=>‖x‖) from PolyBound.id.norm)
  intro x y hx
  simp only [Real.norm_eq_abs] at hx
  unfold g st jump; split_ifs <;> grind

def ss (f:ℝ→ℝ) (z y:ℝ) := score z y * deriv f z
lemma ss_m {f:ℝ→ℝ} (hf:TestF f) : mixed (ss f) :=
  score_rapid.product (g:=fun x _=>deriv f x) (show PolyBound (fun u:Plane=> deriv f u.1) from hf.der.poly.comp PolyBound.fst)
    fun _x _y=> (norm_mul _ _).le
lemma ss_sm (f) : Measurable (ss f).uncurry :=
  score_m.mul ((measurable_deriv f).comp measurable_fst)

lemma centered_s {f:ℝ→ℝ} (hf:TestF f) (x:ℝ) :
    (∫ z,ss f z x)= f x-ga f := by
  let g := fun z=>ss f z x+phi z*f z
  have hg (t:ℝ) : HasDerivAt (fun z=>p z*f z)
      (phi t*f t+p t*deriv f t) t :=
    (d_p t).fun_mul (hf.diff t).hasDerivAt
  have hg' (t:ℝ) : HasDerivAt (fun z=>(p z-1)*f z)
      (phi t*f t+(p t-1)*deriv f t) t :=
    ((d_p t).sub_const 1).fun_mul (hf.diff t).hasDerivAt
  have ht := rapid_p.product hf.poly
  have hi := mixed_integrable_left (μ:=volume) (ss_m hf) x
    ((ss_sm f).comp (measurable_id.prodMk measurable_const)).aestronglyMeasurable
  have hh : Integrable g := hi.add (ga_i hf)
  have h₀ : Tendsto (fun x=>p x*f x) atBot (𝓝 0) := by
    apply Tendsto.congr' _ ht.tail_limit_bot
    filter_upwards [eventually_lt_atBot (0:ℝ)] with z hz; simp [st,not_le_of_gt hz]
  have h₁ : Tendsto (fun x=>(p x-1)*f x) atTop (𝓝 0) := by
    apply Tendsto.congr' _ ht.tail_limit
    filter_upwards [eventually_ge_atTop (0:ℝ)] with z hz; simp [st,hz]
  have ha : (∫ t in Iic x,g t)=p x*f x := by
    have hh := integral_Iic_of_hasDerivAt_of_tendsto ((hg x).continuousAt.continuousWithinAt)
      (fun t ht => ?_) hh.integrableOn h₀
    · simpa using hh
    have he : g t=phi t*f t+p t*deriv f t := by simp only [g,ss,score,jump,
      ite_eq_right (not_le_of_gt (mem_Iio.mp ht)),sub_zero]; ring
    exact he.symm ▸ hg t
  have hb : (∫ t in Ioi x,g t)= -((p x-1)*f x) := by
    have hh := integral_Ioi_of_hasDerivAt_of_tendsto ((hg' x).continuousAt.continuousWithinAt)
      (fun t ht => ?_) hh.integrableOn h₁
    · simpa using hh
    have he : g t=phi t*f t+(p t-1)*deriv f t :=
      by simp only [g,ss,score,jump,ite_eq_left (mem_Ioi.mp ht).le]; ring
    exact he.symm ▸ hg' t
  have hx : (∫ t,g t)=f x := by
    rw [← integral_add_compl measurableSet_Iic (s:=Iic x) hh,compl_Iic,ha,hb]; ring
  rw [show (∫ t,g t) = _ from integral_add hi (ga_i hf)] at hx
  unfold ga; linarith

lemma two_scores {f j:ℝ→ℝ} (hf:TestF f) (hj:TestF j) :
    mixed fun u:Plane => fun y=>ss f u.1 y*ss j u.2 y := by
  intro n
  obtain ⟨C,m,hc,h⟩ := ss_m hf n
  obtain ⟨D,k,hd,h'⟩ := ss_m hj n
  use C*D,m+k,mul_nonneg hc hd
  intro u y
  rw [norm_mul]
  have ha : (1+‖u‖)^n ≤ (1+‖u.1‖)^n*(1+‖u.2‖)^n := by
    rw [← mul_pow]
    apply pow_le_pow_left₀ (by positivity)
    change 1+max _ _ ≤ _
    rcases max_choice ‖u.1‖ ‖u.2‖ with h|h <;> rw [h] <;> nlinarith [norm_nonneg u.1,norm_nonneg u.2]
  apply le_trans (mul_le_mul_of_nonneg_left ha (by positivity))
  calc
    _ = (‖ss f u.1 y‖*(1+‖u.1‖)^n)*(‖ss j u.2 y‖*(1+‖u.2‖)^n) := by ring
    _ ≤ _ := mul_le_mul (h _ _) (h' _ _) (by positivity) (by positivity)
    _ = _ := by rw [pow_add]; ring

lemma moment_mix {w:ℝ→ℝ} (hw:MomentF w) (hm:Measurable w) (hp:∀ x,0≤w x)
    {f:Plane→ℝ→ℝ} (hf:mixed f) (hf':Measurable f.uncurry) :
    Integrable (fun v:Plane×ℝ=> w v.2*f v.1 v.2) := by
  let d := Module.finrank ℝ Plane+1
  obtain ⟨C,n,hc,h⟩ := hf d
  let b := fun x:Plane=> ((1+‖x‖)^d)⁻¹
  have hh : Integrable b := envelope_inv_int
  let g := fun x:ℝ=>w x * (C*(1+‖x‖)^n)
  have hg : Integrable g := hw _ (by fun_prop)
    ((PolyBound.const _).mul (((PolyBound.const _).add PolyBound.id.norm).pow n))
  apply (hh.mul_prod hg).mono' ((hm.comp measurable_snd).mul hf').aestronglyMeasurable
    (ae_of_all _ ?_)
  rintro ⟨x,y⟩
  change ‖w y*f x y‖ ≤ b x*g y
  rw [norm_mul,Real.norm_of_nonneg (hp _)]
  have he : ‖f x y‖ ≤ C*(1+‖y‖)^n*b x := by
    unfold b
    rw [← div_eq_mul_inv, le_div_iff₀ (by positivity)]
    exact h x y
  unfold g
  apply le_trans (mul_le_mul_of_nonneg_left he (hp _)); apply le_of_eq; ring

variable {m:ℕ} [NeZero m]
namespace ProjField
variable (q:ProjField m)
def Hcov (u:Plane) := q.s0*p u.1*p u.2 - p u.1*q.avH u.2 - q.avH u.1*p u.2+
  q.avH (min u.1 u.2)
lemma H_jump (x:ℝ) :
    (∫ z,q.layerW z*jump x z)=q.avH x := by
  rw [show (fun z=>q.layerW z*jump x z)=(Iic x).indicator q.layerW from by ext t; by_cases h:t≤x <;> simp [jump,h]]
  rw [integral_indicator measurableSet_Iic]
  have hh := integral_Iic_of_hasDerivAt_of_tendsto'
    (f:=q.avH) (a:=x) (fun t _=>q.H_deriv t) q.integrable_w.integrableOn q.H_bot
  simpa using hh

lemma H_score (u:Plane) : q.Hcov u=∫ y,q.layerW y*(score u.1 y*score u.2 y) := by
  let f := fun x z => q.layerW z*jump x z
  have hi (x) : Integrable (f x) := q.moment_w (jump x)
    (jump_m.comp (measurable_const.prodMk measurable_id)) (PolyBound.of_bound 1
      (fun y=>by unfold jump; split<;>norm_num))
  set a := u.1; set b := u.2
  have he (y) : q.layerW y*(score a y*score b y) =
      (q.layerW y*(p a*p b)-f b y*p a-f a y*p b)+f (min a b) y := by
    unfold f score
    have hh : jump a y*jump b y=jump (min a b) y := by unfold jump; split_ifs <;> grind
    rw [← hh]; ring
  simp_rw [he]
  have ha := (hi a).mul_const (p b)
  have hb := (hi b).mul_const (p a)
  have hd := q.integrable_w.mul_const (p a*p b)
  rw [integral_add,integral_sub,integral_sub hd hb]
  · unfold f; simp_rw [integral_mul_const, q.H_jump,q.integral_w]
    unfold Hcov a b; ring
  all_goals first | exact hi _ | exact ha | exact hd.sub hb | exact (hd.sub hb).sub ha

lemma H_cov_I {f g:ℝ→ℝ} (hf:TestF f) (hg:TestF g) :
    Integrable (fun x:Plane=>q.Hcov x*(deriv f x.1*deriv g x.2)) ∧
    (∫ x:Plane,q.Hcov x*(deriv f x.1*deriv g x.2))=
      ∫ x,q.layerW x*((f x-ga f)*(g x-ga g)) := by
  let F := fun u:Plane=>fun x:ℝ=>ss f u.1 x*ss g u.2 x
  let C := fun u:Plane×ℝ=>q.layerW u.2*F u.1 u.2
  have hm : Measurable F.uncurry :=
    ((ss_sm f).comp ((measurable_fst.comp measurable_fst).prodMk measurable_snd)).mul
      ((ss_sm g).comp ((measurable_snd.comp measurable_fst).prodMk measurable_snd))
  have hi : Integrable C :=
    moment_mix q.moment_w q.w_cont.measurable (fun x=>(q.w_positive x).le) (two_scores hf hg) hm
  have hh (u:Plane) : q.Hcov u*(deriv f u.1*deriv g u.2)=∫ y,C (u,y) := by
    rw [q.H_score, ← integral_mul_const]
    congr 1; ext; unfold C F ss; ring
  simp_rw [hh]
  refine ⟨hi.integral_prod_left,?_⟩
  rw [integral_integral_swap]
  · congr 1; ext y; dsimp only [C,F]; rw [integral_const_mul,show (volume:Measure Plane)=volume.prod volume from rfl,
      integral_prod_mul (fun x=>ss f x y) (fun x=>ss g x y), centered_s hf,centered_s hg]
  exact hi
end ProjField
end GeneralMahler

end

end OAI