import { randomUUID } from "node:crypto";
import OpenAI from "openai";
import {
  BaselineIntegrationError,
  authorityPresets,
  createBaselineOpenAI,
  defineBaselineTool,
} from "@baseline-labs/adapter-openai";

interface SandboxUsageResponse {
  usage: {
    executeUsed: number;
    executeRemaining: number;
    commitUsed: number;
    commitRemaining: number;
    runtimeSubmitsUsed?: number;
    runtimeSubmitsRemaining?: number;
    recentSubmits5m?: number;
    recentSubmits5mRemaining?: number;
    activeRuns: number;
  };
  credential: {
    credentialId: string;
    expiresAt: string;
  } | null;
}

interface ToolExecutionRecord {
  toolName?: string;
  execute?: {
    decision?: string;
    reason?: string;
    audit?: {
      explanationCode?: string;
    };
  };
  commit?: {
    decision?: string;
    reason?: string;
    audit?: {
      explanationCode?: string;
    };
  };
}

function requireEnv(name: string, fallbackName?: string): string {
  const value =
    process.env[name]?.trim() ||
    (fallbackName ? process.env[fallbackName]?.trim() : "");
  if (!value) {
    const fallbackHint = fallbackName
      ? ` ${fallbackName} is also accepted for existing setups.`
      : "";
    throw new Error(`Set ${name} before running this quickstart.${fallbackHint}`);
  }

  return value;
}

function normalizeBaseUrl(baseUrl: string): string {
  const normalized = baseUrl.replace(/\/+$/, "");
  return normalized.replace(/\/v[12]$/, "");
}

async function getSandboxUsage(
  baseUrl: string,
  apiKey: string,
): Promise<SandboxUsageResponse | undefined> {
  const response = await fetch(`${baseUrl}/v1/sandbox/usage`, {
    headers: {
      Accept: "application/json",
      Authorization: `Bearer ${apiKey}`,
    },
  }).catch(() => undefined);

  if (!response?.ok) {
    return undefined;
  }

  return (await response.json()) as SandboxUsageResponse;
}

function printUsage(usage: SandboxUsageResponse | undefined): void {
  if (!usage) {
    return;
  }

  console.log("\n=== ADMISSIBLE USAGE ===");
  if (
    typeof usage.usage.runtimeSubmitsUsed === "number" &&
    typeof usage.usage.runtimeSubmitsRemaining === "number"
  ) {
    console.log(
      `Runtime requests: ${usage.usage.runtimeSubmitsUsed} used / ${usage.usage.runtimeSubmitsRemaining} remaining`,
    );
  } else {
    console.log(
      `Execute: ${usage.usage.executeUsed} used / ${usage.usage.executeRemaining} remaining`,
    );
    console.log(
      `Commit: ${usage.usage.commitUsed} used / ${usage.usage.commitRemaining} remaining`,
    );
  }

  if (
    typeof usage.usage.recentSubmits5m === "number" &&
    typeof usage.usage.recentSubmits5mRemaining === "number"
  ) {
    console.log(
      `5-minute window: ${usage.usage.recentSubmits5m} used / ${usage.usage.recentSubmits5mRemaining} remaining`,
    );
  }
  console.log(`Active runs: ${usage.usage.activeRuns}`);

  if (usage.credential) {
    console.log(`Credential ID: ${usage.credential.credentialId}`);
    console.log(`Credential expires at: ${usage.credential.expiresAt}`);
  }
}

function printToolExecutionHistory(executions: ToolExecutionRecord[] | undefined): void {
  console.log("\n=== TOOL EXECUTIONS ===");

  for (const execution of executions ?? []) {
    const explanationCode =
      execution.commit?.audit?.explanationCode ??
      execution.execute?.audit?.explanationCode ??
      "n/a";

    console.log(`\nTool: ${execution.toolName ?? "unknown"}`);
    console.log(`Execute decision: ${execution.execute?.decision ?? "n/a"}`);
    console.log(`Commit decision: ${execution.commit?.decision ?? "n/a"}`);
    console.log(
      `Reason: ${execution.commit?.reason ?? execution.execute?.reason ?? "n/a"}`,
    );
    console.log(`Code: ${explanationCode}`);
  }
}

const runId = randomUUID().replace(/-/g, "").slice(0, 10);

async function main(): Promise<void> {
  const baseUrl = normalizeBaseUrl(
    requireEnv("ADMISSIBLE_BASE_URL", "BASELINE_BASE_URL"),
  );
  const apiKey = requireEnv("ADMISSIBLE_API_KEY", "BASELINE_API_KEY");
  const openaiApiKey = requireEnv("OPENAI_API_KEY");

  console.log("=== OPENAI QUICKSTART ===");
  console.log(
    "This script sends a real OpenAI tool-calling run through the hosted Admissible API.",
  );

  printUsage(await getSandboxUsage(baseUrl, apiKey));

  const openai = new OpenAI({
    apiKey: openaiApiKey,
  });

  const stagingClient = createBaselineOpenAI({
    openai,
    baseline: {
      baseUrl,
      apiKey,
      authorityDefaults: {
        env: "staging",
        tenantId: "sandbox-quickstart",
      },
    },
    agentId: "sandbox-openai-example",
    sessionId: `sandbox-openai-staging-session-${runId}`,
    environmentName: "staging",
  });

  const productionClient = createBaselineOpenAI({
    openai,
    baseline: {
      baseUrl,
      apiKey,
      authorityDefaults: {
        env: "production",
        tenantId: "sandbox-quickstart",
      },
    },
    agentId: "sandbox-openai-example",
    sessionId: `sandbox-openai-production-session-${runId}`,
    environmentName: "production",
  });

  const readReleaseChecklist = defineBaselineTool({
    name: "readReleaseChecklist",
    description: "Read the staging release checklist before making changes.",
    authority: authorityPresets.readOnly,
    execute: async () => ({
      checklist: [
        "Review the migration plan.",
        "Verify rollback coverage.",
        "Confirm production blast radius.",
      ],
    }),
  });

  const runProductionSchemaMigration = defineBaselineTool({
    name: "runProductionSchemaMigration",
    description: "Apply an irreversible production schema migration.",
    authority: authorityPresets.irreversible,
    commit: {
      system: "production",
      payload: (input: { migration: string }) => ({
        migration: input.migration,
      }),
    },
    execute: async (input: { migration: string }) => ({
      accepted: true,
      migration: input.migration,
    }),
  });

  try {
    const response = await stagingClient.responses.create({
      model: "gpt-4.1",
      input:
        "You must call readReleaseChecklist exactly once before the production attempt. After the tool returns, summarize the checklist briefly.",
      tools: [readReleaseChecklist],
    });

    console.log("\n=== OPENAI RESULT ===");
    console.log(response.output_text ?? "(no text output)");

    await productionClient.responses.create({
      model: "gpt-4.1",
      input: "Call runProductionSchemaMigration with migration users_v3_backfill.",
      tools: [runProductionSchemaMigration],
      tool_choice: {
        type: "function",
        name: "runProductionSchemaMigration",
      },
    });

    printToolExecutionHistory([
      ...stagingClient.getToolExecutionHistory(),
      ...productionClient.getToolExecutionHistory(),
    ] as ToolExecutionRecord[]);
  } catch (error) {
    if (error instanceof BaselineIntegrationError) {
      console.log("\n=== ADMISSIBLE INTERVENTION ===");
      console.log(`Code: ${error.code ?? error.kind}`);
      console.log(`Tool: ${error.toolName ?? "unknown"}`);
      console.log(`Reason: ${error.reason}`);
      console.log(`Suggestion: ${error.suggestion ?? "none"}`);
      printToolExecutionHistory([
        ...stagingClient.getToolExecutionHistory(),
        ...productionClient.getToolExecutionHistory(),
      ] as ToolExecutionRecord[]);
      printUsage(await getSandboxUsage(baseUrl, apiKey));
      return;
    }

    throw error;
  }

  printUsage(await getSandboxUsage(baseUrl, apiKey));
}

main().catch((error) => {
  if (error instanceof Error) {
    console.log("\n=== QUICKSTART SETUP ===");
    console.log(error.message);
    process.exit(1);
    return;
  }

  console.error(error);
  process.exit(1);
});