import Mathlib
import OAI.Computability.MinUncut.Estimates.UniformBoolean
import OAI.Computability.MinUncut.Estimates.UniformTransport

namespace OAI

section
namespace MinUncut.Preprocess
open MinUncutGames.Foundations.Hastad.SourceOccurrences
namespace UEncoding
variable {P : Type} [Primcodable P] {A B Γ : P → Type}

def optionEquiv (X : Type) : Option X ≃ X ⊕ Unit where
  toFun x := match x with | some a => .inl a | none => .inr ()
  invFun x := match x with | .inl a => some a | .inr _ => none
  left_inv := by intro x; cases x <;> rfl
  right_inv := by intro x; cases x with | inl a => rfl | inr a => cases a; rfl

def option (a : UEncoding P A) : UEncoding P (fun p=>Option (A p)) :=
  (a.sum (fixed Encoding.unit)).ofEquiv (fun p=>optionEquiv (A p))
lemma option_code_some (a : UEncoding P A) (p : P) (x : A p) :
    ((a.option.enc p).code (some x)).val=((a.enc p).code x).val := rfl
lemma option_code_none (a : UEncoding P A) (p : P) :
    ((a.option.enc p).code none).val=(a.enc p).size := by
  change (a.enc p).size+0=_
  omega

lemma enumeration_codes {X : Type} (a : Encoding X) :
    a.enumerate.map (fun x=>(a.code x).val)=List.range a.size := by
  simp only [Encoding.enumerate,List.map_ofFn]
  rw [List.ofFn_eq_map]
  simpa only [Function.comp_def,Equiv.apply_symm_apply] using finRange_values a.size

lemma map_find (a : UEncoding P A) :
    (a.function bool).Map a.option (fun p f=>(a.enc p).enumerate.find? f) := by
  let search : ℕ × ℕ → ℕ := fun q=>(List.range q.1).findIdx (fun i=>decide ((q.2/2^i)%2=1))
  have hs : Primrec search := by
    exact Primrec.list_findIdx (Primrec.list_range.comp Primrec.fst)
      (Primrec.eq.decide.comp₂
        (Primrec.nat_mod.comp₂
          (Primrec.nat_div.comp₂ (Primrec.snd.comp Primrec.fst).to₂
            (primrec_pow.comp₂ (Primrec.const 2).to₂ Primrec.snd.to₂))
          (Primrec.const 2).to₂) (Primrec.const 1).to₂)
  refine ⟨fun q=>search ((a.enc q.1).size,q.2),hs.to_comp.comp
    ((a.computableSize.comp Computable.fst).pair Computable.snd),?_⟩
  intro p f
  have he : search ((a.enc p).size,((a.function bool).enc p).code f|>.val)=
      (a.enc p).enumerate.findIdx f := by
    unfold search
    rw [←enumeration_codes (a.enc p),List.findIdx_map]
    congr 1
    funext x
    have hd:=function_digit (a.enc p) Encoding.bool f x
    change decide ((((a.enc p).function Encoding.bool).code f|>.val)/Encoding.bool.size^((a.enc p).code x|>.val)%Encoding.bool.size=1)=f x
    rw [hd,bool_code]
    cases f x <;> rfl
  dsimp only
  rw [he,List.find?_eq_getElem?_findIdx]
  by_cases h:(a.enc p).enumerate.findIdx f < (a.enc p).size
  · rw [show (a.enc p).enumerate=((List.ofFn (a.enc p).code.symm)) from rfl]
    dsimp only [Encoding.enumerate] at h
    rw [List.getElem?_ofFn,dite_eq_left h]
    simp only [option_code_some,Equiv.apply_symm_apply]
  · have hn : (a.enc p).enumerate.findIdx f=(a.enc p).size :=
      le_antisymm (by simpa using List.findIdx_le_length (p:=f) (xs:=(a.enc p).enumerate)) (by omega)
    rw [hn,List.getElem?_eq_none (by simp),option_code_none]

lemma map_find_apply {g : UEncoding P Γ} {a : UEncoding P A}
    {f : ∀p,Γ p → A p → Bool} (hf : g.Map (a.function bool) f) :
    g.Map a.option (fun p x=>(a.enc p).enumerate.find? (f p x)) := map_comp hf (map_find a)

lemma map_option_elim {g : UEncoding P Γ} {a : UEncoding P A} {b : UEncoding P B}
    {f : ∀p,Γ p → B p} {h : ∀p,Γ p × A p → B p}
    (hf : g.Map b f) (hh : (g.prod a).Map b h) :
    (g.prod a.option).Map b (fun p x=>x.2.elim (f p x.1) (fun y=>h p (x.1,y))) := by
  have hc:=map_case hh (hf.first (c:=fixed Encoding.unit))
  have ht : (g.prod a.option).Map (g.prod (a.sum (fixed Encoding.unit)))
      (fun p x=>(x.1,optionEquiv (A p) x.2)) :=
    map_pair (map_fst g a.option)
      (map_comp (map_snd g a.option) (map_to (a.sum (fixed Encoding.unit)) (fun p=>optionEquiv (A p))))
  obtain ⟨raw, hraw, hraw_spec⟩ := map_comp ht hc
  refine ⟨raw, hraw, ?_⟩
  rintro parameter ⟨context, value⟩
  cases value <;> exact hraw_spec parameter _

end UEncoding
end MinUncut.Preprocess

end

end OAI