import type { InventoryAction, InventoryWindowState, PlayerState, TradeOffer } from '../types'

export interface InventoryConnector {
  getWindowState(): InventoryWindowState | null
  getPlayerState(): PlayerState | null
  sendAction(action: InventoryAction): void | Promise<void>
  closeWindow(): void | Promise<void>
  subscribe(listener: ConnectorListener): () => void
  /**
   * Open the player inventory, taking into account the entity the player is riding.
   * For horse/llama/donkey/etc this activates the entity so the server sends a windowOpen.
   * For unmounted players it emits a playerUpdate with the current inventory.
   */
  openPlayerInventory(): void | Promise<void>
}

export type ConnectorEvent =
  | { type: 'windowOpen'; state: InventoryWindowState }
  | { type: 'windowClose' }
  | { type: 'windowUpdate'; state: InventoryWindowState }
  | { type: 'playerUpdate'; state: PlayerState }
  | { type: 'heldItemChange'; item: InventoryWindowState['heldItem'] }

export type ConnectorListener = (event: ConnectorEvent) => void

export interface MineflayerBotWindow {
  id: number
  type: string
  title?: string
  slots: Array<{ type: number; count: number; metadata?: number; nbt?: unknown } | null>
  selectedItem?: { type: number; count: number; metadata?: number; nbt?: unknown } | null
}

/** Villager window from bot.openVillager() — has trade() */
export interface MineflayerVillagerWindow extends MineflayerBotWindow {
  trade: (index: number, count?: number) => Promise<void>
  trades: unknown[] | null
}

/** Enchantment table from bot.openEnchantmentTable() — has enchant() */
export interface MineflayerEnchantmentTableWindow extends MineflayerBotWindow {
  enchant: (choice: number) => Promise<void>
}

/** Anvil from bot.openAnvil() — has rename() and combine() */
export interface MineflayerAnvilWindow extends MineflayerBotWindow {
  rename: (item: { type: number; metadata?: number; count: number; nbt?: unknown }, name: string) => Promise<void>
  combine: (itemOne: unknown, itemTwo: unknown, name?: string) => Promise<void>
  findInventoryItem: (itemId: number) => unknown | null
}

/** Beacon — mineflayer has no dedicated plugin; uses packets. */
export interface MineflayerBeaconWindow extends MineflayerBotWindow {}

export interface MineflayerBot {
  inventory: {
    slots: Array<{ type: number; count: number; metadata?: number; nbt?: unknown } | null>
  }
  currentWindow: MineflayerBotWindow | null
  heldItem: { type: number; count: number; metadata?: number; nbt?: unknown } | null
  experience: { level: number; progress: number; points: number }
  quickBarSlot: number
  /** Entity currently being ridden, if any. Name is the mineflayer entity type string. */
  vehicle?: { name?: string; entityType?: string; id?: number; [key: string]: unknown } | null
  clickWindow(slot: number, mouseButton: number, mode: number): Promise<void>
  closeWindow(window: unknown): void
  on(event: string, listener: (...args: unknown[]) => void): void
  off(event: string, listener: (...args: unknown[]) => void): void
  removeListener(event: string, listener: (...args: unknown[]) => void): void
  /** For beacon/special packets; optional. */
  _client?: { write: (name: string, data: unknown) => void }
}