import OAI.Combinatorics.EditApproximation.Geometry.BandNumericalBits
import OAI.Combinatorics.EditApproximation.Geometry.BandEnvelopes

namespace OAI

/-! Encoding lengths of the actual finite maxima and dyadic envelopes.
These estimates include the scales below one and require no good seed. -/

namespace EditApproximation

theorem positive_rational_binary_bounds (r : ℚ) (B : ℕ)
    (hr : 0 < r) (hbits : rationalEncodingBits r ≤ B) :
    (2 : ℚ) ^ (-(B : ℤ)) ≤ r ∧ r ≤ (2 : ℚ) ^ (B : ℤ) := by
  have hnumSize : Nat.size r.num.natAbs ≤ B := by unfold rationalEncodingBits at hbits; omega
  have hdenSize : Nat.size r.den ≤ B := by unfold rationalEncodingBits at hbits; omega
  have hnum : r.num.natAbs ≤ 2 ^ B :=
    (Nat.lt_size_self _).le.trans (Nat.pow_le_pow_right (by decide) hnumSize)
  have hden : r.den ≤ 2 ^ B :=
    (Nat.lt_size_self _).le.trans (Nat.pow_le_pow_right (by decide) hdenSize)
  have hnumPos : 0 < r.num := Rat.num_pos.mpr hr
  have hnumOne : 1 ≤ r.num.natAbs := Int.natAbs_pos.mpr (ne_of_gt hnumPos)
  have hrep : r = (r.num.natAbs : ℚ) / r.den := by
    rw [← Int.cast_natCast, Int.natCast_natAbs, abs_of_pos hnumPos]
    exact r.num_div_den.symm
  have hd : (0 : ℚ) < r.den := by exact_mod_cast r.den_pos
  have hp : (0 : ℚ) < (2 : ℚ) ^ B := pow_pos (by norm_num) _
  simp only [zpow_neg, zpow_natCast]
  rw [hrep]
  constructor
  · rw [inv_eq_one_div, div_le_div_iff₀ hp hd, one_mul]
    exact_mod_cast (hden.trans (Nat.le_mul_of_pos_left _ (by omega : 0 < r.num.natAbs)))
  · apply (div_le_iff₀ hd).mpr
    exact_mod_cast (hnum.trans (Nat.le_mul_of_pos_right _ r.den_pos))

theorem rationalDyadicCeiling_encoding (r : ℚ) (B : ℕ)
    (hr : 0 < r) (hbits : rationalEncodingBits r ≤ B) :
    rationalEncodingBits (rationalDyadicCeiling r) ≤ 5 * B + 5 := by
  have hrange := positive_rational_binary_bounds r B hr hbits
  have hlo := Int.clog_mono_right (b := 2) (zpow_pos (by norm_num : (0 : ℚ) < 2) (-(B : ℤ))) hrange.1
  have hhi := Int.clog_mono_right (b := 2) hr hrange.2
  have hclog (z : ℤ) : Int.clog 2 ((2 : ℚ) ^ z) = z := by
    simpa only [Nat.cast_ofNat] using (Int.clog_zpow (R := ℚ) (b := 2) (by decide) z)
  rw [hclog] at hlo hhi
  have htwo : rationalEncodingBits (2 : ℚ) = 4 := by
    rw [show (2 : ℚ) = (2 : ℕ) by norm_num, rationalEncodingBits_natCast]
    rfl
  unfold rationalDyadicCeiling
  cases he : Int.clog 2 r with
  | ofNat n =>
    rw [he, Int.ofNat_eq_natCast] at hlo hhi
    have hn : n ≤ B := by omega
    rw [Int.ofNat_eq_natCast, zpow_natCast]
    have h := rationalEncodingBits_pow (2 : ℚ) n
    rw [htwo] at h
    omega
  | negSucc n =>
    rw [he, Int.negSucc_eq] at hlo hhi
    have hn : n + 1 ≤ B := by omega
    rw [zpow_negSucc]
    have hp := rationalEncodingBits_pow (2 : ℚ) (n + 1)
    have hi := rationalEncodingBits_inv ((2 : ℚ) ^ (n + 1))
    rw [htwo] at hp
    omega

theorem rationalMaximum_encoding (fallback : ℚ) (values : List ℚ) (B : ℕ)
    (hfallback : rationalEncodingBits fallback ≤ B)
    (hvalues : ∀ value ∈ values, rationalEncodingBits value ≤ B) :
    rationalEncodingBits (rationalMaximum fallback values) ≤ B := by
  induction values with
  | nil => exact hfallback
  | cons value rest ih =>
    have hv := hvalues value List.mem_cons_self
    have ht := ih (fun q hq => hvalues q (List.mem_cons_of_mem _ hq))
    change rationalEncodingBits (max value (rationalMaximum fallback rest)) ≤ B
    rcases le_total value (rationalMaximum fallback rest) with h | h
    · simpa only [max_eq_right h] using ht
    · simpa only [max_eq_left h] using hv

def bandEnvelopeEncodingBudget (M b initialBits : ℕ) : ℕ :=
  5 * max (Nat.size b + Nat.size M + 7) (initialBits + 2) + 5

theorem bandChildEnvelope_encoding {ny M : ℕ} (b : ℕ)
    (band : List (Fin M → TargetInterval ny))
    (initial : Fin M → TargetInterval ny → ℚ) (B : ℕ) (hb : 0 < b) (hM : 0 < M)
    (hinitial : ∀ action ∈ band, ∀ i, rationalEncodingBits (initial i (action i)) ≤ B)
    (i : Fin M) :
    rationalEncodingBits (bandChildEnvelope b band initial i) ≤ bandEnvelopeEncodingBudget M b B := by
  have hmax := rationalMaximum_encoding 0 (band.map fun action => initial i (action i)) (B + 2)
    (by norm_num [rationalEncodingBits]) (by
      intro q hq
      obtain ⟨action, ha, rfl⟩ := List.mem_map.mp hq
      exact (hinitial action ha i).trans (by omega))
  have hfloor := rationalEncodingBits_div (b : ℚ) (M : ℚ)
  rw [rationalEncodingBits_natCast, rationalEncodingBits_natCast] at hfloor
  have hbits : rationalEncodingBits (max ((b : ℚ) / M)
      (rationalMaximum 0 (band.map fun action => initial i (action i)))) ≤
        max (Nat.size b + Nat.size M + 7) (B + 2) := by
    rcases le_total ((b : ℚ) / M) (rationalMaximum 0 (band.map fun action => initial i (action i))) with h | h
    · rw [max_eq_right h]
      exact hmax.trans (Nat.le_max_right _ _)
    · rw [max_eq_left h]
      exact hfloor.trans (by have h := Nat.le_max_left (Nat.size b + Nat.size M + 7) (B + 2); omega)
  exact rationalDyadicCeiling_encoding _ _
    ((div_pos (by exact_mod_cast hb) (by exact_mod_cast hM)).trans_le (le_max_left _ _)) hbits

end EditApproximation

end OAI