import * as fs from "fs";
import * as path from "path";
import * as readline from "readline";

// Helper to manually load .env file
function loadEnv() {
  const envPath = path.join(__dirname, "../.env");
  if (fs.existsSync(envPath)) {
    const envContent = fs.readFileSync(envPath, "utf8");
    for (const line of envContent.split("\n")) {
      const match = line.match(/^\s*([\w.-]+)\s*=\s*(.*)\s*$/);
      if (match) {
        const key = match[1];
        let value = match[2].trim();
        if (value.startsWith('"') && value.endsWith('"')) value = value.slice(1, -1);
        else if (value.startsWith("'") && value.endsWith("'")) value = value.slice(1, -1);
        process.env[key] = value;
      }
    }
  }
}

loadEnv();

const N8N_HOST = process.env.N8N_HOST || "https://n8n.gaboggamer.online";
const N8N_API_KEY = process.env.N8N_API_KEY;
const EMAIL_USER = process.env.EMAIL_USER;
const EMAIL_PASSWORD = process.env.EMAIL_PASSWORD;
const EMAIL_HOST = process.env.EMAIL_HOST;
const EMAIL_PORT = parseInt(process.env.EMAIL_PORT || "465", 10);
const SUPABASE_URL = process.env.NEXT_PUBLIC_SUPABASE_URL;
const SUPABASE_SECRET_KEY = process.env.SUPABASE_SECRET_KEY;

if (!N8N_API_KEY) {
  console.error("Error: N8N_API_KEY is not defined in .env file.");
  process.exit(1);
}

// Interactive prompt helper
function askQuestion(query: string): Promise<string> {
  const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout,
  });

  return new Promise((resolve) =>
    rl.question(query, (ans) => {
      rl.close();
      resolve(ans.trim());
    })
  );
}

// n8n request helper
async function n8nRequest(endpoint: string, method: string = "GET", body?: any) {
  const response = await fetch(`${N8N_HOST}${endpoint}`, {
    method,
    headers: {
      "X-N8N-API-KEY": N8N_API_KEY!,
      "Content-Type": "application/json",
    },
    body: body ? JSON.stringify(body) : undefined,
  });

  if (!response.ok) {
    const text = await response.text();
    throw new Error(`n8n API request failed: ${response.status} ${response.statusText} - ${text}`);
  }

  return response.json();
}

async function getOrCreateCredential(name: string, type: string, data: any) {
  try {
    const credsList = await n8nRequest("/api/v1/credentials");
    const existingCred = credsList.data.find((c: any) => c.name === name && c.type === type);
    if (existingCred) {
      console.log(`Reusing existing credential: ${name} (ID: ${existingCred.id})`);
      return existingCred.id;
    } else {
      const newCred = await n8nRequest("/api/v1/credentials", "POST", {
        name,
        type,
        data,
      });
      console.log(`Created new credential: ${name} (ID: ${newCred.id})`);
      return newCred.id;
    }
  } catch (err: any) {
    console.error(`Error setting up credential ${name}:`, err.message);
    process.exit(1);
  }
}

// LLM provider node configuration details
interface ProviderConfig {
  nodeType: string;
  credentialType: string;
  credentialData: any;
  nodeParameters: any;
}

function getProviderConfig(provider: string, apiKey: string, modelName: string): ProviderConfig {
  switch (provider) {
    case "1": // Deepseek (Native)
      return {
        nodeType: "@n8n/n8n-nodes-langchain.lmChatDeepSeek",
        credentialType: "deepSeekApi",
        credentialData: {
          apiKey,
          allowedHttpRequestDomains: "none",
        },
        nodeParameters: {
          model: modelName || "deepseek-chat",
          options: {},
        },
      };
    case "2": // OpenAI
      return {
        nodeType: "@n8n/n8n-nodes-langchain.lmChatOpenAi",
        credentialType: "openAiApi",
        credentialData: {
          apiKey,
          header: false,
          allowedHttpRequestDomains: "none",
        },
        nodeParameters: {
          model: modelName || "gpt-4o-mini",
          options: {},
        },
      };
    case "3": // Google Gemini
      return {
        nodeType: "@n8n/n8n-nodes-langchain.lmChatGoogleGemini",
        credentialType: "googlePalmApi",
        credentialData: {
          apiKey,
          host: "https://generativelanguage.googleapis.com",
          allowedHttpRequestDomains: "none",
        },
        nodeParameters: {
          model: modelName || "gemini-1.5-flash",
          options: {},
        },
      };
    case "4": // Anthropic
      return {
        nodeType: "@n8n/n8n-nodes-langchain.lmChatAnthropic",
        credentialType: "anthropicApi",
        credentialData: {
          apiKey,
          allowedHttpRequestDomains: "none",
        },
        nodeParameters: {
          model: modelName || "claude-3-5-sonnet-latest",
          options: {},
        },
      };
    default:
      throw new Error("Invalid provider chosen");
  }
}

async function main() {
  console.log("\n==================================================");
  console.log("Welcome to n8n Kickstart Interactive Setup");
  console.log("==================================================");

  // 1. Ask for Primary Provider
  console.log("\nSelect Primary LLM Provider:");
  console.log("1. Deepseek (Native Node)");
  console.log("2. OpenAI (Standard)");
  console.log("3. Google Gemini");
  console.log("4. Anthropic");
  const primaryProviderChoice = await askQuestion("Enter choice (1-4) [default: 1]: ") || "1";

  let defaultModel = "deepseek-chat";
  if (primaryProviderChoice === "2") defaultModel = "gpt-4o-mini";
  else if (primaryProviderChoice === "3") defaultModel = "gemini-1.5-flash";
  else if (primaryProviderChoice === "4") defaultModel = "claude-3-5-sonnet-latest";

  const primaryModelName = await askQuestion(`Enter primary model name [default: ${defaultModel}]: `) || defaultModel;

  let defaultKey = "";
  if (primaryProviderChoice === "1") defaultKey = process.env.DEEPSEEK_API_KEY || "";
  else if (primaryProviderChoice === "3") defaultKey = process.env.GEMINI_API_KEY || "";

  const primaryApiKey = await askQuestion(`Enter API key [default: ${defaultKey ? "Loaded from .env" : "None"}]: `) || defaultKey;
  if (!primaryApiKey) {
    console.error("API Key is required.");
    process.exit(1);
  }

  // 2. Ask for Fallback Provider
  const configureFallback = (await askQuestion("\nDo you want to configure a Fallback LLM Model? (y/n) [default: n]: ") || "n").toLowerCase() === "y";
  let fallbackProviderChoice = "";
  let fallbackModelName = "";
  let fallbackApiKey = "";

  if (configureFallback) {
    console.log("\nSelect Fallback LLM Provider:");
    console.log("1. Deepseek (Native Node)");
    console.log("2. OpenAI (Standard)");
    console.log("3. Google Gemini");
    console.log("4. Anthropic");
    fallbackProviderChoice = await askQuestion("Enter choice (1-4) [default: 3]: ") || "3";

    let defaultFallbackModel = "gemini-1.5-flash";
    if (fallbackProviderChoice === "1") defaultFallbackModel = "deepseek-chat";
    else if (fallbackProviderChoice === "2") defaultFallbackModel = "gpt-4o-mini";
    else if (fallbackProviderChoice === "4") defaultFallbackModel = "claude-3-5-sonnet-latest";

    fallbackModelName = await askQuestion(`Enter fallback model name [default: ${defaultFallbackModel}]: `) || defaultFallbackModel;

    let defaultFallbackKey = "";
    if (fallbackProviderChoice === "1") defaultFallbackKey = process.env.DEEPSEEK_API_KEY || "";
    else if (fallbackProviderChoice === "3") defaultFallbackKey = process.env.GEMINI_API_KEY || "";

    fallbackApiKey = await askQuestion(`Enter fallback API key [default: ${defaultFallbackKey ? "Loaded from .env" : "None"}]: `) || defaultFallbackKey;
    if (!fallbackApiKey) {
      console.error("Fallback API Key is required when fallback is enabled.");
      process.exit(1);
    }
  }

  console.log("\n==================================================");
  console.log("Setting up credentials on n8n server...");
  console.log("==================================================");

  // 1. Manage IMAP Credentials
  const imapCredId = await getOrCreateCredential("Semillero2_IMAP", "imap", {
    host: EMAIL_HOST,
    port: EMAIL_PORT,
    user: EMAIL_USER,
    password: EMAIL_PASSWORD,
    secure: true,
  });

  // 2. Manage Supabase Credentials using modern keys structure
  const supabaseCredId = await getOrCreateCredential("Semillero2_Supabase", "supabaseApi", {
    host: SUPABASE_URL,
    serviceRole: SUPABASE_SECRET_KEY,
    allowedHttpRequestDomains: "none",
  });

  // 3. Manage Primary Model Credentials
  const primaryConfig = getProviderConfig(primaryProviderChoice, primaryApiKey, primaryModelName);
  const primaryCredId = await getOrCreateCredential("Semillero2_Primary_Model", primaryConfig.credentialType, primaryConfig.credentialData);

  // 4. Manage Fallback Model Credentials (if enabled)
  let fallbackConfig: ProviderConfig | null = null;
  let fallbackCredId = "";
  if (configureFallback) {
    fallbackConfig = getProviderConfig(fallbackProviderChoice, fallbackApiKey, fallbackModelName);
    fallbackCredId = await getOrCreateCredential("Semillero2_Fallback_Model", fallbackConfig.credentialType, fallbackConfig.credentialData);
  }

  // Define nodes dynamically
  console.log("\nBuilding workflow configurations...");

  const parserNode = {
    parameters: {
      jsonSchema: "{\n  \"type\": \"object\",\n  \"properties\": {\n    \"summary\": {\n      \"type\": \"string\"\n    },\n    \"classification\": {\n      \"type\": \"string\",\n      \"enum\": [\"Qualified\", \"Unqualified\", \"Review\"]\n    },\n    \"suggestions\": {\n      \"type\": \"array\",\n      \"items\": {\n        \"type\": \"string\"\n      }\n    },\n    \"riskLevel\": {\n      \"type\": \"string\",\n      \"enum\": [\"Low\", \"Medium\", \"High\"]\n    }\n  },\n  \"required\": [\"summary\", \"classification\", \"suggestions\", \"riskLevel\"]\n}",
    },
    id: "w3-parser-primary-id",
    name: "Structured Output Parser",
    type: "@n8n/n8n-nodes-langchain.outputParserStructured",
    typeVersion: 1,
    position: [680, 480],
  };

  const primaryChainNode = {
    parameters: {
      promptType: "Define below", // Fixed casing as required!
      text: "={{ $json.text }}",
      systemMessage: "You are an AI recruitment assistant. Analyze the candidate's CV text. You MUST respond with a raw JSON object containing exactly these four keys:\n- summary: a brief profile summary.\n- classification: 'Qualified', 'Unqualified', or 'Review'.\n- suggestions: an array of recommendations for next steps.\n- riskLevel: 'Low', 'Medium', or 'High'.\n\nDo not include markdown code blocks or any text outside the JSON.",
    },
    id: "w3-chain-primary-id",
    name: "Basic LLM Chain (Primary)",
    type: "@n8n/n8n-nodes-langchain.chainLlm",
    typeVersion: 1.4,
    position: [480, 300],
    continueOnFail: configureFallback, // enable continue on fail only if fallback exists
  };

  const primaryModelNode = {
    parameters: primaryConfig.nodeParameters,
    id: "w3-model-primary-id",
    name: "Primary Chat Model",
    type: primaryConfig.nodeType,
    typeVersion: 1,
    position: [480, 480],
    credentials: {
      [primaryConfig.credentialType]: {
        id: primaryCredId,
        name: "Semillero2_Primary_Model",
      },
    },
  };

  const parsePrimaryNode = {
    parameters: {
      jsCode: `return [{
  json: {
    name: $('Execute Workflow Trigger').item.json.name || "Unknown Candidate",
    email: $('Execute Workflow Trigger').item.json.email || "unknown@example.com",
    summary: $input.first().json.summary,
    seniority: $input.first().json.classification
  }
}];`,
    },
    id: "w3-parse-primary-id",
    name: "Parse Primary Response",
    type: "n8n-nodes-base.code",
    typeVersion: 2,
    position: [900, 200],
  };

  const supabaseInsertNode = {
    parameters: {
      operation: "insert",
      table: "candidates",
      options: {},
    },
    id: "w3-supabase-id",
    name: "Insert Candidate to Supabase",
    type: "n8n-nodes-base.supabase",
    typeVersion: 1,
    position: [1150, 300],
    credentials: {
      supabaseApi: {
        id: supabaseCredId,
        name: "Semillero2_Supabase",
      },
    },
  };

  // Build the complete list of nodes and connections for Workflow 3
  const w3Nodes: any[] = [
    {
      parameters: {},
      id: "w3-trigger-id",
      name: "Execute Workflow Trigger",
      type: "n8n-nodes-base.executeWorkflowTrigger",
      typeVersion: 1,
      position: [250, 300],
    },
    primaryChainNode,
    primaryModelNode,
    parserNode,
    supabaseInsertNode,
  ];

  const w3Connections: any = {
    "Execute Workflow Trigger": {
      main: [
        [
          {
            node: "Basic LLM Chain (Primary)",
            type: "main",
            index: 0,
          },
        ],
      ],
    },
    "Primary Chat Model": {
      ai_languageModel: [
        [
          {
            node: "Basic LLM Chain (Primary)",
            type: "ai_languageModel",
            index: 0,
          },
        ],
      ],
    },
    "Structured Output Parser": {
      outputParser: [
        [
          {
            node: "Basic LLM Chain (Primary)",
            type: "outputParser",
            index: 0,
          },
        ],
      ],
    },
  };

  if (configureFallback && fallbackConfig) {
    console.log("Configuring error handling and fallback route...");

    const checkErrorNode = {
      parameters: {
        conditions: {
          boolean: [
            {
              value1: "={{ $json.hasOwnProperty('error') }}",
              value2: true,
            },
          ],
        },
      },
      id: "w3-check-error-id",
      name: "Check Primary Error",
      type: "n8n-nodes-base.if",
      typeVersion: 2.2,
      position: [680, 200],
    };

    const fallbackChainNode = {
      parameters: {
        promptType: "Define below",
        text: "={{ $('Execute Workflow Trigger').item.json.text }}",
        systemMessage: "You are an AI recruitment assistant. Analyze the candidate's CV text. You MUST respond with a raw JSON object containing exactly these four keys:\n- summary: a brief profile summary.\n- classification: 'Qualified', 'Unqualified', or 'Review'.\n- suggestions: an array of recommendations for next steps.\n- riskLevel: 'Low', 'Medium', or 'High'.\n\nDo not include markdown code blocks or any text outside the JSON.",
      },
      id: "w3-chain-fallback-id",
      name: "Basic LLM Chain (Fallback)",
      type: "@n8n/n8n-nodes-langchain.chainLlm",
      typeVersion: 1.4,
      position: [900, 400],
    };

    const fallbackModelNode = {
      parameters: fallbackConfig.nodeParameters,
      id: "w3-model-fallback-id",
      name: "Fallback Chat Model",
      type: fallbackConfig.nodeType,
      typeVersion: 1,
      position: [900, 580],
      credentials: {
        [fallbackConfig.credentialType]: {
          id: fallbackCredId,
          name: "Semillero2_Fallback_Model",
        },
      },
    };

    const parserFallbackNode = {
      parameters: {
        jsonSchema: "{\n  \"type\": \"object\",\n  \"properties\": {\n    \"summary\": {\n      \"type\": \"string\"\n    },\n    \"classification\": {\n      \"type\": \"string\",\n      \"enum\": [\"Qualified\", \"Unqualified\", \"Review\"]\n    },\n    \"suggestions\": {\n      \"type\": \"array\",\n      \"items\": {\n        \"type\": \"string\"\n      }\n    },\n    \"riskLevel\": {\n      \"type\": \"string\",\n      \"enum\": [\"Low\", \"Medium\", \"High\"]\n    }\n  },\n  \"required\": [\"summary\", \"classification\", \"suggestions\", \"riskLevel\"]\n}",
      },
      id: "w3-parser-fallback-id",
      name: "Structured Output Parser (Fallback)",
      type: "@n8n/n8n-nodes-langchain.outputParserStructured",
      typeVersion: 1,
      position: [1050, 580],
    };

    const parseFallbackNode = {
      parameters: {
        jsCode: `return [{
  json: {
    name: $('Execute Workflow Trigger').item.json.name || "Unknown Candidate",
    email: $('Execute Workflow Trigger').item.json.email || "unknown@example.com",
    summary: $input.first().json.summary,
    seniority: $input.first().json.classification
  }
}];`,
      },
      id: "w3-parse-fallback-id",
      name: "Parse Fallback Response",
      type: "n8n-nodes-base.code",
      typeVersion: 2,
      position: [1120, 400],
    };

    w3Nodes.push(checkErrorNode, parsePrimaryNode, fallbackChainNode, fallbackModelNode, parserFallbackNode, parseFallbackNode);

    // Wire fallback connections
    w3Connections["Basic LLM Chain (Primary)"] = {
      main: [
        [
          {
            node: "Check Primary Error",
            type: "main",
            index: 0,
          },
        ],
      ],
    };

    w3Connections["Check Primary Error"] = {
      main: [
        [
          {
            node: "Basic LLM Chain (Fallback)",
            type: "main",
            index: 0,
          },
        ], // Output 0 (true -> Error happened)
        [
          {
            node: "Parse Primary Response",
            type: "main",
            index: 0,
          },
        ], // Output 1 (false -> Success)
      ],
    };

    w3Connections["Fallback Chat Model"] = {
      ai_languageModel: [
        [
          {
            node: "Basic LLM Chain (Fallback)",
            type: "ai_languageModel",
            index: 0,
          },
        ],
      ],
    };

    w3Connections["Structured Output Parser (Fallback)"] = {
      outputParser: [
        [
          {
            node: "Basic LLM Chain (Fallback)",
            type: "outputParser",
            index: 0,
          },
        ],
      ],
    };

    w3Connections["Basic LLM Chain (Fallback)"] = {
      main: [
        [
          {
            node: "Parse Fallback Response",
            type: "main",
            index: 0,
          },
        ],
      ],
    };

    w3Connections["Parse Primary Response"] = {
      main: [
        [
          {
            node: "Insert Candidate to Supabase",
            type: "main",
            index: 0,
          },
        ],
      ],
    };

    w3Connections["Parse Fallback Response"] = {
      main: [
        [
          {
            node: "Insert Candidate to Supabase",
            type: "main",
            index: 0,
          },
        ],
      ],
    };
  } else {
    // If no fallback, wire directly Primary Chain -> Parse Primary Response -> Supabase
    w3Nodes.push(parsePrimaryNode);
    w3Connections["Basic LLM Chain (Primary)"] = {
      main: [
        [
          {
            node: "Parse Primary Response",
            type: "main",
            index: 0,
          },
        ],
      ],
    };
    w3Connections["Parse Primary Response"] = {
      main: [
        [
          {
            node: "Insert Candidate to Supabase",
            type: "main",
            index: 0,
          },
        ],
      ],
    };
  }

  // 5. Deploy Workflow 3
  console.log("\nDeploying Workflow 3: Core AI Parsing Sub-workflow...");
  const workflow3Definition = {
    name: "Semillero2: Core AI Parsing Sub-workflow",
    settings: {},
    nodes: w3Nodes,
    connections: w3Connections,
  };

  const w3Result = await n8nRequest("/api/v1/workflows", "POST", workflow3Definition);
  const w3Id = w3Result.id;
  console.log(`Workflow 3 deployed successfully (ID: ${w3Id})`);

  // 6. Define Workflow 1: The API Gateway (Web UI Ingestion)
  console.log("Deploying Workflow 1: The API Gateway...");
  const workflow1Definition = {
    name: "Semillero2: API Gateway (Web UI Ingestion)",
    settings: {},
    nodes: [
      {
        parameters: {
          path: "parse-cv",
          options: {},
        },
        id: "w1-webhook-id",
        name: "Webhook",
        type: "n8n-nodes-base.webhook",
        typeVersion: 1,
        position: [100, 300],
      },
      {
        parameters: {
          jsCode: `return $input.first().json.body.candidates.map(c => ({ json: c }));`,
        },
        id: "w1-extract-id",
        name: "Extract Candidates Array",
        type: "n8n-nodes-base.code",
        typeVersion: 2,
        position: [320, 300],
      },
      {
        parameters: {
          batchSize: 1,
          options: {},
        },
        id: "w1-loop-id",
        name: "Loop Over Candidates",
        type: "n8n-nodes-base.splitInBatches",
        typeVersion: 3,
        position: [540, 300],
      },
      {
        parameters: {
          workflowId: w3Id,
          options: {},
        },
        id: "w1-exec-id",
        name: "Execute Workflow 3",
        type: "n8n-nodes-base.executeWorkflow",
        typeVersion: 1,
        position: [760, 200],
      },
    ],
    connections: {
      Webhook: {
        main: [
          [
            {
              node: "Extract Candidates Array",
              type: "main",
              index: 0,
            },
          ],
        ],
      },
      "Extract Candidates Array": {
        main: [
          [
            {
              node: "Loop Over Candidates",
              type: "main",
              index: 0,
            },
          ],
        ],
      },
      "Loop Over Candidates": {
        main: [
          [], // Output 0 (Done)
          [
            {
              node: "Execute Workflow 3",
              type: "main",
              index: 0,
            },
          ], // Output 1 (Loop)
        ],
      },
      "Execute Workflow 3": {
        main: [
          [
            {
              node: "Loop Over Candidates",
              type: "main",
              index: 0,
            },
          ],
        ],
      },
    },
  };

  const w1Result = await n8nRequest("/api/v1/workflows", "POST", workflow1Definition);
  const w1Id = w1Result.id;
  const webhookPath = `${N8N_HOST}/webhook/${w1Id}/webhook/parse-cv`;
  console.log(`Workflow 1 deployed successfully (ID: ${w1Id})`);
  console.log(`Webhook URL: ${webhookPath}`);

  // 7. Define Workflow 2: Email Ingestion Listener
  console.log("Deploying Workflow 2: Email Ingestion Listener...");
  const workflow2Definition = {
    name: "Semillero2: Email Ingestion Listener",
    settings: {},
    nodes: [
      {
        parameters: {
          postProcessAction: "markAsRead",
          format: "resolved",
          downloadAttachments: true,
          options: {
            customEmailConfig: '["UNSEEN"]',
          },
        },
        id: "w2-imap-id",
        name: "Email Trigger (IMAP)",
        type: "n8n-nodes-base.emailReadImap",
        typeVersion: 2,
        position: [100, 300],
        credentials: {
          imap: {
            id: imapCredId,
            name: "Semillero2_IMAP",
          },
        },
      },
      {
        parameters: {
          operation: "pdf",
          binaryPropertyName: "attachment_0",
        },
        id: "w2-extract-id",
        name: "Extract From PDF",
        type: "n8n-nodes-base.extractFromFile",
        typeVersion: 1,
        position: [320, 300],
      },
      {
        parameters: {
          jsCode: `const item = $input.first().json;
const text = item.text || "";
const emailBody = $('Email Trigger (IMAP)').item.json.textHtml || $('Email Trigger (IMAP)').item.json.text || "";
const fromEmail = $('Email Trigger (IMAP)').item.json.from.value[0].address;
const fromName = $('Email Trigger (IMAP)').item.json.from.value[0].name || fromEmail.split('@')[0];
return [{
  json: {
    name: fromName,
    email: fromEmail,
    text: \`Email Body:\\n\${emailBody}\\n\\nResume Text:\\n\${text}\`
  }
}];`,
        },
        id: "w2-format-id",
        name: "Format Email Data",
        type: "n8n-nodes-base.code",
        typeVersion: 2,
        position: [540, 300],
      },
      {
        parameters: {
          workflowId: w3Id,
          options: {},
        },
        id: "w2-exec-id",
        name: "Execute Workflow 3",
        type: "n8n-nodes-base.executeWorkflow",
        typeVersion: 1,
        position: [760, 300],
      },
    ],
    connections: {
      "Email Trigger (IMAP)": {
        main: [
          [
            {
              node: "Extract From PDF",
              type: "main",
              index: 0,
            },
          ],
        ],
      },
      "Extract From PDF": {
        main: [
          [
            {
              node: "Format Email Data",
              type: "main",
              index: 0,
            },
          ],
        ],
      },
      "Format Email Data": {
        main: [
          [
            {
              node: "Execute Workflow 3",
              type: "main",
              index: 0,
            },
          ],
        ],
      },
    },
  };

  const w2Result = await n8nRequest("/api/v1/workflows", "POST", workflow2Definition);
  console.log(`Workflow 2 deployed successfully (ID: ${w2Result.id})`);

  console.log("\n==================================================");
  console.log("KICKSTART SETUP COMPLETE.");
  console.log("==================================================");
  console.log("Use the following curl command to test the API Gateway directly:");
  console.log(`curl -X POST -H "Content-Type: application/json" \\
  -d '{"source": "web", "candidates": [{"name": "Jane Developer", "email": "jane.dev@example.com", "text": "Jane is a Senior Frontend Engineer with 8 years of experience in React, Next.js, and TypeScript. Extremely qualified."}]}' \\
  "${webhookPath}"`);
  console.log("==================================================");
}

main().catch((err) => {
  console.error("Kickstart script failed:", err);
  process.exit(1);
});