import OAI.Analysis.IntegralMeans.TraceBounds

namespace OAI

noncomputable section
open Set MeasureTheory Filter Function
open scoped Topology ENNReal
namespace Brennan

def logDisk (z : ℂ) : ℂ := Complex.exp (z*Complex.I)

lemma logDisk_norm (z : ℂ) : ‖logDisk z‖ = Real.exp (-z.im) := by
  simp [logDisk,Complex.norm_exp]

lemma logDisk_mem_disk {z : ℂ} (hz : 0 < z.im) : logDisk z ∈ disk := by
  simp only [disk,Metric.mem_ball,dist_zero_right,logDisk_norm]
  exact Real.exp_lt_one_iff.mpr (by linarith)

lemma logDisk_analytic (z : ℂ) : AnalyticAt ℂ logDisk z := by
  exact (analyticAt_cexp).comp ((analyticAt_id.mul analyticAt_const))

lemma logDisk_injOn : InjOn logDisk {z : ℂ | -Real.pi < z.re ∧ z.re < Real.pi} := by
  intro z hz w hw h
  have he := Complex.exp_inj_of_neg_pi_lt_of_le_pi
    (by simpa using hz.1 : -Real.pi < (z*Complex.I).im)
    (by simpa using hz.2.le : (z*Complex.I).im ≤ Real.pi)
    (by simpa using hw.1 : -Real.pi < (w*Complex.I).im)
    (by simpa using hw.2.le : (w*Complex.I).im ≤ Real.pi) h
  exact mul_right_cancel₀ Complex.I_ne_zero he

lemma logDisk_realProd (x y : ℝ) :
    logDisk (Complex.equivRealProdCLM.symm (x,y)) = circlePoint (Real.exp (-y)) x := by
  rw [logDisk,Complex.equivRealProdCLM_symm_apply]
  have he : ((x:ℂ)+y*Complex.I)*Complex.I = (-y:ℂ)+(x:ℂ)*Complex.I := by rw [add_mul,mul_assoc,Complex.I_mul_I]; ring
  rw [he,Complex.exp_add,← Complex.ofReal_neg,← Complex.ofReal_exp]
  rfl

lemma logDisk_periodic (z : ℂ) : logDisk (z+2*Real.pi) = logDisk z := by
  simp only [logDisk,add_mul,Complex.exp_add,Complex.exp_two_pi_mul_I,mul_one]

lemma logStrip_smooth_periodic_side (H : ℂ → ℝ) (y : ℝ) :
    fderiv ℝ ((H ∘ logDisk) ∘ Complex.equivRealProdCLM.symm) (-Real.pi,y) (1,0) =
      fderiv ℝ ((H ∘ logDisk) ∘ Complex.equivRealProdCLM.symm) (Real.pi,y) (1,0) := by
  let g := (H ∘ logDisk) ∘ Complex.equivRealProdCLM.symm
  have he : (fun p : ℝ × ℝ => g (p+(2*Real.pi,0))) = g := by
    ext p
    dsimp [g]
    have hz : Complex.equivRealProdCLM.symm ((p.1,p.2)+(2*Real.pi,0)) =
        Complex.equivRealProdCLM.symm p+2*Real.pi := by
      simp [Complex.equivRealProdCLM_symm_apply]
      ring
    rw [hz,logDisk_periodic]
  have hd := congrArg (fun L : (ℝ × ℝ) →L[ℝ] ℝ => L (1,0))
    (fderiv_comp_add_right (𝕜 := ℝ) (f := g) (x := (-Real.pi,y)) (2*Real.pi,0))
  rw [he] at hd
  have hp : (-Real.pi,y)+(2*Real.pi,0) = (Real.pi,y) := by
    ext <;> dsimp <;> ring
  simpa only [hp] using hd

lemma exp_boundary_lower {y : ℝ} (hy : 0 < y) (hy1 : y ≤ 1) : y/2 ≤ 1-Real.exp (-y) := by
  have he := Real.add_one_le_exp y
  have hp := Real.exp_pos y
  have hn : Real.exp (-y) = (Real.exp y)⁻¹ := Real.exp_neg y
  rw [hn]
  have hi : (Real.exp y)⁻¹ ≤ (1+y)⁻¹ := inv_anti₀ (by linarith) (by linarith)
  have hden : 0 < 1+y := by linarith
  have hf : y/2 ≤ 1-(1+y)⁻¹ := by
    rw [inv_eq_one_div]
    have hh : 1/(1+y) ≤ 1-y/2 := (div_le_iff₀ hden).mpr (by nlinarith)
    linarith
  linarith

lemma logStrip_height_bound {f : ℂ → ℂ} (hf : Schlicht f) {z : ℂ}
    (hz : 0 < z.im) (hz1 : z.im ≤ 1) :
    z.im ≤ 3*(1+‖f (logDisk z)‖^2)^(-1/4:ℝ) := by
  let y := z.im
  let r := Real.exp (-y)
  have hy : 0 < y := hz
  have hyr : r < 1 := Real.exp_lt_one_iff.mpr (by dsimp [y]; linarith)
  have hr : 0 < r := Real.exp_pos _
  have hd : 0 < 1-r := by linarith
  have hg := schlicht_growth_upper hf (logDisk_mem_disk hz)
  rw [logDisk_norm] at hg
  change ‖f (logDisk z)‖ ≤ r/(1-r)^2 at hg
  have hb : ‖f (logDisk z)‖ ≤ 4/y^2 := by
    have hyb := exp_boundary_lower hy hz1
    change y/2 ≤ 1-r at hyb
    calc
      ‖f (logDisk z)‖ ≤ r/(1-r)^2 := hg
      _ ≤ 1/(y/2)^2 := div_le_div₀ (by norm_num) hyr.le (by positivity) (by nlinarith)
      _ = 4/y^2 := by field_simp; ring
  have hy4 : y^4 ≤ 1 := pow_le_one₀ hy.le hz1
  have hs : (1+‖f (logDisk z)‖^2)*y^4 ≤ 17 := by
    have hb' : ‖f (logDisk z)‖*y^2 ≤ 4 := (le_div_iff₀ (sq_pos_of_pos hy)).mp hb
    have hsquare := pow_le_pow_left₀ (by positivity : 0 ≤ ‖f (logDisk z)‖*y^2) hb' 2
    nlinarith [hsquare]
  have hbase : 0 < 1+‖f (logDisk z)‖^2 := by positivity
  have hpow := Real.rpow_le_rpow (by positivity : 0 ≤ (1+‖f (logDisk z)‖^2)*y^4) hs (by norm_num : (0:ℝ) ≤ 1/4)
  rw [Real.mul_rpow (by positivity) (by positivity),← Real.rpow_natCast y 4,
    ← Real.rpow_mul hy.le] at hpow
  norm_num at hpow
  have h17 : (17:ℝ)^(1/4:ℝ) ≤ 3 := by
    calc
      (17:ℝ)^(1/4:ℝ) ≤ (81:ℝ)^(1/4:ℝ) := Real.rpow_le_rpow (by norm_num) (by norm_num) (by norm_num)
      _ = 3 := by rw [show (81:ℝ) = 3^(4:ℝ) by norm_num,← Real.rpow_mul (by norm_num)]; norm_num
  have hmul : y*(1+‖f (logDisk z)‖^2)^(1/4:ℝ) ≤ 3 := by nlinarith
  have hpos := Real.rpow_pos_of_pos hbase (1/4:ℝ)
  rw [show (-1/4:ℝ) = -(1/4) by ring,Real.rpow_neg hbase.le,← div_eq_mul_inv]
  exact (le_div_iff₀ hpos).mpr hmul

end Brennan

end

noncomputable section
open Set MeasureTheory Filter Function InnerProductSpace
open scoped Topology
namespace Brennan

def bracketSq (z : ℂ) : ℝ := 1+z.re^2+z.im^2

def smoothPower (q : ℝ) (z : ℂ) : ℝ := bracketSq z ^ q

lemma bracketSq_eq (z : ℂ) : bracketSq z = 1+‖z‖^2 := by
  rw [Complex.sq_norm]
  simp [bracketSq,Complex.normSq_apply,pow_two,add_assoc]

lemma bracketSq_pos (z : ℂ) : 0 < bracketSq z := by rw [bracketSq_eq]; positivity

lemma bracketSq_contDiff (n : ℕ∞) : ContDiff ℝ n bracketSq := by
  exact (contDiff_const.add (Complex.reCLM.contDiff.pow 2)).add (Complex.imCLM.contDiff.pow 2)

lemma smoothPower_contDiff (q : ℝ) (n : ℕ∞) : ContDiff ℝ n (smoothPower q) :=
  (bracketSq_contDiff n).rpow_const_of_ne (fun z => (bracketSq_pos z).ne')

def bracketSqDeriv (z : ℂ) : ℂ →L[ℝ] ℝ :=
  (2*z.re) • Complex.reCLM + (2*z.im) • Complex.imCLM

lemma bracketSq_hasFDerivAt (z : ℂ) : HasFDerivAt bracketSq (bracketSqDeriv z) z := by
  have h := (((Complex.reCLM.hasFDerivAt (x := z)).pow 2).const_add 1).add
    ((Complex.imCLM.hasFDerivAt (x := z)).pow 2)
  convert! h using 1
  simp [bracketSqDeriv]

lemma smoothPower_hasFDerivAt (q : ℝ) (z : ℂ) :
    HasFDerivAt (smoothPower q) ((q*bracketSq z^(q-1)) • bracketSqDeriv z) z :=
  (bracketSq_hasFDerivAt z).rpow_const (Or.inl (bracketSq_pos z).ne')

lemma bracketSqDeriv_hasFDerivAt (z : ℂ) : HasFDerivAt bracketSqDeriv
    ((ContinuousLinearMap.smulRight Complex.reCLM (2 • Complex.reCLM))+
      (ContinuousLinearMap.smulRight Complex.imCLM (2 • Complex.imCLM))) z := by
  have h := (((Complex.reCLM.hasFDerivAt (x := z)).const_mul 2).smul_const Complex.reCLM).add
    (((Complex.imCLM.hasFDerivAt (x := z)).const_mul 2).smul_const Complex.imCLM)
  convert! h using 1
  ext v w
  simp [ContinuousLinearMap.smulRight_apply,smul_eq_mul]
  ring

lemma smoothPower_secondReal (q : ℝ) (z u v : ℂ) :
    secondReal (smoothPower q) z u v =
      q*(q-1)*bracketSq z^(q-2)*(2*z.re*u.re+2*z.im*u.im)*(2*z.re*v.re+2*z.im*v.im)+
        q*bracketSq z^(q-1)*(2*u.re*v.re+2*u.im*v.im) := by
  have he : fderiv ℝ (smoothPower q) = fun z => (q*bracketSq z^(q-1)) • bracketSqDeriv z :=
    funext (fun z => (smoothPower_hasFDerivAt q z).fderiv)
  have hscalar := ((bracketSq_hasFDerivAt z).rpow_const (p := q-1) (Or.inl (bracketSq_pos z).ne')).const_mul q
  have hd := (hscalar.smul (bracketSqDeriv_hasFDerivAt z)).fderiv
  change fderiv ℝ (fun z => (q*bracketSq z^(q-1)) • bracketSqDeriv z) z = _ at hd
  rw [secondReal,he,hd]
  simp [bracketSqDeriv,ContinuousLinearMap.smulRight_apply,smul_eq_mul,show q-1-1=q-2 by ring]
  ring

lemma laplacian_smoothPower (q : ℝ) (z : ℂ) :
    Laplacian.laplacian (smoothPower q) z =
      4*q*bracketSq z^(q-2)*(1+q*‖z‖^2) := by
  rw [laplacian_eq_secondReal,smoothPower_secondReal,smoothPower_secondReal]
  have he : bracketSq z^(q-1) = bracketSq z^(q-2)*bracketSq z := by
    simpa only [show q-2+1=q-1 by ring,Real.rpow_one] using Real.rpow_add (bracketSq_pos z) (q-2) 1
  rw [he,Complex.sq_norm]
  simp [Complex.normSq_apply,bracketSq]
  ring

lemma laplacian_smoothPower_bounds {q : ℝ} (hq : 0 ≤ q) (hq1 : q ≤ 1) (z : ℂ) :
    0 ≤ Laplacian.laplacian (smoothPower q) z ∧
      Laplacian.laplacian (smoothPower q) z ≤ 4*q*bracketSq z^(q-1) := by
  have hz := bracketSq_pos z
  rw [laplacian_smoothPower]
  constructor
  · positivity
  · have he : bracketSq z^(q-1) = bracketSq z^(q-2)*bracketSq z := by
      simpa only [show q-2+1=q-1 by ring,Real.rpow_one] using Real.rpow_add (bracketSq_pos z) (q-2) 1
    rw [he,← mul_assoc]
    apply mul_le_mul_of_nonneg_left _ (by positivity)
    rw [bracketSq_eq]
    nlinarith [sq_nonneg ‖z‖]

lemma bracketSq_decay_integrable {q : ℝ} (hq : q < 1/4) :
    Integrable (fun z : ℂ => bracketSq z^(q-5/4)) := by
  have h := integrable_rpow_neg_one_add_norm_sq (E := ℂ) (μ := volume) (r := 5/2-2*q)
    (by norm_num [Complex.finrank_real_complex]; linarith)
  convert! h using 1
  ext z
  rw [bracketSq_eq]
  congr 1
  ring

end Brennan

end

noncomputable section
open Set MeasureTheory Filter Function
open scoped Topology ENNReal
namespace Brennan

lemma schlicht_smooth_trace {f : ℂ → ℂ} (hf : Schlicht f) {q : ℝ}
    (hq : 0 < q) (hq4 : q < 1/4) :
    ∃ C : ℝ, ∀ y : ℝ, 0 < y → y ≤ 1 →
      (∫ x in -Real.pi..Real.pi, smoothPower q (f (logDisk (x+y*Complex.I)))) ≤ C := by
  let F : ℂ → ℂ := f ∘ logDisk
  have hF (z : ℂ) (hz : 0 < z.im) : AnalyticAt ℂ F z :=
    ((hf.1.1.analyticOnNhd Metric.isOpen_ball _ (logDisk_mem_disk hz)).comp (logDisk_analytic z))
  apply periodic_conformal_trace_bounded (F := F) (ψ := smoothPower q)
    (b := fun w => bracketSq w^(q-5/4)) (K := 12*q) hF
  · intro z hz w hw he
    apply logDisk_injOn ⟨hz.1,hz.2.1⟩ ⟨hw.1,hw.2.1⟩
    exact hf.1.2 (logDisk_mem_disk hz.2.2) (logDisk_mem_disk hw.2.2) he
  · exact smoothPower_contDiff q 2
  · exact bracketSq_decay_integrable hq4
  · intro w
    exact Real.rpow_nonneg (bracketSq_pos w).le _
  · positivity
  · intro y _hy
    exact logStrip_smooth_periodic_side (smoothPower q ∘ f) y
  · intro z hz hz1
    rw [laplacian_holomorphic_comp (smoothPower_contDiff q 2).contDiffAt (hF z hz)]
    have hl := laplacian_smoothPower_bounds hq.le (by linarith) (F z)
    have hy := logStrip_height_bound hf hz hz1
    rw [← bracketSq_eq] at hy
    change z.im ≤ 3*bracketSq (F z)^(-1/4:ℝ) at hy
    constructor
    · exact mul_nonneg (sq_nonneg _) hl.1
    · calc
        _ ≤ (3*bracketSq (F z)^(-1/4:ℝ)) * (‖deriv F z‖^2*(4*q*bracketSq (F z)^(q-1))) :=
          mul_le_mul hy (mul_le_mul_of_nonneg_left hl.2 (sq_nonneg _))
            (mul_nonneg (sq_nonneg _) hl.1) (mul_nonneg (by norm_num) (Real.rpow_nonneg (bracketSq_pos _).le _))
        _ = _ := by
          have he : bracketSq (F z)^(-1/4:ℝ)*bracketSq (F z)^(q-1) = bracketSq (F z)^(q-5/4) := by
            rw [← Real.rpow_add (bracketSq_pos _)]
            congr 1
            ring
          calc
            _ = (12*q*‖deriv F z‖^2)*(bracketSq (F z)^(-1/4:ℝ)*bracketSq (F z)^(q-1)) := by ring
            _ = _ := by rw [he]

lemma continuous_circle_smoothPower {f : ℂ → ℂ} (hf : Schlicht f) (q r : ℝ)
    (hr : 0 ≤ r) (hr1 : r < 1) : Continuous (fun θ => smoothPower q (f (circlePoint r θ))) := by
  apply (smoothPower_contDiff q 0).continuous.comp
  apply hf.1.1.continuousOn.comp_continuous (show Continuous (circlePoint r) from by unfold circlePoint; fun_prop)
  intro θ
  simpa only [disk,Metric.mem_ball,dist_zero_right,circlePoint_norm,abs_of_nonneg hr] using hr1

lemma schlicht_smooth_means {f : ℂ → ℂ} (hf : Schlicht f) {q : ℝ}
    (hq : 0 < q) (hq4 : q < 1/4) :
    ∃ C : ℝ, 0 < C ∧ ∀ r : ℝ, 0 < r → r < 1 →
      (∫ θ in -Real.pi..Real.pi, smoothPower q (f (circlePoint r θ))) ≤ C := by
  obtain ⟨C,hC⟩ := schlicht_smooth_trace hf hq hq4
  refine ⟨|C|+2*Real.pi*(5:ℝ)^q+1,by positivity,fun r hr hr1 => ?_⟩
  by_cases hrh : r ≤ 1/2
  · have hb (θ : ℝ) : smoothPower q (f (circlePoint r θ)) ≤ (5:ℝ)^q := by
      have hm : circlePoint r θ ∈ disk := by
        simpa [disk,circlePoint_norm,abs_of_pos hr] using hr1
      have hg := schlicht_growth_upper hf hm
      rw [circlePoint_norm,abs_of_pos hr] at hg
      have hv : ‖f (circlePoint r θ)‖ ≤ 2 := by
        have hd : 0 < (1-r)^2 := sq_pos_of_pos (by linarith)
        have hh : r/(1-r)^2 ≤ 2 := (div_le_iff₀ hd).mpr (by nlinarith)
        exact hg.trans hh
      apply Real.rpow_le_rpow (bracketSq_pos _).le _ hq.le
      rw [bracketSq_eq]
      nlinarith [norm_nonneg (f (circlePoint r θ))]
    have hi := intervalIntegral.integral_mono_on (a := -Real.pi) (b := Real.pi) (by linarith [Real.pi_pos])
      ((continuous_circle_smoothPower hf q r hr.le hr1).intervalIntegrable _ _)
      (intervalIntegrable_const (μ := volume)) (fun θ _ => hb θ)
    simp only [intervalIntegral.integral_const,smul_eq_mul] at hi
    have hn := abs_nonneg C
    nlinarith
  · let y := -Real.log r
    have hy : 0 < y := neg_pos.mpr (Real.log_neg hr hr1)
    have hy1 : y ≤ 1 := by
      have hexp : Real.exp (-1) ≤ (1/2:ℝ) := by
        rw [Real.exp_neg]
        have he := Real.add_one_le_exp (1:ℝ)
        exact inv_le_comm₀ (Real.exp_pos _) (by norm_num) |>.mpr (by norm_num; linarith)
      have hlog : -1 ≤ Real.log r := (Real.le_log_iff_exp_le hr).mpr (hexp.trans (by linarith))
      dsimp [y]
      linarith
    have he (x : ℝ) : logDisk ((x:ℂ)+y*Complex.I) = circlePoint r x := by
      have hh := logDisk_realProd x y
      rw [Complex.equivRealProdCLM_symm_apply] at hh
      simpa only [y,neg_neg,Real.exp_log hr] using hh
    have hs := hC y hy hy1
    simp_rw [he] at hs
    have hc' := le_abs_self C
    have hn : 0 ≤ 2*Real.pi*(5:ℝ)^q := by positivity
    linarith

end Brennan

end

end OAI