import OAI.Computability.DegreeRigidity.Syntax.SigmaHull
import OAI.Computability.DegreeRigidity.SetModels.CollapseCoding
import Mathlib.Data.List.Basic

namespace OAI


namespace TuringRigidity.BoundedSetTheory
open TransitiveNameModel RelationCollapse
universe u
namespace FiniteTuple

noncomputable def indexSpace (t : ZFSet.{u}) : ZFSet.{u} :=
  ZFSet.prod {natSet 0} t ∪ ZFSet.prod {natSet 1} ZFSet.omega

noncomputable def finiteIndex (t : ZFSet.{u}) (xs : List ZFSet.{u}) (x : ZFSet.{u}) : ZFSet.{u} := by
  classical
  exact if x ∈ t then ZFSet.pair (natSet 0) x else ZFSet.pair (natSet 1) (natSet (xs.idxOf x))

theorem indexSpace_mem (M : ZFSet.{u}) (hM : Transitive M)
    (hP : Pairing M) (hU : BoundedSetTheory.Union M) (hPow : PowerSet M) (hS : Separation M)
    (hω : ZFSet.omega.{u} ∈ M) {t : ZFSet.{u}} (ht : t ∈ M) : indexSpace t ∈ M := by
  have hn (n : ℕ) : natSet.{u} n ∈ M := hM _ hω _ ((mem_omega _).mpr ⟨n,rfl⟩)
  exact binary_union_mem M hM hP hU
    (product_mem M hM hP hU hPow hS (singleton_mem M hM hP (hn 0)) ht)
    (product_mem M hM hP hU hPow hS (singleton_mem M hM hP (hn 1)) hω)

theorem finiteIndex_mem (t : ZFSet.{u}) (xs : List ZFSet.{u}) (x : ZFSet.{u}) :
    finiteIndex t xs x ∈ indexSpace t := by
  classical
  unfold finiteIndex
  by_cases hx : x ∈ t
  · rw [ite_eq_left hx]
    exact ZFSet.mem_union.mpr (Or.inl (ZFSet.mem_prod.mpr
      ⟨_,ZFSet.mem_singleton.mpr rfl,x,hx,rfl⟩))
  · rw [ite_eq_right hx]
    exact ZFSet.mem_union.mpr (Or.inr (ZFSet.mem_prod.mpr
      ⟨_,ZFSet.mem_singleton.mpr rfl,_,(mem_omega _).mpr ⟨xs.idxOf x,rfl⟩,rfl⟩))

theorem finiteIndex_injective (t : ZFSet.{u}) (xs : List ZFSet.{u})
    (x : ZFSet.{u}) (hx : x ∈ t ∪ elements xs) (y : ZFSet.{u}) (_hy : y ∈ t ∪ elements xs)
    (he : finiteIndex t xs x = finiteIndex t xs y) : x = y := by
  classical
  unfold finiteIndex at he
  by_cases hxt : x ∈ t <;> by_cases hyt : y ∈ t
  · rw [ite_eq_left hxt,ite_eq_left hyt] at he
    exact (ZFSet.pair_inj.mp he).2
  · rw [ite_eq_left hxt,ite_eq_right hyt] at he
    have hf := natSet_injective (ZFSet.pair_inj.mp he).1
    omega
  · rw [ite_eq_right hxt,ite_eq_left hyt] at he
    have hf := natSet_injective (ZFSet.pair_inj.mp he).1
    omega
  · rw [ite_eq_right hxt,ite_eq_right hyt] at he
    have hidx := natSet_injective (ZFSet.pair_inj.mp he).2
    have hxl : x ∈ xs := (mem_elements x xs).mp ((ZFSet.mem_union.mp hx).resolve_left hxt)
    exact (List.idxOf_inj hxl).mp hidx

theorem internal_finite_extension_injection (M : ZFSet.{u}) (hM : Transitive M)
    (hP : Pairing M) (hU : BoundedSetTheory.Union M) (hPow : PowerSet M)
    (hS : Separation M) (hR : SigmaReplacement M) (hω : ZFSet.omega.{u} ∈ M)
    {t : ZFSet.{u}} (ht : t ∈ M) (xs : List ZFSet.{u}) (hxs : ∀ x ∈ xs, x ∈ M) :
    ∃ f ∈ M, Presents (t ∪ elements xs) f (finiteIndex t xs) := by
  classical
  have hn (n : ℕ) : natSet.{u} n ∈ M := hM _ hω _ ((mem_omega _).mpr ⟨n,rfl⟩)
  have hk := indexSpace_mem M hM hP hU hPow hS hω ht
  let j := finiteIndex t xs
  have hj (x : ZFSet.{u}) : j x ∈ M := hM _ hk _ (finiteIndex_mem t xs x)
  let φ : Formula := .existsMem 2 (.conj (.orderedPair 1 2 0) (.orderedPair 0 4 2))
  let e := cons (indexSpace t) (fun _ => natSet 0)
  have he : ∀ i, e i ∈ M := by intro i; cases i with
    | zero => exact hk
    | succ => exact hn 0
  obtain ⟨b,hb,hbdef⟩ := replacement_image M hM hR (.bounded φ) e he ht
    (fun x => ZFSet.pair x (ZFSet.pair (natSet 0) x))
    (fun x hx => orderedPair_mem M hM hP (hM t ht x hx)
      (orderedPair_mem M hM hP (hn 0) (hM t ht x hx))) (by
      intro x hx y hy
      change φ.Realize M (cons y (cons x e)) ↔ _
      rw [Formula.absolute _ M hM _ (by
        intro i; rcases i with _|i; exact hy
        rcases i with _|i; exact hM t ht x hx
        exact he i)]
      simp only [φ,Formula.Eval,Formula.eval_orderedPair,cons_zero,cons_succ,e]
      constructor
      · rintro ⟨v,_,hy,rfl⟩; exact hy
      · intro hy
        have hjx := finiteIndex_mem t xs x
        rw [finiteIndex,ite_eq_left hx] at hjx
        exact ⟨_,hjx,hy,rfl⟩)
  let f := b ∪ elements (xs.map (fun x => ZFSet.pair x (j x)))
  have hf : f ∈ M := binary_union_mem M hM hP hU hb
    (elements_mem M hM hP hU (hn 0) _ (by
      intro z hz
      obtain ⟨x,hx,rfl⟩ := List.mem_map.mp hz
      exact orderedPair_mem M hM hP (hxs x hx) (hj x)))
  refine ⟨f,hf,?_⟩
  intro z
  change z ∈ b ∪ elements (xs.map (fun x => ZFSet.pair x (j x))) ↔ _
  rw [ZFSet.mem_union,hbdef,mem_elements,List.mem_map]
  constructor
  · rintro (⟨x,hx,rfl⟩|⟨x,hx,rfl⟩)
    · refine ⟨x,ZFSet.mem_union.mpr (Or.inl hx),?_⟩
      simp only [finiteIndex,ite_eq_left hx]
    · exact ⟨x,ZFSet.mem_union.mpr (Or.inr ((mem_elements x xs).mpr hx)),rfl⟩
  · rintro ⟨x,hx,rfl⟩
    rcases ZFSet.mem_union.mp hx with hx|hx
    · apply Or.inl
      exact ⟨x,hx,by simp only [finiteIndex,ite_eq_left hx]⟩
    · exact Or.inr ⟨x,(mem_elements x xs).mp hx,rfl⟩

end FiniteTuple
end TuringRigidity.BoundedSetTheory

end OAI