import type { ToolConfig } from './index'
import { getTorchClients, getTorchStatus, transferTorch, requestTorch, releaseTorch } from '../../torch'

export function createTorchHandlers(): ToolConfig[] {
  return [
    {
      name: 'list_torch_clients',
      description: 'Lista todos los browsers/clientes conectados al sistema de antorcha con sus metadatos',
      category: 'global',
      schema: {
        type: 'object',
        properties: {}
      },
      handler: () => {
        const clients = getTorchClients()
        const status = getTorchStatus()

        if (clients.length === 0) {
          return 'No hay clientes conectados al sistema de antorcha'
        }

        let result = `Clientes conectados (${clients.length}):\n\n`

        for (const client of clients) {
          const isMe = client.id === status.clientId
          const hasTorch = client.hasTorch

          result += `${hasTorch ? '🔥' : '⚪'} ${client.name || 'Anonymous'} (${client.id})${isMe ? ' (este browser)' : ''}\n`
          result += `   Hostname: ${client.hostname}\n`
          result += `   User Agent: ${client.userAgent.substring(0, 80)}...\n`
          result += `   Conectado: ${client.connectedAt}\n\n`
        }

        return result
      }
    },
    {
      name: 'get_torch_status',
      description: 'Obtiene el estado actual del sistema de antorcha (quien tiene el control del MCP)',
      category: 'global',
      schema: {
        type: 'object',
        properties: {}
      },
      handler: () => {
        const status = getTorchStatus()
        const clients = getTorchClients()

        const myClient = clients.find(c => c.id === status.clientId)
        let result = '=== Estado de la Antorcha ===\n\n'
        result += `Mi ID: ${status.clientId || 'No registrado'}\n`
        result += `Mi nombre: ${myClient?.name || 'Anonymous'}\n`
        result += `Tengo la antorcha: ${status.hasTorch ? 'Si' : 'No'}\n`
        result += `Holder actual: ${status.torchHolderId || 'Nadie'}\n`
        result += `Clientes conectados: ${status.clientCount}\n\n`

        if (status.torchHolderId) {
          const holder = clients.find(c => c.id === status.torchHolderId)
          if (holder) {
            result += `Detalles del holder:\n`
            result += `  Nombre: ${holder.name || 'Anonymous'}\n`
            result += `  Hostname: ${holder.hostname}\n`
            result += `  Conectado desde: ${holder.connectedAt}\n`
          }
        }

        return result
      }
    },
    {
      name: 'transfer_torch',
      description: 'Transfiere la antorcha (control del MCP) a otro cliente especifico',
      category: 'global',
      schema: {
        type: 'object',
        properties: {
          target_id: {
            type: 'string',
            description: 'ID del cliente al que transferir la antorcha (usar list_torch_clients para ver IDs)'
          }
        },
        required: ['target_id']
      },
      handler: async (args: { target_id: string }) => {
        const status = getTorchStatus()

        if (!status.hasTorch && status.torchHolderId !== null) {
          return 'Error: No tienes la antorcha. Solo el holder actual puede transferirla.'
        }

        const clients = getTorchClients()
        const targetExists = clients.some(c => c.id === args.target_id)

        if (!targetExists) {
          return `Error: Cliente "${args.target_id}" no encontrado.\n\nClientes disponibles:\n${clients.map(c => `  - ${c.name || 'Anonymous'} (${c.id})`).join('\n')}`
        }

        if (args.target_id === status.clientId) {
          return 'Error: No puedes transferir la antorcha a ti mismo'
        }

        const targetClient = clients.find(c => c.id === args.target_id)
        const success = await transferTorch(args.target_id)
        if (success) {
          return `Antorcha transferida a ${targetClient?.name || args.target_id}. El otro browser ahora tiene control del MCP.`
        } else {
          return 'Error al transferir la antorcha'
        }
      }
    },
    {
      name: 'request_torch',
      description: 'Solicita la antorcha (control del MCP) para este browser',
      category: 'global',
      schema: {
        type: 'object',
        properties: {}
      },
      handler: async () => {
        const status = getTorchStatus()

        if (status.hasTorch) {
          return 'Ya tienes la antorcha'
        }

        const success = await requestTorch()
        if (success) {
          return 'Antorcha solicitada. Conectando al MCP...'
        } else {
          return 'Error al solicitar la antorcha'
        }
      }
    },
    {
      name: 'release_torch',
      description: 'Libera la antorcha (desconecta del MCP y permite que otro browser la tome)',
      category: 'global',
      schema: {
        type: 'object',
        properties: {}
      },
      handler: async () => {
        const status = getTorchStatus()

        if (!status.hasTorch) {
          return 'No tienes la antorcha para liberar'
        }

        const success = await releaseTorch()
        if (success) {
          return 'Antorcha liberada. Desconectando del MCP...'
        } else {
          return 'Error al liberar la antorcha'
        }
      }
    }
  ]
}
