#!/usr/bin/env bash
set -euo pipefail

ROOT_DIR="$(pwd)"
NODE_COMMAND=""
USE_NODE_ALIAS=0
WRITE_LEGACY=0

usage() {
  cat <<'EOF'
Uso: ./genera_mcp_json.sh [opzioni]

Opzioni:
  --root <path>            Root del repo mcp-servers (default: cwd)
  --node-path <path>       Path assoluto a node/node.exe
  --use-node-alias         Forza command="node"
  --write-legacy           Genera anche settings.json e settings.toml legacy
  -h, --help               Mostra aiuto
EOF
}

while [[ $# -gt 0 ]]; do
  case "$1" in
    --root)
      ROOT_DIR="$2"
      shift 2
      ;;
    --node-path)
      NODE_COMMAND="$2"
      shift 2
      ;;
    --use-node-alias)
      USE_NODE_ALIAS=1
      shift
      ;;
    --write-legacy)
      WRITE_LEGACY=1
      shift
      ;;
    -h|--help)
      usage
      exit 0
      ;;
    *)
      echo "Argomento non riconosciuto: $1"
      usage
      exit 2
      ;;
  esac
done

if [[ ! -d "$ROOT_DIR" ]]; then
  echo "Root non valida: $ROOT_DIR"
  exit 1
fi

ROOT_DIR="$(cd "$ROOT_DIR" && pwd)"

if [[ "$USE_NODE_ALIAS" -eq 1 ]]; then
  NODE_COMMAND="node"
elif [[ -n "$NODE_COMMAND" ]]; then
  if [[ ! -e "$NODE_COMMAND" ]]; then
    echo "Node path non trovato: $NODE_COMMAND"
    exit 1
  fi
  NODE_COMMAND="$(cd "$(dirname "$NODE_COMMAND")" && pwd)/$(basename "$NODE_COMMAND")"
else
  if command -v node >/dev/null 2>&1; then
    NODE_COMMAND="$(command -v node)"
  else
    NODE_COMMAND="node"
  fi
fi

export ROOT_DIR
export NODE_COMMAND
export WRITE_LEGACY

node <<'NODE'
const fs = require('fs');
const path = require('path');

const rootDir = process.env.ROOT_DIR;
const nodeCommand = process.env.NODE_COMMAND || 'node';
const writeLegacy = process.env.WRITE_LEGACY === '1';

const projectFsAllowedRoots = rootDir;
const projectFsConfig = path.join(rootDir, 'projectfs-node', 'projectfs.config.json');

const servers = [
  { name: 'cf-mcp-server', dir: 'cf-node', args: ['index.js'] },
  { name: 'docs-mcp-server', dir: 'docs-node', args: ['index.js'] },
  { name: 'git-mcp-server', dir: 'git-node', args: ['index.js'] },
  { name: 'linter-mcp-server', dir: 'linter-node', args: ['dist/index.js'] },
  { name: 'mantis-mcp-server', dir: 'mantis-node', args: ['index.js'] },
  { name: 'office-mcp-server', dir: 'office-node', args: ['index.js'] },
  {
    name: 'playwright-mcp-server',
    dir: 'playwright-node',
    args: ['index.js'],
    env: { ALLOWED_URLS: '*', BLOCK_MEDIA: 'false' }
  },
  {
    name: 'projectfs-mcp-server',
    dir: 'projectfs-node',
    args: ['dist/index.js'],
    env: { PROJECTFS_ALLOWED_ROOTS: projectFsAllowedRoots, PROJECTFS_CONFIG: projectFsConfig }
  },
  { name: 'sql-mcp-server', dir: 'sql-node', args: ['index.js'] }
];

function mkConfig(spec) {
  const serverDir = path.join(rootDir, spec.dir);
  const config = {
    command: nodeCommand,
    args: spec.args.map((a) => path.join(serverDir, a))
  };
  if (spec.env) {
    config.env = spec.env;
  }
  return config;
}

const claude = { mcpServers: {} };
const vscode = { servers: {} };
const codexServers = {};

for (const spec of servers) {
  const cfg = mkConfig(spec);
  claude.mcpServers[spec.name] = cfg;
  vscode.servers[spec.name] = cfg;
  codexServers[spec.name] = cfg;
  console.log(`Configurato: ${spec.name}`);
}

const claudePath = path.join(rootDir, 'settings.claude.json');
const vscodePath = path.join(rootDir, 'settings.vscode.mcp.json');
const codexPath = path.join(rootDir, 'settings.codex.toml');

fs.writeFileSync(claudePath, JSON.stringify(claude, null, 2), 'utf8');
fs.writeFileSync(vscodePath, JSON.stringify(vscode, null, 2), 'utf8');
fs.writeFileSync(codexPath, toToml(codexServers), 'utf8');

console.log(`Generato: ${claudePath}`);
console.log(`Generato: ${vscodePath}`);
console.log(`Generato: ${codexPath}`);

if (writeLegacy) {
  const legacyJson = path.join(rootDir, 'settings.json');
  const legacyToml = path.join(rootDir, 'settings.toml');
  fs.writeFileSync(legacyJson, JSON.stringify(claude, null, 2), 'utf8');
  fs.writeFileSync(legacyToml, toToml(codexServers), 'utf8');
  console.log(`Generato (legacy): ${legacyJson}`);
  console.log(`Generato (legacy): ${legacyToml}`);
}

console.log('Completato.');

function toToml(map) {
  const names = Object.keys(map).sort();
  const lines = [];
  for (const name of names) {
    const cfg = map[name];
    lines.push(`[mcp_servers.${name}]`);
    lines.push(`command = "${escapeTomlString(cfg.command)}"`);
    const args = cfg.args.map((a) => `"${escapeTomlString(String(a))}"`).join(', ');
    lines.push(`args = [${args}]`);

    if (cfg.env) {
      lines.push('');
      lines.push(`[mcp_servers.${name}.env]`);
      for (const k of Object.keys(cfg.env).sort()) {
        lines.push(`${k} = "${escapeTomlString(String(cfg.env[k]))}"`);
      }
    }
    lines.push('');
  }
  return lines.join('\n');
}

function escapeTomlString(v) {
  return String(v).replace(/\\/g, '\\\\').replace(/"/g, '\\"');
}
NODE