import OAI.Probability.SATComputability.RationalHierarchy
import OAI.Probability.SATComputability.ArithmeticConstructors

namespace OAI

namespace FixedClauseThreshold.Computability

open Encodable Denumerable Nat.Partrec FiniteArithmetic
open scoped BigOperators
local instance hierarchyEncodingRatPrimcodable : Primcodable ℚ := PeriodicLattice.RecursiveArithmetic.ratPrimcodable

noncomputable def branchEntry : Code → ℚ × Code
  | .comp w c => (decodedRational w, c)
  | _ => (0, .zero)

noncomputable def rawBranches : Code → List (ℚ × Code)
  | .pair c rest => branchEntry c :: rawBranches rest
  | _ => []

noncomputable def encodeBranches (bs : List (ℚ × Code)) : Code :=
  bs.foldr (fun b rest => .pair (.comp (ofNat Code (encode b.1)) b.2) rest) .zero

theorem rawBranches_encode (bs : List (ℚ × Code)) : rawBranches (encodeBranches bs) = bs := by
  induction bs with
  | nil => rfl
  | cons b bs ih =>
    simp only [encodeBranches, List.foldr_cons, rawBranches, branchEntry, decodedRational,
      encode_ofNat, encodek, Option.getD_some]
    exact congrArg (b :: ·) ih

noncomputable def normalizedBranches (c : Code) : List (ℚ × Code) :=
  let bs := rawBranches c
  let s := (bs.map (fun b => |b.1|)).sum
  if s = 0 then [(1, .zero)] else bs.map (fun b => (|b.1|/s, b.2))

theorem normalizedBranches_nonneg (c : Code) :
    ∀ b ∈ normalizedBranches c, 0 ≤ b.1 := by
  dsimp only [normalizedBranches]
  split_ifs with hs
  · simp
  · intro b hb
    obtain ⟨x, _, rfl⟩ := List.mem_map.mp hb
    exact div_nonneg (abs_nonneg _) (List.sum_nonneg (fun _ hx => by
      obtain ⟨y, _, rfl⟩ := List.mem_map.mp hx
      exact abs_nonneg _))

theorem normalizedBranches_sum (c : Code) :
    ((normalizedBranches c).map Prod.fst).sum = 1 := by
  dsimp only [normalizedBranches]
  split_ifs with hs
  · simp
  · simp only [List.map_map, Function.comp_def]
    simp only [div_eq_mul_inv]
    rw [List.sum_map_mul_right]
    exact mul_inv_cancel₀ hs

theorem normalizedBranches_encode {bs : List (ℚ × Code)}
    (hpos : ∀ b ∈ bs, 0 ≤ b.1) (hs : (bs.map Prod.fst).sum = 1) :
    normalizedBranches (encodeBranches bs) = bs := by
  have ha : bs.map (fun b => |b.1|) = bs.map Prod.fst := by
    apply List.map_congr_left
    intro b hb
    exact abs_of_nonneg (hpos b hb)
  simp only [normalizedBranches, rawBranches_encode, ha, hs, one_ne_zero, ite_false, div_one]
  conv_rhs => rw [← List.map_id bs]
  apply List.map_congr_left
  intro b hb
  exact Prod.ext (abs_of_nonneg (hpos b hb)) rfl

noncomputable def branchWeights (c : Code) :
    RationalWeights (Fin (normalizedBranches c).length) :=
  ⟨fun i => ((normalizedBranches c).get i).1, by
    constructor
    · intro i
      exact normalizedBranches_nonneg c _ (List.get_mem _ _)
    · have h : (List.ofFn (fun i : Fin (normalizedBranches c).length =>
          ((normalizedBranches c).get i).1)).sum = 1 := by
        simp only [List.get_eq_getElem]
        rw [List.ofFn_getElem_eq_map, normalizedBranches_sum]
      simpa only [List.sum_ofFn] using h⟩

noncomputable def decodeTree : (r : ℕ) → Code → RationalTree r
  | 0, c => decodedRational c
  | r+1, c => ⟨(normalizedBranches c).length, branchWeights c,
      fun i => decodeTree r ((normalizedBranches c).get i).2⟩

noncomputable def encodeTree : (r : ℕ) → RationalTree r → Code
  | 0, q => ofNat Code (@encode ℚ Rat.instEncodable q)
  | r+1, t => encodeBranches (List.ofFn (fun i : Fin t.1 =>
      (t.2.1.val i, encodeTree r (t.2.2 i))))

theorem normalizedBranches_encodeTree (r : ℕ) (t : RationalTree (r+1)) :
    normalizedBranches (encodeTree (r+1) t) =
      List.ofFn (fun i : Fin t.1 => (t.2.1.val i, encodeTree r (t.2.2 i))) := by
  apply normalizedBranches_encode
  · intro b hb
    obtain ⟨i, rfl⟩ := List.mem_ofFn.mp hb
    exact t.2.1.property.1 i
  · rw [List.map_ofFn, List.sum_ofFn]
    exact t.2.1.property.2

theorem rationalTree_node_ext {r n k : ℕ} (hn : n = k)
    (w : RationalWeights (Fin n)) (v : RationalWeights (Fin k))
    (x : Fin n → RationalTree r) (y : Fin k → RationalTree r)
    (hw : ∀ i, w.val i = v.val (Fin.cast hn i))
    (hx : ∀ i, x i = y (Fin.cast hn i)) :
    (⟨n, w, x⟩ : RationalTree (r+1)) = ⟨k, v, y⟩ := by
  subst k
  apply congrArg (Sigma.mk n)
  apply Prod.ext
  · exact Subtype.ext (funext hw)
  · exact funext hx

theorem decodeTree_encodeTree (r : ℕ) (t : RationalTree r) :
    decodeTree r (encodeTree r t) = t := by
  induction r with
  | zero =>
    change decodedRational (ofNat Code (@encode ℚ Rat.instEncodable t)) = t
    simp only [decodedRational, encode_ofNat]
    exact congrArg (fun o : Option ℚ => o.getD 0) (@Encodable.encodek ℚ Rat.instEncodable t)
  | succ r ih =>
    obtain ⟨n, w, x⟩ := t
    let c := encodeTree (r+1) ⟨n, w, x⟩
    have he : normalizedBranches c =
        List.ofFn (fun i : Fin n => (w.val i, encodeTree r (x i))) :=
      normalizedBranches_encodeTree r ⟨n, w, x⟩
    change (⟨(normalizedBranches c).length, branchWeights c,
      fun i => decodeTree r ((normalizedBranches c).get i).2⟩ :
        Σ k : ℕ, RationalWeights (Fin k) × (Fin k → RationalTree r)) = ⟨n, w, x⟩
    have hn : (normalizedBranches c).length = n := by rw [he, List.length_ofFn]
    apply rationalTree_node_ext hn
    · intro i
      change ((normalizedBranches c).get i).1 = w.val (Fin.cast hn i)
      simp only [List.get_eq_getElem, he, List.getElem_ofFn]
      rfl
    · intro i
      simp only [List.get_eq_getElem, he, List.getElem_ofFn]
      exact ih (x (Fin.cast hn i))

theorem decodeTree_surjective (r : ℕ) : Function.Surjective (decodeTree r) :=
  fun t => ⟨encodeTree r t, decodeTree_encodeTree r t⟩

end FixedClauseThreshold.Computability

end OAI