/**
 * Tool Utilities
 *
 * Provides normalization and conversion utilities for tool types.
 * Handles various input formats (aliases, case variations) and converts
 * them to the canonical ToolType used throughout the platform.
 */

import { ToolType, toolLabels } from '../types/tool.types'

/**
 * Map of common tool name variants to canonical ToolType
 */
const toolAliasMap: Record<string, ToolType> = {
  // Fleet MDM
  'FLEET': 'FLEET_MDM',
  'FLEET_MDM': 'FLEET_MDM',
  'FLEET-MDM': 'FLEET_MDM',
  'FLEETMDM': 'FLEET_MDM',
  'fleet': 'FLEET_MDM',
  'fleet_mdm': 'FLEET_MDM',
  'fleet-mdm': 'FLEET_MDM',
  'fleetmdm': 'FLEET_MDM',
  'fleetmdm-agent': 'FLEET_MDM',

  // MeshCentral
  'MESHCENTRAL': 'MESHCENTRAL',
  'MESH': 'MESHCENTRAL',
  'MESH_CENTRAL': 'MESHCENTRAL',
  'MESH-CENTRAL': 'MESHCENTRAL',
  'mesh': 'MESHCENTRAL',
  'meshcentral': 'MESHCENTRAL',
  'mesh_central': 'MESHCENTRAL',
  'mesh-central': 'MESHCENTRAL',
  'meshcentral-agent': 'MESHCENTRAL',

  // Authentik
  'AUTHENTIK': 'AUTHENTIK',
  'authentik': 'AUTHENTIK',

  // OpenFrame
  'OPENFRAME': 'OPENFRAME',
  'openframe': 'OPENFRAME',
  'OPEN_FRAME': 'OPENFRAME',
  'OPEN-FRAME': 'OPENFRAME',
  'open_frame': 'OPENFRAME',
  'open-frame': 'OPENFRAME',

  // OpenFrame Chat
  'OPENFRAME_CHAT': 'OPENFRAME_CHAT',
  'OPENFRAME-CHAT': 'OPENFRAME_CHAT',
  'OPENFRAMECHAT': 'OPENFRAME_CHAT',
  'openframe_chat': 'OPENFRAME_CHAT',
  'openframe-chat': 'OPENFRAME_CHAT',
  'openframechat': 'OPENFRAME_CHAT',

  // OpenFrame Client
  'OPENFRAME_CLIENT': 'OPENFRAME_CLIENT',
  'OPENFRAME-CLIENT': 'OPENFRAME_CLIENT',
  'OPENFRAMECLIENT': 'OPENFRAME_CLIENT',
  'openframe_client': 'OPENFRAME_CLIENT',
  'openframe-client': 'OPENFRAME_CLIENT',
  'openframeclient': 'OPENFRAME_CLIENT',

  // OpenFrame RMM
  'RMM': 'OPENFRAME_RMM',
  'rmm': 'OPENFRAME_RMM',
  'OPENFRAME_RMM': 'OPENFRAME_RMM',
  'OPENFRAME-RMM': 'OPENFRAME_RMM',
  'OPENFRAMERMM': 'OPENFRAME_RMM',
  'openframe_rmm': 'OPENFRAME_RMM',
  'openframe-rmm': 'OPENFRAME_RMM',
  'openframermm': 'OPENFRAME_RMM',
  'openframe-rmm-agent': 'OPENFRAME_RMM',

  // OSQUERY
  'OSQUERY': 'OSQUERY',

  // System
  'SYSTEM': 'SYSTEM',
  'system': 'SYSTEM',
}

/**
 * Normalizes a tool name string to the canonical ToolType.
 * Handles various formats like 'rmm', 'OPENFRAME_RMM', 'openframe-rmm', etc.
 *
 * @param input - The tool name string to normalize
 * @returns The canonical ToolType, or undefined if no match found
 *
 * @example
 * normalizeToolType('rmm') // => 'OPENFRAME_RMM'
 * normalizeToolType('FLEET-MDM') // => 'FLEET_MDM'
 * normalizeToolType('unknown') // => undefined
 */
export function normalizeToolType(input?: string): ToolType | undefined {
  if (!input) return undefined

  // Try exact match first
  const exact = toolAliasMap[input]
  if (exact) return exact

  // Try uppercase
  const upper = input.toUpperCase()
  if (toolAliasMap[upper]) return toolAliasMap[upper]

  // Try lowercase
  const lower = input.toLowerCase()
  if (toolAliasMap[lower]) return toolAliasMap[lower]

  return undefined
}

/**
 * Normalizes a tool name string to the canonical ToolType with a fallback.
 * Returns 'SYSTEM' as the default if no match is found.
 *
 * @param input - The tool name string to normalize
 * @returns The canonical ToolType, defaults to 'SYSTEM' if no match
 *
 * @example
 * normalizeToolTypeWithFallback('rmm') // => 'OPENFRAME_RMM'
 * normalizeToolTypeWithFallback('unknown') // => 'SYSTEM'
 */
export function normalizeToolTypeWithFallback(input?: string): ToolType {
  return normalizeToolType(input) ?? 'SYSTEM'
}

/**
 * Converts any tool name variant to its display label.
 * Handles normalization internally.
 *
 * @param input - The tool name string (any format)
 * @returns The display label, or the original input if no match
 *
 * @example
 * toToolLabel('rmm') // => 'RMM'
 * toToolLabel('FLEET-MDM') // => 'Fleet'
 * toToolLabel('unknown') // => 'unknown'
 */
export function toToolLabel(input?: string): string {
  if (!input) return ''

  const toolType = normalizeToolType(input)
  if (toolType) {
    return toolLabels[toolType]
  }

  return input
}

/**
 * Checks if a string is a valid tool type (or can be normalized to one).
 *
 * @param input - The string to check
 * @returns True if the input can be normalized to a valid ToolType
 *
 * @example
 * isValidToolType('rmm') // => true
 * isValidToolType('FLEET_MDM') // => true
 * isValidToolType('unknown') // => false
 */
export function isValidToolType(input?: string): boolean {
  return normalizeToolType(input) !== undefined
}

/**
 * Gets all valid tool type aliases for a given canonical ToolType.
 * Useful for documentation or validation purposes.
 *
 * @param toolType - The canonical ToolType
 * @returns Array of all aliases that map to this tool type
 */
export function getToolTypeAliases(toolType: ToolType): string[] {
  return Object.entries(toolAliasMap)
    .filter(([_, value]) => value === toolType)
    .map(([key]) => key)
}

/**
 * Get display label for a tool type
 */
export function getToolLabel(toolType: ToolType): string {
  return toolLabels[toolType] || toolType
}