Types

interface BotContext {
  event: BotEvent
  provider: string
  bot: {
    id: string
    name: string
    send: (params: Omit<BotSendParams<any>, 'config'>) => Promise<void>
  }
  channel: {
    id: string
    name: string
    isGroup: boolean
  }
  message: {
    content?: BotContent
    attachments?: BotAttachmentContent[]
    author: {
      id: string
      name: string
      username: string
    }
    isMentioned: boolean
  }
}

interface BotCommand {
  name: string
  aliases: string[]
  description: string
  help: string
  handle: (ctx: BotContext, params: any) => Promise<void>
}

type Middleware = (
  ctx: BotContext,
  next: () => Promise<void>
) => Promise<void>

type BotEvent = 'start' | 'message' | 'error'

type BotContent =
  | BotTextContent
  | BotCommandContent
  | BotImageContent
  | BotAudioContent
  | BotDocumentContent

interface BotTextContent {
  type: 'text'
  content: string
  raw: string
}

interface BotCommandContent {
  type: 'command'
  command: string
  params: string[]
  raw: string
}

interface BotImageContent {
  type: 'image'
  content: string
  file: File
  caption?: string
}

interface BotDocumentContent {
  type: 'document'
  content: string
  file: File
}

interface BotAudioContent {
  type: 'audio'
  content: string
  file: File
}

interface BotAttachmentContent {
  type: string
  name: string
  content: string
}

interface IBotAdapter<TConfig extends ZodObject<any>> {
  name: string
  parameters: TConfig
  init: (params: {
    config: TypeOf<TConfig>
    commands: BotCommand[]
    logger?: BotLogger
  }) => Promise<void>
  send: (params: BotSendParams<TConfig> & { logger?: BotLogger }) => Promise<void>
  handle: (params: BotHandleParams<TConfig> & { logger?: BotLogger }) => Promise<Omit<BotContext, 'bot'> | null>
}

type BotSendParams<TConfig extends Record<string, any>> = {
  provider: string
  channel: string
  content: { type: 'text'; content: string }
  config: TConfig
}

type BotHandleParams<TConfig extends Record<string, any>> = {
  request: Request
  config: TConfig
}

interface BotLogger {
  debug?: (...args: any[]) => void
  info?: (...args: any[]) => void
  warn?: (...args: any[]) => void
  error?: (...args: any[]) => void
}

class BotError extends Error {
  constructor(
    public code: BotErrorCode,
    message?: string,
    public meta?: Record<string, unknown>
  )
}

type BotErrorCode =
  | 'PROVIDER_NOT_FOUND'
  | 'COMMAND_NOT_FOUND'
  | 'INVALID_COMMAND_PARAMETERS'
  | 'ADAPTER_HANDLE_RETURNED_NULL'

import type {
  BotContext,
  BotCommand,
  BotContent,
  Middleware,
  BotEvent,
  BotLogger,
  IBotAdapter
} from '@igniter-js/bot/types'

function isTextContent(content: BotContent | undefined): content is BotTextContent {
  return content?.type === 'text'
}

if (isTextContent(ctx.message.content)) {
  // TypeScript knows content is BotTextContent
  console.log(ctx.message.content.content)
}

interface ExtendedContext extends BotContext {
  session?: {
    userId: string
    data: Record<string, any>
  }
}

bot.onPreProcess(async (ctx) => {
  const session = await loadSession(ctx.message.author.id)
  ;(ctx as ExtendedContext).session = session
})