// -- Newtype IDs -------------------------------------------------------------

///|
pub(all) struct CodexThreadId(String) derive(Debug, Eq)

///|
pub(all) struct CodexTurnId(String) derive(Debug, Eq)

///|
pub(all) struct CodexItemId(String) derive(Debug, Eq)

///|
pub(all) struct CodexRequestId(Json)

// -- Status enums ------------------------------------------------------------

///|
pub(all) enum CodexThreadStatus {
  Open
  Archived
  Closed
} derive(Debug, Eq)

///|
pub(all) enum CodexStatus {
  InProgress
  Completed
  Failed
} derive(Debug, Eq)

///|
pub(all) enum CodexActiveFlag {
  WaitingOnApproval
  WaitingOnUserInput
} derive(Debug, Eq)

///|
pub(all) enum CodexActivityStatus {
  NotLoaded
  Idle
  Active(Array[CodexActiveFlag])
  SystemError
} derive(Debug, Eq)

// -- Shared types ------------------------------------------------------------

///|
pub(all) struct CodexClientInfo {
  name : String
  title : String
  version : String
}

///|
pub(all) enum CodexItemKind {
  AgentMessage
  UserMessage
  CommandExecution
  FileChange
  Reasoning
} derive(Debug, Eq)

///|
pub(all) struct CodexThreadResult {
  id : CodexThreadId
  preview : String
  status : CodexThreadStatus
  activity : CodexActivityStatus
} derive(Debug, Eq)

///|
pub(all) struct CodexReadItem {
  id : CodexItemId
  kind : CodexItemKind
  text : String
  command : String
  output : String
}

///|
pub(all) struct CodexReadTurn {
  id : CodexTurnId
  items : Array[CodexReadItem]
  status : CodexStatus
}

// -- Outgoing (client -> server) ---------------------------------------------

///|
pub(all) enum CodexApprovalDecision {
  Accept
  Decline
}

///|
pub(all) enum CodexOutgoing {
  Initialize(id~ : Int, client_info~ : CodexClientInfo)
  ThreadStart(id~ : Int, cwd~ : String)
  ThreadList(id~ : Int, cwd~ : String)
  ThreadRead(id~ : Int, thread_id~ : CodexThreadId, include_turns~ : Bool)
  ThreadResume(id~ : Int, thread_id~ : CodexThreadId)
  TurnStart(id~ : Int, thread_id~ : CodexThreadId, input~ : String)
  TurnInterrupt(id~ : Int, thread_id~ : CodexThreadId, turn_id~ : CodexTurnId)
  Initialized
  Approval(id~ : CodexRequestId, decision~ : CodexApprovalDecision)
}

// -- Approval requests -------------------------------------------------------

///|
pub(all) enum CodexApproval {
  Command(command~ : String)
  FileChange(reason~ : String)
}

// -- Incoming (server -> client) ---------------------------------------------

///|
pub(all) enum CodexIncoming {
  // Responses
  ThreadResult(thread~ : CodexThreadResult)
  ThreadListResult(threads~ : Array[CodexThreadResult])
  ThreadReadResult(thread~ : CodexThreadResult, turns~ : Array[CodexReadTurn])
  OtherResponse(id~ : Json)
  // Notifications
  TurnStarted(turn_id~ : CodexTurnId)
  TurnCompleted(turn_id~ : CodexTurnId, status~ : CodexStatus)
  ItemStarted(
    turn_id~ : CodexTurnId,
    item_id~ : CodexItemId,
    kind~ : CodexItemKind,
    text~ : String,
    command~ : String
  )
  ItemCompleted(
    turn_id~ : CodexTurnId,
    item_id~ : CodexItemId,
    status~ : CodexStatus
  )
  Delta(
    turn_id~ : CodexTurnId,
    item_id~ : CodexItemId,
    delta~ : String,
    kind~ : CodexItemKind
  )
  ThreadStatusChanged(
    thread_id~ : CodexThreadId,
    activity~ : CodexActivityStatus
  )
  // Server requests (need our response)
  Approval(
    id~ : CodexRequestId,
    thread_id~ : CodexThreadId,
    turn_id~ : CodexTurnId,
    item_id~ : CodexItemId,
    approval~ : CodexApproval
  )
}