/**
 * Shared OpenCode client manager.
 * Reuses an existing server on port 4096; starts one on a random port as fallback.
 * Tracks spawned servers so they can be cleaned up on process exit.
 */
import { execSync } from 'node:child_process';
import { existsSync } from 'node:fs';
import { join } from 'node:path';
import { homedir } from 'node:os';

const activeServers = new Set<{ close(): void }>();

// Clean up spawned OpenCode servers on process exit
function cleanup() {
  for (const server of activeServers) {
    try {
      server.close();
    } catch {
      /* ignore */
    }
  }
  activeServers.clear();
}

process.on('beforeExit', cleanup);
process.on('SIGTERM', cleanup);
process.on('SIGINT', cleanup);

const isWindows = process.platform === 'win32';

/** Cached resolved binary path */
let _resolvedBinary: string | undefined | null = null;

/** Resolve the opencode binary, with caching. */
function resolveOpencodeBinary(): string | undefined {
  if (_resolvedBinary !== null) return _resolvedBinary ?? undefined;

  // PATH lookup
  try {
    const cmd = isWindows ? 'where opencode 2>nul' : 'which opencode 2>/dev/null';
    const result = execSync(cmd, { encoding: 'utf-8', timeout: 5000 })
      .trim()
      .split(/\r?\n/)[0]
      ?.trim();
    if (result && existsSync(result)) {
      _resolvedBinary = result;
      return result;
    }
  } catch {
    /* not on PATH */
  }

  // Common install locations
  const home = homedir();
  const candidates = isWindows
    ? [
        join(process.env.APPDATA || '', 'npm', 'opencode.cmd'),
        join(process.env.NVM_SYMLINK || '', 'opencode.cmd'),
        join(process.env.FNM_MULTISHELL_PATH || '', 'opencode.cmd'),
        join(home, 'scoop', 'shims', 'opencode.exe'),
      ]
    : [
        join(home, '.opencode', 'bin', 'opencode'),
        join(home, '.npm-global', 'bin', 'opencode'),
        '/usr/local/bin/opencode',
        '/opt/homebrew/bin/opencode',
        join(home, '.local', 'bin', 'opencode'),
      ];

  for (const c of candidates) {
    if (c && existsSync(c)) {
      _resolvedBinary = c;
      return c;
    }
  }

  _resolvedBinary = undefined;
  return undefined;
}

export async function getOpencodeClient(binaryPath?: string) {
  const { createOpencodeClient, createOpencode } = await import('../opencode/index');

  // Try connecting to an existing server first
  try {
    const client = createOpencodeClient();
    await client.config.providers(); // probe
    return { client, server: undefined };
  } catch {
    // No running server — start a temporary one on a random port
    const resolvedPath = binaryPath ?? resolveOpencodeBinary();
    const timeout = isWindows ? 15_000 : 5000;
    const oc = await createOpencode({ port: 0, binaryPath: resolvedPath, timeout });
    activeServers.add(oc.server);
    return { client: oc.client, server: oc.server };
  }
}

export function releaseOpencodeServer(server: { close(): void } | undefined) {
  if (!server) return;
  try {
    server.close();
  } catch {
    /* ignore */
  }
  activeServers.delete(server);
}