export const agentCallableConversationRpcMethods = [
  conversationList,
  agentConversationCreate,
] as const

export const agentConversationCreate = defineRpc({
  name: "agent/conversation/create",
  params: Schema.Struct({
    name: Schema.optional(conversationNameSchema),
    participants: Schema.Array(agentId).pipe(
      Schema.minItems(1),
      Schema.maxItems(MAX_CREATE_PARTICIPANTS),
    ),
  }),
  result: Schema.Struct({ conversation: conversationSchemaValue }),
  requires: [AuthenticatedAgent, ActiveAgent],
  errors: [AgentNotFoundError, ConversationFullError],
})

export type Conversation = Schema.Schema.Type<typeof conversationSchemaValue>;

export type ConversationCreatedNotification = Schema.Schema.Type<
  typeof conversationCreatedNotificationSchema
>;

export const conversationCreatedNotificationDefinition = defineNotification({
  name: "agent/conversation/created",
  params: conversationCreatedNotificationSchema,
})

export class ConversationFullError extends Schema.TaggedError<ConversationFullError>()(
  "ConversationFull",
  errorPayloadFields,
) {
  static readonly message = "Conversation is full";
}

export const conversationId: Schema.Schema<ConversationId, string> =
  formatString("uuid").pipe(
    Schema.brand("ConversationId"),
    Schema.annotations({ description: "Branded ConversationId" }),
  )

export type ConversationId = string & Brand.Brand<"ConversationId">;

export const conversationList = defineRpc({
  name: "agent/conversation/list",
  params: Schema.Struct({
    limit: listLimitSchema,
    cursor: Schema.optional(Schema.String),
  }),
  result: Schema.Struct({
    items: Schema.Array(conversationListItemSchema),
    nextCursor: Schema.optional(Schema.String),
  }),
  requires: [AuthenticatedAgent, ActiveAgent],
  errors: [InvalidParamsError, ConversationNotFoundError],
})

export type ConversationListItem = Schema.Schema.Type<
  typeof conversationListItemSchema
>;

export const conversationNameSchema = Schema.String.pipe(
  Schema.minLength(1),
  Schema.maxLength(100),
)

export class ConversationNotFoundError extends Schema.TaggedError<ConversationNotFoundError>()(
  "ConversationNotFound",
  errorPayloadFields,
) {
  static readonly message = "Conversation not found";
}

export const conversationNotifications = [
  conversationCreatedNotificationDefinition,
] as const

export function conversationSchema(): typeof conversationSchemaValue

export const messageId: Schema.Schema<MessageId, string> = formatString(
  "uuid",
).pipe(
  Schema.brand("MessageId"),
  Schema.annotations({ description: "Branded MessageId" }),
)

export type MessageId = string & Brand.Brand<"MessageId">;

export class NotAParticipantError extends Schema.TaggedError<NotAParticipantError>()(
  "NotAParticipant",
  errorPayloadFields,
) {
  static readonly message = "Not a participant in the conversation";
}