import OAI.MeasureTheory.Falconer.Fourier.MaskedFourier
import OAI.MeasureTheory.Falconer.Estimates.ScaledInverseRemainder

namespace OAI

/-! # The weighted distance law for two different endpoint profiles

Both original marginal laws and their separate normalizations are retained.
The endpoint factors may be the actual descriptor products of different
regularized classes. No common probability law is introduced.
-/

namespace Falconer
open Set MeasureTheory
open scoped ENNReal

noncomputable def endpointDistanceWeight {d : ℕ} (s : ℝ)
    (B C : Space d → Space d → ℝ) (z : Space d × Space d) : ℝ :=
  (dist z.1 z.2/s)^(-(((d:ℝ)-1)/2)) *
    B z.1 (NormedSpace.normalize (z.1-z.2)) * C z.2 (NormedSpace.normalize (z.1-z.2))

noncomputable def endpointWeightedDistance {d : ℕ} (μ ν : Measure (Space d))
    (M P s : ℝ) (B C : Space d → Space d → ℝ) : Measure ℝ :=
  ((μ.prod ν).withDensity (fun z => ENNReal.ofReal
    ((M⁻¹*P⁻¹)*endpointDistanceWeight s B C z))).map (fun z => dist z.1 z.2)

 theorem endpointDistanceWeight_measurable {d : ℕ} (s : ℝ)
    (B C : Space d → Space d → ℝ)
    (hB : Measurable (Function.uncurry B)) (hC : Measurable (Function.uncurry C)) :
    Measurable (endpointDistanceWeight s B C) := by
  have hn : Measurable (fun z : Space d × Space d => NormedSpace.normalize (z.1-z.2)) := by
    unfold NormedSpace.normalize
    fun_prop
  exact (((measurable_fst.dist measurable_snd).div_const s).pow_const _).mul
    (hB.comp (measurable_fst.prodMk hn)) |>.mul (hC.comp (measurable_snd.prodMk hn))

 theorem endpointDistanceWeight_nonneg {d : ℕ} {s : ℝ} (hs : 0 ≤ s)
    (B C : Space d → Space d → ℝ)
    (hB : ∀ x w, 0 ≤ B x w) (hC : ∀ x w, 0 ≤ C x w) (z : Space d × Space d) :
    0 ≤ endpointDistanceWeight s B C z :=
  mul_nonneg (mul_nonneg (Real.rpow_nonneg (div_nonneg dist_nonneg hs) _) (hB _ _)) (hC _ _)

 theorem endpointDistanceWeight_bound {d : ℕ} (hd : 1 ≤ d) {s δ : ℝ} (hδ : 0 < δ)
    (B C : Space d → Space d → ℝ)
    (hB : ∀ x w, B x w ∈ Icc (0:ℝ) 1) (hC : ∀ x w, C x w ∈ Icc (0:ℝ) 1)
    (z : Space d × Space d) (hz : δ ≤ dist z.1 z.2/s) :
    endpointDistanceWeight s B C z ≤ δ^(-(((d:ℝ)-1)/2)) := by
  have hr : 0 ≤ (dist z.1 z.2/s)^(-(((d:ℝ)-1)/2)) := Real.rpow_nonneg (hδ.trans_le hz).le _
  have hd' : (1:ℝ) ≤ d := by exact_mod_cast hd
  apply (mul_le_of_le_one_right (mul_nonneg hr (hB _ _).1) (hC _ _).2).trans
  exact (mul_le_of_le_one_right hr (hB _ _).2).trans
    (Real.rpow_le_rpow_of_nonpos hδ hz (by linarith))

 theorem endpointWeightedDistance_finite {d : ℕ} (hd : 1 ≤ d)
    (μ ν : Measure (Space d)) [IsFiniteMeasure μ] [IsFiniteMeasure ν]
    {M P s δ : ℝ} (hM : 0 < M) (hP : 0 < P) (hδ : 0 < δ)
    (B C : Space d → Space d → ℝ)
    (hB : ∀ x w, B x w ∈ Icc (0:ℝ) 1) (hC : ∀ x w, C x w ∈ Icc (0:ℝ) 1)
    (hsep : ∀ᵐ z ∂μ.prod ν, δ ≤ dist z.1 z.2/s) :
    IsFiniteMeasure (endpointWeightedDistance μ ν M P s B C) := by
  have hbound : ∀ᵐ z ∂μ.prod ν,
      ENNReal.ofReal ((M⁻¹*P⁻¹)*endpointDistanceWeight s B C z) ≤
        ENNReal.ofReal ((M⁻¹*P⁻¹)*δ^(-(((d:ℝ)-1)/2))) := by
    filter_upwards [hsep] with z hz
    exact ENNReal.ofReal_le_ofReal (mul_le_mul_of_nonneg_left
      (endpointDistanceWeight_bound hd hδ B C hB hC z hz) (by positivity))
  let := finite_withDensity_of_bounded (μ.prod ν) _ ENNReal.ofReal_lt_top hbound
  unfold endpointWeightedDistance
  infer_instance

 theorem endpointWeightedDistance_fourier (n : ℕ)
    (μ ν : Measure (Space (n+3))) {M P : ℝ} (hM : 0 < M) (hP : 0 < P)
    {s : ℝ} (hs : 0 < s) (B C : Space (n+3) → Space (n+3) → ℝ)
    (hB : Measurable (Function.uncurry B)) (hC : Measurable (Function.uncurry C))
    (hB0 : ∀ x w, 0 ≤ B x w) (hC0 : ∀ x w, 0 ≤ C x w) (r : ℝ) :
    charFun (endpointWeightedDistance μ ν M P s B C) r =
      (M⁻¹*P⁻¹) • ∫ z, scaledDistanceKernel n s r
        (fun x y w => (B x w : ℂ)*(C y w : ℂ)) z ∂μ.prod ν := by
  rw [charFun_apply_real,endpointWeightedDistance,integral_map (by fun_prop) (by fun_prop)]
  have hw : Measurable (fun z => ENNReal.ofReal
      ((M⁻¹*P⁻¹)*endpointDistanceWeight s B C z)) :=
    ((endpointDistanceWeight_measurable s B C hB hC).const_mul _).ennreal_ofReal
  rw [integral_withDensity_eq_integral_toReal_smul hw
    (Filter.Eventually.of_forall (fun _ => ENNReal.ofReal_lt_top)),← integral_smul]
  apply integral_congr_ae
  filter_upwards with z
  rw [ENNReal.toReal_ofReal (mul_nonneg (by positivity)
    (endpointDistanceWeight_nonneg hs.le B C hB0 hC0 z))]
  have he : -((((n+3:ℕ):ℝ)-1)/2) = -(((n+2:ℕ):ℝ)/2) := by push_cast; ring
  simp only [endpointDistanceWeight,scaledDistanceKernel,he,Complex.real_smul,Complex.ofReal_mul]
  push_cast
  ring_nf

end Falconer

end OAI