/**
 * S-001: MCP Tool Types — 36 Tool definitions for Yuzu-GCA
 * 
 * Each Tool follows the @modelcontextprotocol/sdk shape:
 *   { name, description, inputSchema }
 * 
 * Organized by module per docs/backlog:
 *   Module 1: Device Management   (5 tools)
 *   Module 2: Command Execution   (4 tools)  
 *   Module 3: File Operations     (6 tools)
 *   Module 4: System Control      (4 tools)
 *   Module 5: Remote Desktop      (4 tools)
 *   Module 6: AI Manipulation     (4 tools)
 *   Module 7: Network             (3 tools)
 *   Module 8: Hardware            (3 tools)
 *   Module 9: Developer Tools     (2 tools)
 *   Module 10: Media              (1 tool)
 */

import type { z } from "zod";

// ── JSON Schema primitive aliases ──────────────────────────
const str = (desc: string) => ({ type: "string" as const, description: desc });
const num = (desc: string) => ({ type: "number" as const, description: desc });
const bool = (desc: string) => ({ type: "boolean" as const, description: desc });
const arr = (items: any, desc: string) => ({ type: "array" as const, items, description: desc });
const obj = (props: Record<string,any>, required: string[], desc: string) => ({
  type: "object" as const, properties: props, required, description: desc,
});

// ── Tool definition type ───────────────────────────────────
export interface ToolDef {
  name: string;
  description: string;
  inputSchema: {
    type: "object";
    properties: Record<string, any>;
    required?: string[];
  };
}

export interface ToolCategory {
  module: number;
  name: string;
  tools: ToolDef[];
}

// ── Module 1: Device Management (5 tools) ──────────────────
export const DEVICE_TOOLS: ToolDef[] = [
  {
    name: "device_info",
    description: "Get device hardware/OS information (CPU, RAM, hostname, platform, arch)",
    inputSchema: obj({}, [], "No input required"),
  },
  {
    name: "device_list",
    description: "List all connected devices known to the Gateway",
    inputSchema: obj({}, [], "No input required"),
  },
  {
    name: "device_status",
    description: "Get current connection status and health of a specific device",
    inputSchema: obj({ deviceId: str("Target device ID (default: self)") }, [], ""),
  },
  {
    name: "device_register",
    description: "Register this device with the Gateway with capabilities and metadata",
    inputSchema: obj({
      name: str("Human-readable device name"),
      capabilities: arr(str("capability"), "List of capability strings"),
    }, ["name"], ""),
  },
  {
    name: "device_unregister",
    description: "Unregister from Gateway (graceful disconnect)",
    inputSchema: obj({}, [], "No input required"),
  },
];

// ── Module 2: Command Execution (4 tools) ──────────────────
export const EXEC_TOOLS: ToolDef[] = [
  {
    name: "exec",
    description: "Execute a shell command and return stdout/stderr. 30s timeout.",
    inputSchema: obj({
      command: str("Shell command to execute"),
      cwd: str("Working directory (optional)"),
      timeout: num("Timeout in ms (default 30000)"),
    }, ["command"], ""),
  },
  {
    name: "exec_background",
    description: "Start a long-running command and return a process ID for later control",
    inputSchema: obj({
      command: str("Shell command to execute"),
      cwd: str("Working directory (optional)"),
    }, ["command"], ""),
  },
  {
    name: "process_list",
    description: "List running processes with PID, name, CPU%, memory",
    inputSchema: obj({
      filter: str("Optional name filter (substring match)"),
    }, [], ""),
  },
  {
    name: "process_kill",
    description: "Kill a process by PID",
    inputSchema: obj({
      pid: num("Process ID to kill"),
      signal: str("Signal (default: SIGTERM)"),
    }, ["pid"], ""),
  },
];

// ── Module 3: File Operations (6 tools) ────────────────────
export const FILE_TOOLS: ToolDef[] = [
  {
    name: "file_list",
    description: "List files and directories at a given path",
    inputSchema: obj({
      path: str("Directory path to list"),
      recursive: bool("Recursive listing (default false)"),
    }, ["path"], ""),
  },
  {
    name: "file_read",
    description: "Read contents of a file (text or binary as base64)",
    inputSchema: obj({
      path: str("File path to read"),
      encoding: str("utf8 | base64 (default utf8)"),
      offset: num("Line offset (0-based, optional)"),
      limit: num("Max lines to return (optional)"),
    }, ["path"], ""),
  },
  {
    name: "file_write",
    description: "Write content to a file (create or overwrite)",
    inputSchema: obj({
      path: str("File path to write"),
      content: str("Content to write (text or base64)"),
      encoding: str("utf8 | base64 (default utf8)"),
    }, ["path", "content"], ""),
  },
  {
    name: "file_move",
    description: "Move or rename a file/directory",
    inputSchema: obj({
      from: str("Source path"),
      to: str("Destination path"),
    }, ["from", "to"], ""),
  },
  {
    name: "file_delete",
    description: "Delete a file or directory (recursive for dirs)",
    inputSchema: obj({
      path: str("Path to delete"),
      recursive: bool("Recursive delete for directories (default false)"),
    }, ["path"], ""),
  },
  {
    name: "file_stat",
    description: "Get file metadata (size, permissions, mtime)",
    inputSchema: obj({
      path: str("Path to stat"),
    }, ["path"], ""),
  },
];

// ── Module 4: System Control (4 tools) ─────────────────────
export const SYSTEM_TOOLS: ToolDef[] = [
  {
    name: "sysinfo",
    description: "Get system resource usage (CPU%, RAM, disk, uptime, network IO)",
    inputSchema: obj({}, [], "No input required"),
  },
  {
    name: "power",
    description: "Power management: shutdown, reboot, sleep, lock",
    inputSchema: obj({
      action: str("shutdown | reboot | sleep | lock"),
    }, ["action"], ""),
  },
  {
    name: "service",
    description: "Manage system services/daemons (start/stop/restart/status)",
    inputSchema: obj({
      name: str("Service name"),
      action: str("start | stop | restart | status | enable | disable"),
    }, ["name", "action"], ""),
  },
  {
    name: "notify_send",
    description: "Send a desktop notification to the device",
    inputSchema: obj({
      title: str("Notification title"),
      message: str("Notification body"),
      urgency: str("low | normal | critical (default normal)"),
    }, ["title", "message"], ""),
  },
];

// ── Module 5: Remote Desktop (4 tools) ─────────────────────
export const REMOTE_TOOLS: ToolDef[] = [
  {
    name: "screenshot",
    description: "Capture a screenshot of the device display",
    inputSchema: obj({
      display: num("Display index (default 0)"),
      format: str("png | jpg (default png)"),
      quality: num("JPEG quality 1-100 (default 80)"),
    }, [], ""),
  },
  {
    name: "remote_input",
    description: "Inject keyboard/mouse input events on the remote device",
    inputSchema: obj({
      type: str("key | mouse | text"),
      action: str("key: press/release; mouse: move/click/scroll; text: input string"),
      value: str("Key name, coordinates, or text content"),
    }, ["type", "action", "value"], ""),
  },
  {
    name: "clipboard_sync",
    description: "Read or write the device clipboard",
    inputSchema: obj({
      action: str("read | write"),
      content: str("Content to write (required for write action)"),
    }, ["action"], ""),
  },
  {
    name: "remote_stream",
    description: "Start/stop a low-latency screen streaming session",
    inputSchema: obj({
      action: str("start | stop"),
      fps: num("Frames per second (default 15)"),
      quality: num("Quality 1-100 (default 60)"),
    }, ["action"], ""),
  },
];

// ── Module 6: AI Manipulation (4 tools) ────────────────────
export const AI_TOOLS: ToolDef[] = [
  {
    name: "ui_find",
    description: "Find UI elements by description (uses OCR/accessibility)",
    inputSchema: obj({
      query: str("Text or description to search for on screen"),
      confidence: num("Minimum confidence 0-1 (default 0.7)"),
    }, ["query"], ""),
  },
  {
    name: "ui_act",
    description: "Click, type, or scroll at a UI element found by ui_find",
    inputSchema: obj({
      element: str("Element descriptor from ui_find result"),
      action: str("click | dblclick | type | scroll | hover"),
      value: str("Text to type or scroll direction"),
    }, ["element", "action"], ""),
  },
  {
    name: "browser_open",
    description: "Open a URL in the default browser and optionally extract content",
    inputSchema: obj({
      url: str("URL to open"),
      extract: bool("Extract page text content after load (default false)"),
    }, ["url"], ""),
  },
  {
    name: "ocr_screen",
    description: "Run OCR on a screenshot region and return text results",
    inputSchema: obj({
      x: num("Region left (0-1 fraction of width, default 0)"),
      y: num("Region top (default 0)"),
      w: num("Region width (default 1)"),
      h: num("Region height (default 1)"),
      lang: str("Language code (default: eng)"),
    }, [], ""),
  },
];

// ── Module 7: Network (3 tools) ─────────────────────────────
export const NETWORK_TOOLS: ToolDef[] = [
  {
    name: "net_info",
    description: "Get network interfaces, IPs, MAC addresses",
    inputSchema: obj({}, [], "No input required"),
  },
  {
    name: "net_ping",
    description: "Ping a host and return latency/packet loss",
    inputSchema: obj({
      host: str("Hostname or IP to ping"),
      count: num("Number of pings (default 4)"),
    }, ["host"], ""),
  },
  {
    name: "net_speedtest",
    description: "Run a basic network speed test (download/upload)",
    inputSchema: obj({}, [], "No input required"),
  },
];

// ── Module 8: Hardware (3 tools) ────────────────────────────
export const HARDWARE_TOOLS: ToolDef[] = [
  {
    name: "hw_temperature",
    description: "Read CPU/GPU temperature sensors",
    inputSchema: obj({}, [], "No input required"),
  },
  {
    name: "hw_battery",
    description: "Get battery status (level, charging, health)",
    inputSchema: obj({}, [], "No input required"),
  },
  {
    name: "hw_sensors",
    description: "Read hardware sensors (fan speed, voltage, etc.)",
    inputSchema: obj({
      type: str("Filter by sensor type (optional)"),
    }, [], ""),
  },
];

// ── Module 9: Developer Tools (2 tools) ─────────────────────
export const DEV_TOOLS: ToolDef[] = [
  {
    name: "dev_shell",
    description: "Open an interactive shell session (persistent, stateful)",
    inputSchema: obj({
      command: str("Shell command (empty to start session)"),
    }, ["command"], ""),
  },
  {
    name: "dev_eval",
    description: "Execute JavaScript/Python code snippet on the device and return result",
    inputSchema: obj({
      code: str("Code to execute"),
      lang: str("js | python (default js)"),
    }, ["code"], ""),
  },
];

// ── Module 10: Media (1 tool) ──────────────────────────────
export const MEDIA_TOOLS: ToolDef[] = [
  {
    name: "media_control",
    description: "Control media playback (play/pause/next/prev/volume)",
    inputSchema: obj({
      action: str("play | pause | next | prev | volume_up | volume_down | mute"),
    }, ["action"], ""),
  },
];

// ── Aggregate ───────────────────────────────────────────────
export const ALL_TOOLS: ToolCategory[] = [
  { module: 1,  name: "Device Management",   tools: DEVICE_TOOLS },
  { module: 2,  name: "Command Execution",   tools: EXEC_TOOLS },
  { module: 3,  name: "File Operations",     tools: FILE_TOOLS },
  { module: 4,  name: "System Control",      tools: SYSTEM_TOOLS },
  { module: 5,  name: "Remote Desktop",      tools: REMOTE_TOOLS },
  { module: 6,  name: "AI Manipulation",     tools: AI_TOOLS },
  { module: 7,  name: "Network",             tools: NETWORK_TOOLS },
  { module: 8,  name: "Hardware",            tools: HARDWARE_TOOLS },
  { module: 9,  name: "Developer Tools",     tools: DEV_TOOLS },
  { module: 10, name: "Media",              tools: MEDIA_TOOLS },
];

export const ALL_TOOL_DEFS: ToolDef[] = ALL_TOOLS.flatMap(c => c.tools);
export const TOOL_COUNT = ALL_TOOL_DEFS.length; // 36

/** Look up a tool by name */
export function getTool(name: string): ToolDef | undefined {
  return ALL_TOOL_DEFS.find(t => t.name === name);
}
