import OAI.SetTheory.PartitionPrinciple.Forcing.FixedTop

namespace OAI

section

namespace PartitionPilot.Compression.RecursiveMaps

open RationalHeights
universe u v

namespace LinearHeightOrder
variable {Column : Type u} {Coord : Type v}

theorem first_weak (C : LinearHeightOrder Column) (D : LinearHeightOrder Coord)
    {x y : Column × Coord} (lower : (C.lex D).Weak x y) : C.Weak x.1 y.1 := by
  rcases lower with eq | lower | ⟨eq, _⟩
  · exact Or.inl (congrArg Prod.fst eq)
  · exact Or.inr lower
  · exact Or.inl eq

end LinearHeightOrder

structure ColumnRoom {Column : Type v} (C : LinearHeightOrder Column) (old : Column) where
  column : Nat → Column
  increasing : ∀ n, C.lt (column n) (column (n + 1))
  starts_above : C.lt old (column 0)
  cap : Column
  below_cap : ∀ n, C.lt (column n) cap

namespace FixedTop
variable {A : Type u} {H : Type v} {P : MeetOrder A} {R : HeightOrder H}
    (height : StrictHeight P R) (topValue : H)
    (above : ∀ x, R.lt (height.value x) topValue)

def heightValue : Option A → H
  | none => topValue
  | some x => height.value x

def extendHeight : StrictHeight (order P) R where
  value := heightValue height topValue
  strict x y lower different := by
    cases x with
    | none =>
      cases y with
      | none => exact False.elim (different rfl)
      | some y => exact False.elim lower
    | some x =>
      cases y with
      | none => exact above x
      | some y => exact height.strict x y lower (fun eq => different (congrArg some eq))

theorem extendHeight_countable (countable : CountableRange height.value) :
    CountableRange (extendHeight height topValue above).value := by
  rcases countable with ⟨oldCode, equal⟩
  let code : Option A → Nat
    | none => 0
    | some x => oldCode x + 1
  refine ⟨code, ?_⟩
  intro x y eq
  cases x with
  | none =>
    cases y with
    | none => rfl
    | some y => change 0 = oldCode y + 1 at eq; omega
  | some x =>
    cases y with
    | none => change oldCode x + 1 = 0 at eq; omega
    | some y => exact equal x y (by change oldCode x + 1 = oldCode y + 1 at eq; omega)

end FixedTop

namespace TileRequests.Family

open CosetGeometry
variable {A J R : Type u} [Group J] {P : MeetOrder A}
    {Column : Type v} (f : Family P R) (a : OrderAction J P)
    (C : LinearHeightOrder Column) (seed : StrictHeight P (lexOrder C).toHeightOrder)
    (countable : CountableRange seed.value)
    (room : ColumnRoom C (seed.value f.top).1)

noncomputable def localHeight : (v : TileStars.Vertex J f.Letters R) →
    StrictHeight (f.localOrder v) Rational.order.toHeightOrder
  | .inl _ => Classical.choose (rational_assignment (lexOrder C) seed f.top countable)
  | .inr c => (f.request c.2).rationalHeight f.top f.greatest (lexOrder C) seed countable

theorem seed_column_bound (x : A) : C.lt (seed.value x).1 (room.column 0) :=
  C.weak_lt (C.first_weak Rational.order.toLinearHeightOrder (seed.mono (f.greatest x)))
    room.starts_above

noncomputable def gluedHeight : StrictHeight (f.gluedOrder a) (lexOrder C).toHeightOrder :=
  (f.diagram a).scheme.externalHeight C room.column room.increasing seed
    (f.seed_column_bound C seed room) (f.localHeight C seed countable)

theorem gluedHeight_original (x : A) :
    (f.gluedHeight a C seed countable room).value ((f.copy a 1).toFun x) = seed.value x := by
  rw [f.copy_one]
  exact (f.diagram a).scheme.externalHeight_original C room.column room.increasing seed
    (f.seed_column_bound C seed room) (f.localHeight C seed countable) x

theorem gluedHeight_countable : CountableRange (f.gluedHeight a C seed countable room).value :=
  (f.diagram a).scheme.externalHeight_countable C room.column room.increasing seed
    (f.seed_column_bound C seed room) (f.localHeight C seed countable) countable

theorem gluedHeight_column_bound (x : f.Node a) :
    C.lt ((f.gluedHeight a C seed countable room).value x).1 room.cap :=
  (f.diagram a).scheme.externalHeight_column_bound C room.column room.increasing seed
    (f.seed_column_bound C seed room) (f.localHeight C seed countable) room.cap room.below_cap x

noncomputable def extensionHeight : StrictHeight (f.extensionOrder a) (lexOrder C).toHeightOrder :=
  FixedTop.extendHeight (f.gluedHeight a C seed countable room) (room.cap, zero)
    (fun x => Or.inl (f.gluedHeight_column_bound a C seed countable room x))

theorem extensionHeight_original (x : A) :
    (f.extensionHeight a C seed countable room).value ((f.extensionCopy a 1).toFun x) =
      seed.value x := f.gluedHeight_original a C seed countable room x

theorem extensionHeight_countable :
    CountableRange (f.extensionHeight a C seed countable room).value :=
  FixedTop.extendHeight_countable _ _ _ (f.gluedHeight_countable a C seed countable room)

theorem extensionHeight_top :
    (f.extensionHeight a C seed countable room).value none = (room.cap, zero) := rfl

theorem extensionHeight_bounded (x : f.Extension a) :
    (lexOrder C).Weak ((f.extensionHeight a C seed countable room).value x) (room.cap, zero) :=
  (f.extensionHeight a C seed countable room).mono (f.extension_greatest a x)

include countable in

theorem external_height_extension :
    ∃ height : StrictHeight (f.extensionOrder a) (lexOrder C).toHeightOrder,
      (∀ x, height.value ((f.extensionCopy a 1).toFun x) = seed.value x) ∧
      CountableRange height.value ∧ height.value none = (room.cap, zero) ∧
      (∀ x, (lexOrder C).Weak (height.value x) (room.cap, zero)) :=
  ⟨f.extensionHeight a C seed countable room,
    f.extensionHeight_original a C seed countable room,
    f.extensionHeight_countable a C seed countable room,
    f.extensionHeight_top a C seed countable room,
    f.extensionHeight_bounded a C seed countable room⟩

end TileRequests.Family

end PartitionPilot.Compression.RecursiveMaps

end

end OAI