#!/usr/bin/env node
/**
 * Claude CLI to OpenAI-compatible API Proxy
 *
 * This proxy allows @hanzo/dev to use Claude Code CLI as a backend.
 * It accepts OpenAI-compatible chat completion requests and invokes
 * the Claude CLI under the hood.
 *
 * Usage:
 *   node claude-proxy.js [--port 8080]
 *
 * Then configure ~/.code/config.toml:
 *   [model_providers.claude-cli]
 *   name = "Claude CLI"
 *   base_url = "http://localhost:8080/v1"
 *   wire_api = "chat"
 */

const http = require("http");
const { spawn } = require("child_process");

const PORT = parseInt(
  process.env.PORT ||
    process.argv.find((a) => a.startsWith("--port="))?.split("=")[1] ||
    "8080",
);

/**
 * Extract non-JSON text from Claude CLI output (filter telemetry)
 */
function extractResponse(output) {
  const lines = output.split("\n");
  const textLines = [];
  let inJson = false;
  let braceCount = 0;

  for (const line of lines) {
    const trimmed = line.trim();

    // Skip empty lines at start
    if (!trimmed && textLines.length === 0) continue;

    // Track JSON blocks
    if (trimmed.startsWith("{")) {
      inJson = true;
      braceCount = 1;
      continue;
    }

    if (inJson) {
      braceCount += (trimmed.match(/{/g) || []).length;
      braceCount -= (trimmed.match(/}/g) || []).length;
      if (braceCount <= 0) {
        inJson = false;
      }
      continue;
    }

    // Skip lines that are just JSON artifacts (brackets, commas)
    if (/^[\[\]\{\},\s]*$/.test(trimmed)) {
      continue;
    }

    // Not in JSON block - this is actual content
    if (trimmed && !trimmed.startsWith("}")) {
      textLines.push(line);
    }
  }

  // Clean up any trailing bracket artifacts
  let result = textLines.join("\n").trim();
  result = result.replace(/\s*[\[\]\{\}]+\s*$/g, "").trim();

  return result;
}

/**
 * Map model names to Claude CLI supported models
 */
function mapModel(model) {
  const modelMap = {
    "claude-cli": null, // Use default
    "claude-opus": "claude-opus-4-5-20251101",
    "claude-sonnet": "claude-sonnet-4-20250514",
    "claude-haiku": "claude-haiku-4-5-20251001",
    "gpt-4": null, // Use default
    "gpt-4o": null,
    "gpt-4o-mini": null,
  };

  // If model is in map, use mapped value (null means use default)
  if (model in modelMap) {
    return modelMap[model];
  }

  // If model starts with 'claude-', pass it through
  if (model && model.startsWith("claude-")) {
    return model;
  }

  // Default: use Claude's default model
  return null;
}

/**
 * Invoke Claude CLI and return the response
 */
function invokeClaude(prompt, model) {
  return new Promise((resolve, reject) => {
    const args = ["-p", "--output-format", "text"];

    // Map model name to Claude CLI format
    const mappedModel = mapModel(model);
    if (mappedModel) {
      args.push("--model", mappedModel);
    }

    // Create clean env without ANTHROPIC_API_KEY to force subscription mode
    const cleanEnv = { ...process.env };
    delete cleanEnv.ANTHROPIC_API_KEY;
    delete cleanEnv.ANTHROPIC_AUTH_TOKEN;
    cleanEnv.OTEL_SDK_DISABLED = "true";

    const claude = spawn("claude", args, {
      stdio: ["pipe", "pipe", "pipe"],
      env: cleanEnv,
    });

    let stdout = "";
    let stderr = "";

    claude.stdout.on("data", (data) => {
      stdout += data.toString();
    });

    claude.stderr.on("data", (data) => {
      stderr += data.toString();
    });

    claude.on("close", (code) => {
      if (code !== 0 && !stdout) {
        reject(new Error(`Claude CLI exited with code ${code}: ${stderr}`));
      } else {
        const response = extractResponse(stdout);
        resolve(response || stdout);
      }
    });

    claude.on("error", (err) => {
      reject(err);
    });

    // Send prompt via stdin
    claude.stdin.write(prompt);
    claude.stdin.end();
  });
}

/**
 * Handle incoming HTTP requests
 */
async function handleRequest(req, res) {
  const url = new URL(req.url, `http://localhost:${PORT}`);

  // CORS headers
  res.setHeader("Access-Control-Allow-Origin", "*");
  res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
  res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");

  if (req.method === "OPTIONS") {
    res.writeHead(200);
    res.end();
    return;
  }

  // Health check
  if (url.pathname === "/health" || url.pathname === "/") {
    res.writeHead(200, { "Content-Type": "application/json" });
    res.end(JSON.stringify({ status: "ok", provider: "claude-cli" }));
    return;
  }

  // Chat completions endpoint
  if (url.pathname === "/v1/chat/completions" && req.method === "POST") {
    let body = "";

    req.on("data", (chunk) => {
      body += chunk.toString();
    });

    req.on("end", async () => {
      try {
        const request = JSON.parse(body);

        // Extract prompt from messages - combine all for context
        const messages = request.messages || [];
        const model = request.model;

        // Build a combined prompt with role prefixes for context
        let prompt = messages
          .map((msg) => {
            const role = msg.role || "user";
            const content = msg.content || "";
            if (role === "system") {
              return `[System]: ${content}`;
            } else if (role === "assistant") {
              return `[Assistant]: ${content}`;
            } else {
              return content; // User messages without prefix
            }
          })
          .join("\n\n");

        console.log(
          `[${new Date().toISOString()}] Request: model=${model}, prompt=${prompt.substring(0, 50)}...`,
        );

        // Invoke Claude CLI
        const response = await invokeClaude(prompt, model);

        console.log(
          `[${new Date().toISOString()}] Response: ${response.substring(0, 100)}...`,
        );

        // Return OpenAI-compatible response
        const completion = {
          id: `chatcmpl-${Date.now()}`,
          object: "chat.completion",
          created: Math.floor(Date.now() / 1000),
          model: model || "claude-cli",
          choices: [
            {
              index: 0,
              message: {
                role: "assistant",
                content: response,
              },
              finish_reason: "stop",
            },
          ],
          usage: {
            prompt_tokens: Math.ceil(prompt.length / 4),
            completion_tokens: Math.ceil(response.length / 4),
            total_tokens: Math.ceil((prompt.length + response.length) / 4),
          },
        };

        res.writeHead(200, { "Content-Type": "application/json" });
        res.end(JSON.stringify(completion));
      } catch (error) {
        console.error(`[${new Date().toISOString()}] Error:`, error.message);
        res.writeHead(500, { "Content-Type": "application/json" });
        res.end(
          JSON.stringify({
            error: {
              message: error.message,
              type: "server_error",
              code: "internal_error",
            },
          }),
        );
      }
    });

    return;
  }

  // Models endpoint (for compatibility)
  if (url.pathname === "/v1/models" && req.method === "GET") {
    res.writeHead(200, { "Content-Type": "application/json" });
    res.end(
      JSON.stringify({
        object: "list",
        data: [
          {
            id: "claude-cli",
            object: "model",
            created: Date.now(),
            owned_by: "anthropic",
          },
          {
            id: "claude-opus",
            object: "model",
            created: Date.now(),
            owned_by: "anthropic",
          },
          {
            id: "claude-sonnet",
            object: "model",
            created: Date.now(),
            owned_by: "anthropic",
          },
          {
            id: "claude-haiku",
            object: "model",
            created: Date.now(),
            owned_by: "anthropic",
          },
        ],
      }),
    );
    return;
  }

  // 404 for unknown endpoints
  res.writeHead(404, { "Content-Type": "application/json" });
  res.end(
    JSON.stringify({ error: { message: "Not found", type: "not_found" } }),
  );
}

// Create server
const server = http.createServer(handleRequest);

server.listen(PORT, () => {
  console.log(`
╔══════════════════════════════════════════════════════════════╗
║          Claude CLI → OpenAI API Proxy                       ║
╠══════════════════════════════════════════════════════════════╣
║  Listening on: http://localhost:${PORT}                         ║
║  Endpoint:     http://localhost:${PORT}/v1/chat/completions     ║
╠══════════════════════════════════════════════════════════════╣
║  Configure ~/.code/config.toml:                              ║
║                                                              ║
║  [model_providers.claude-cli]                                ║
║  name = "Claude CLI"                                         ║
║  base_url = "http://localhost:${PORT}/v1"                       ║
║  wire_api = "chat"                                           ║
║                                                              ║
║  Then: code -c 'model_provider="claude-cli"'                 ║
╚══════════════════════════════════════════════════════════════╝
`);
});

// Graceful shutdown
process.on("SIGINT", () => {
  console.log("\nShutting down...");
  server.close(() => {
    process.exit(0);
  });
});