import { DesktopCommandBroker } from './sandbox.js';
import { readWorkspaceTextFile } from './workspace.js';
import type { DesktopToolEvent, DesktopToolSummary } from '../shared.js';

export interface ToolCallRequest {
  readonly name: string;
  readonly input: Record<string, unknown>;
}

const LEDGER_API = 'https://sovereign-email-agent.snapkittywest.workers.dev/api/commit';

export const SOVEREIGN_TOOLS: ReadonlyArray<DesktopToolSummary> = [
  {
    name: 'workspace.search',
    description: 'Search this repo with ripgrep. Read-only.',
    inputSchema: { pattern: 'string', path: 'optional string path inside repo' },
  },
  {
    name: 'workspace.read_file',
    description: 'Read a text file from inside this repo. Read-only.',
    inputSchema: { path: 'string path inside repo' },
  },
  {
    name: 'repo.status',
    description: 'Run git status -sb. Read-only.',
    inputSchema: {},
  },
  {
    name: 'repo.diff_stat',
    description: 'Run git diff --stat. Read-only.',
    inputSchema: {},
  },
  {
    name: 'repo.test',
    description: 'Run npm test through the governed command broker.',
    inputSchema: {},
  },
  {
    name: 'repo.build',
    description: 'Run npm run build through the governed command broker.',
    inputSchema: {},
  },
  {
    name: 'repo.verify',
    description: 'Run npm run verify through the governed command broker.',
    inputSchema: {},
  },
  {
    name: 'ledger.seal',
    description: 'Seal the current file to the Fibonacci WORM ledger and commit to GitHub. Artifact hash (SHA-512 → 0xFFFFFFFF → SHA-512) recorded on-chain.',
    inputSchema: { path: 'string — owner/repo/file/path.ext', code: 'string — file content', branch: 'optional string — default main' },
  },
];

const TOOL_NAMES = new Set(SOVEREIGN_TOOLS.map(tool => tool.name));

export class SovereignToolBroker {
  constructor(
    private readonly repoRoot: string,
    private readonly commands: DesktopCommandBroker,
  ) {}

  list(): ReadonlyArray<DesktopToolSummary> {
    return SOVEREIGN_TOOLS;
  }

  async execute(call: ToolCallRequest): Promise<DesktopToolEvent> {
    try {
      if (!TOOL_NAMES.has(call.name)) {
        return { name: call.name, ok: false, output: `Unknown tool: ${call.name}` };
      }

      switch (call.name) {
        case 'workspace.search':
          return this.runCommandTool(call.name, buildSearchCommand(call.input));
        case 'workspace.read_file': {
          const path = requireString(call.input, 'path');
          const file = await readWorkspaceTextFile(this.repoRoot, path);
          return {
            name: call.name,
            ok: true,
            output: truncateToolOutput(`FILE ${file.relativePath}\n\n${file.content}`),
          };
        }
        case 'repo.status':
          return this.runCommandTool(call.name, 'git status -sb');
        case 'repo.diff_stat':
          return this.runCommandTool(call.name, 'git diff --stat');
        case 'repo.test':
          return this.runCommandTool(call.name, 'npm test');
        case 'repo.build':
          return this.runCommandTool(call.name, 'npm run build');
        case 'repo.verify':
          return this.runCommandTool(call.name, 'npm run verify');
        case 'ledger.seal':
          return this.sealToLedger(call);
        default:
          return { name: call.name, ok: false, output: `Unhandled tool: ${call.name}` };
      }
    } catch (error) {
      return {
        name: call.name,
        ok: false,
        output: error instanceof Error ? error.message : String(error),
      };
    }
  }

  private async sealToLedger(call: ToolCallRequest): Promise<DesktopToolEvent> {
    const path   = requireString(call.input, 'path');
    const code   = requireString(call.input, 'code');
    const branch = typeof call.input.branch === 'string' ? call.input.branch : 'main';

    const res = await fetch(LEDGER_API, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ path, code, branch, author: 'bob-desktop-ide' }),
    });

    if (!res.ok) {
      const err = await res.text();
      return { name: call.name, ok: false, output: `Ledger API error ${res.status}: ${err}` };
    }

    const data = await res.json() as Record<string, unknown>;
    const ledger = data.ledger as Record<string, unknown>;

    const output = [
      `SOVEREIGN COMMIT SEALED`,
      `══════════════════════════════`,
      `  File:     ${data.file}`,
      `  Branch:   ${data.branch}`,
      `  Commit:   ${data.commit}`,
      `  URL:      ${data.url}`,
      ``,
      `FIBONACCI LEDGER`,
      `  Block:    ${ledger.block}`,
      `  F(${ledger.block}):    ${ledger.fib}`,
      `  Hash:     ${data.artifact_hash}`,
      `  Pipeline: ${data.pipeline}`,
      `══════════════════════════════`,
    ].join('\n');

    return { name: call.name, ok: true, output };
  }

  private async runCommandTool(name: string, command: string): Promise<DesktopToolEvent> {
    const result = await this.commands.run({ command }, () => undefined);
    const output = [
      result.reason ? `reason: ${result.reason}` : '',
      result.stdout,
      result.stderr,
    ].filter(Boolean).join('\n');
    return {
      name,
      ok: result.allowed && result.exitCode === 0,
      output: truncateToolOutput(output || `exit=${result.exitCode}`),
    };
  }
}

export function parseToolCall(content: string): ToolCallRequest | undefined {
  const candidates = [
    ...extractJsonCodeBlocks(content),
    content.trim(),
  ];

  for (const candidate of candidates) {
    try {
      const parsed = JSON.parse(candidate) as unknown;
      const toolCall = typeof parsed === 'object' && parsed !== null && 'tool_call' in parsed
        ? (parsed as { tool_call?: unknown }).tool_call
        : parsed;
      if (typeof toolCall !== 'object' || toolCall === null) continue;
      const record = toolCall as Record<string, unknown>;
      if (typeof record.name !== 'string') continue;
      const input = typeof record.input === 'object' && record.input !== null
        ? record.input as Record<string, unknown>
        : {};
      return { name: record.name, input };
    } catch {
      continue;
    }
  }

  return undefined;
}

export function removeToolCallJson(content: string): string {
  return content
    .replace(/```(?:json)?\s*{[\s\S]*?"tool_call"[\s\S]*?}\s*```/gi, '')
    .replace(/^\s*{[\s\S]*?"tool_call"[\s\S]*?}\s*$/i, '')
    .trim();
}

export function formatToolResultForModel(call: ToolCallRequest, event: DesktopToolEvent): string {
  return JSON.stringify({
    tool_result: {
      name: call.name,
      ok: event.ok,
      output: event.output,
    },
  }, null, 2);
}

function buildSearchCommand(input: Record<string, unknown>): string {
  const pattern = requireString(input, 'pattern');
  const path = typeof input.path === 'string' && input.path.trim() ? input.path.trim() : '.';
  return `rg ${quoteArg(pattern)} ${quoteArg(path)}`;
}

function requireString(input: Record<string, unknown>, key: string): string {
  const value = input[key];
  if (typeof value !== 'string' || !value.trim()) {
    throw new Error(`Tool input field "${key}" must be a non-empty string.`);
  }
  return value.trim();
}

function quoteArg(value: string): string {
  return `"${value.replaceAll('\\', '\\\\').replaceAll('"', '\\"')}"`;
}

function extractJsonCodeBlocks(content: string): string[] {
  const matches = [...content.matchAll(/```(?:json)?\s*([\s\S]*?)```/gi)];
  return matches.map(match => match[1]?.trim() ?? '').filter(Boolean);
}

function truncateToolOutput(output: string): string {
  const limit = 12_000;
  if (output.length <= limit) return output;
  return `${output.slice(0, limit)}\n\n[tool output truncated at ${limit} chars]`;
}