#!/usr/bin/env node
/**
 * Domain availability CLI for agents, over the Namechan API. No dependencies; Node 18+.
 *
 *   node domains.mjs check acme.com acme.io getacme.com
 *   node domains.mjs name acme --tlds com,io,ai
 *   node domains.mjs whois example.com
 *   node domains.mjs usage
 *
 * Works without a key, on the per-address limits. A key, if there is one,
 * comes from NAMECHAN_API_KEY or ~/.config/namechan/api-key and is sent as a
 * bearer token. Output is JSON on stdout; failures print a message on stderr
 * and exit 1.
 */
import { readFile } from 'node:fs/promises';
import { homedir } from 'node:os';
import { join } from 'node:path';
import { pathToFileURL } from 'node:url';

const API = (process.env.NAMECHAN_API_URL || 'https://namechan.com/api/v1').replace(/\/$/, '');
const KEY_FILE = join(homedir(), '.config', 'namechan', 'api-key');

async function readKey() {
  const env = (process.env.NAMECHAN_API_KEY || '').trim();
  if (env) return env;
  try {
    return (await readFile(KEY_FILE, 'utf8')).trim();
  } catch {
    return '';
  }
}

function fail(message) {
  process.stderr.write(`${message}\n`);
  process.exit(1);
}

/** Splits arguments that may themselves hold commas or newlines. */
export function names(args) {
  return args.flatMap((a) => a.split(/[\s,;]+/)).map((a) => a.trim()).filter(Boolean);
}

export function parseArgs(argv) {
  const [command, ...rest] = argv;
  const flags = {};
  const positional = [];
  for (let i = 0; i < rest.length; i += 1) {
    if (rest[i] === '--tlds') flags.tlds = rest[(i += 1)] ?? '';
    else if (rest[i].startsWith('--tlds=')) flags.tlds = rest[i].slice(7);
    else positional.push(rest[i]);
  }
  return { command, positional, flags };
}

async function call(path, key, init = {}) {
  let res;
  try {
    res = await fetch(`${API}${path}`, {
      ...init,
      headers: {
        ...(key ? { Authorization: `Bearer ${key}` } : {}),
        'Content-Type': 'application/json',
        'User-Agent': 'domain-availability-skill/1.1',
        ...init.headers,
      },
    });
  } catch (error) {
    fail(`Could not reach Namechan: ${error.message}`);
  }
  const body = await res.json().catch(() => null);
  if (!res.ok) fail(body?.error?.message || `Namechan answered HTTP ${res.status}.`);
  return body;
}

async function main() {
  const { command, positional, flags } = parseArgs(process.argv.slice(2));
  if (!command || command === 'help' || command === '--help') {
    process.stdout.write('Usage: domains.mjs check <domain...> | name <label> [--tlds com,io] | whois <domain> | usage\n');
    return;
  }

  // No key is fine: the API then applies the per-address limits.
  const key = await readKey();

  let out;
  switch (command) {
    case 'check': {
      const domains = names(positional);
      if (domains.length === 0) fail('check needs at least one domain, e.g. check acme.com acme.io');
      out = await call('/check', key, { method: 'POST', body: JSON.stringify({ domains }) });
      break;
    }
    case 'name': {
      if (!positional[0]) fail('name needs a keyword, e.g. name acme --tlds com,io,ai');
      const body = { name: positional[0] };
      if (flags.tlds) body.tlds = names([flags.tlds]);
      out = await call('/check', key, { method: 'POST', body: JSON.stringify(body) });
      break;
    }
    case 'whois': {
      if (!positional[0]) fail('whois needs one domain, e.g. whois example.com');
      out = await call(`/whois?domain=${encodeURIComponent(positional[0])}`, key);
      break;
    }
    case 'usage':
      out = await call('/usage', key);
      break;
    default:
      fail(`Unknown command "${command}". Use check, name, whois or usage.`);
  }
  process.stdout.write(`${JSON.stringify(out, null, 2)}\n`);
}

// Run as a command, not when imported by the tests.
if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) await main();