import { randomUUID } from "node:crypto";
import {
  BaselineClient,
  BaselineClientError,
  BaselineTimeoutError,
  type CommitRequest,
  type ExecuteRequest,
} from "@baseline-labs/sdk";

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;
}

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 createAllowedExecuteRequest(sessionId: string): ExecuteRequest {
  return {
    requestId: `req_sdk_execute_${randomUUID()}`,
    agent: {
      id: "sdk-direct-agent",
      framework: "custom-runtime",
      version: "0.1.0",
    },
    session: {
      id: sessionId,
      conversationId: `conv_${sessionId}`,
      userId: "sdk-user@admissible",
    },
    environment: {
      name: "staging",
      service: "release-control",
      region: "ord",
    },
    action: {
      type: "tool_call",
      name: "read.file",
      description: "Inspect the staged release manifest before proposing a change.",
      input: {
        path: "releases/staging.json",
        targetEnvironment: "staging",
      },
      target: {
        system: "release-control",
        resourceType: "environment",
        resourceId: "staging",
      },
    },
    intent: {
      goal: "Inspect release state safely before proposing a durable change.",
      task: "Read the current staging release manifest.",
      operator: "sdk-user@admissible",
    },
    constraints: {
      mode: "enforce",
      maxRiskScore: 0.4,
      allowModification: false,
      allowDeferral: true,
      approvalMode: "auto",
    },
    metadata: {
      source: "sdk-sandbox-quickstart",
      context: {
        lane: "direct-sdk",
      },
    },
  };
}

function createDeniedCommitRequest(
  sessionId: string,
  supportingOperationId: string,
): CommitRequest {
  return {
    requestId: `req_sdk_commit_${randomUUID()}`,
    agent: {
      id: "sdk-direct-agent",
      framework: "custom-runtime",
      version: "0.1.0",
    },
    session: {
      id: sessionId,
      conversationId: `conv_${sessionId}`,
      userId: "sdk-user@admissible",
    },
    proposedCommit: {
      type: "finalize_release_snapshot",
      system: "production",
      payload: {
        targetEnvironment: "production",
        migration: "users_v3_backfill",
      },
    },
    commitType: "irreversible",
    supportingOperationId,
    rollbackRef: "irreversible:none",
    artifact: {
      id: `artifact_${randomUUID()}`,
      type: "release_record",
    },
  };
}

function readNestedErrorDetails(error: BaselineClientError): Record<string, unknown> | undefined {
  if (typeof error.data !== "object" || error.data === null) {
    return undefined;
  }

  const root = error.data as Record<string, unknown>;
  if (typeof root.details === "object" && root.details !== null) {
    return root.details as Record<string, unknown>;
  }

  if (typeof root.error === "object" && root.error !== null) {
    const nested = root.error as Record<string, unknown>;
    if (typeof nested.details === "object" && nested.details !== null) {
      return nested.details as Record<string, unknown>;
    }
  }

  return undefined;
}

function printDirectSdkError(error: BaselineClientError): void {
  console.log("\n=== ADMISSIBLE INTERVENTION ===");
  console.log(`Status: ${error.status}`);
  console.log(`Code: ${error.code ?? "unknown"}`);
  console.log(`Message: ${error.message}`);

  const details = readNestedErrorDetails(error);
  if (!details) {
    return;
  }

  console.log("Details:");
  for (const [key, value] of Object.entries(details)) {
    console.log(`- ${key}: ${typeof value === "string" ? value : JSON.stringify(value)}`);
  }
}

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

  console.log("=== DIRECT SDK QUICKSTART ===");
  console.log(
    "This script sends direct execute and commit requests through the hosted Admissible API.",
  );

  printUsage(await getSandboxUsage(baseUrl, apiKey));

  const client = new BaselineClient({
    baseUrl,
    apiKey,
    userAgent: "admissible-sdk-quickstart",
  });

  const sessionId = `sess_sdk_direct_${randomUUID()}`;
  const executeResponse = await client.execute(createAllowedExecuteRequest(sessionId));

  console.log("\n=== ALLOWED EXECUTE ===");
  console.log(`Status: ${executeResponse.status}`);
  console.log(`Result: ${executeResponse.result}`);
  console.log(`Message: ${executeResponse.message}`);
  console.log(`Next Action: ${executeResponse.nextAction.type}`);
  console.log(`Operation: ${executeResponse.operation.id}`);

  try {
    const commitResponse = await client.commit(
      createDeniedCommitRequest(sessionId, executeResponse.operation.id),
      {
        idempotencyKey: `idem_${randomUUID()}`,
      },
    );

    const blocked =
      commitResponse.nextAction.type !== "proceed" &&
      commitResponse.nextAction.type !== "check_status";

    console.log(blocked ? "\n=== ADMISSIBLE INTERVENTION ===" : "\n=== COMMIT RESPONSE ===");
    console.log(`Status: ${commitResponse.status}`);
    console.log(`Result: ${commitResponse.result}`);
    console.log(`Message: ${commitResponse.message}`);
    console.log(`Next Action: ${commitResponse.nextAction.type}`);
    console.log(`Operation: ${commitResponse.operation.id}`);

    if (blocked) {
      printUsage(await getSandboxUsage(baseUrl, apiKey));
      return;
    }
  } catch (error) {
    if (error instanceof BaselineClientError) {
      printDirectSdkError(error);
      printUsage(await getSandboxUsage(baseUrl, apiKey));
      return;
    }

    throw error;
  }

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

main().catch((error) => {
  if (error instanceof BaselineTimeoutError) {
    console.log("\n=== SDK TIMEOUT ===");
    console.log(error.message);
    process.exit(1);
    return;
  }

  if (error instanceof BaselineClientError) {
    printDirectSdkError(error);
    process.exit(1);
    return;
  }

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

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