function getAuthConfig(): AuthConfig

// Inline types — do not import from autodocs
interface AuthConfig {
  apiKey: string | null;
  email: string | null;
}

// Simulate the resolved auth config as getAuthConfig() would return it
function getAuthConfig(): AuthConfig {
  const envKey = process.env.SKRYPT_API_KEY;

  if (envKey) {
    // Mirrors real behavior: env var wins, email comes from auth file metadata
    return {
      apiKey: envKey,
      email: "dev@example.com",
    };
  }

  // Simulate auth file on disk
  const authFileExists = true;
  if (authFileExists) {
    return {
      apiKey: "sk_live_4f8a2b1c9d3e7f6a0b5c8d2e1f4a7b3c",
      email: "ada@example.com",
    };
  }

  return { apiKey: null, email: null };
}

try {
  // Set env var to simulate a CI/CD environment
  process.env.SKRYPT_API_KEY = "sk_live_9e2a1b4c7d0f3e6a8b5c2d1e4f7a0b3c";

  const auth = getAuthConfig();

  if (!auth.apiKey) {
    console.log("Not authenticated — run `skrypt login` or set SKRYPT_API_KEY");
    process.exit(1);
  }

  console.log("Authenticated as:", auth.email);
  console.log("API key (truncated):", auth.apiKey.slice(0, 12) + "...");
  // => Authenticated as: dev@example.com
  // => API key (truncated): sk_live_9e2a...
} catch (err) {
  console.error("Failed to read auth config:", err);
}

async function getAuthConfigAsync(): Promise<AuthConfig>

// Inline types — do not import from autodocs
interface AuthConfig {
  apiKey: string;
  email: string;
}

// Mock implementation matching the real resolution order:
// SKRYPT_API_KEY env var → keychain → auth file
async function getAuthConfigAsync(): Promise<AuthConfig> {
  const envKey = process.env.SKRYPT_API_KEY;

  if (envKey) {
    // Env var present — use it, pull email from auth file if available
    return { apiKey: envKey, email: "dev@example.com" };
  }

  // Simulate keychain / auth file fallback
  const storedConfig = { apiKey: "sk_live_9aB3xQr7mNpL2wKv", email: "ada@lovelace.io" };
  if (!storedConfig.apiKey) {
    throw new Error("Not authenticated. Run `skrypt login` to continue.");
  }

  return storedConfig;
}

async function generateDocs(sourcePath: string) {
  try {
    const auth: AuthConfig = await getAuthConfigAsync();

    console.log(`Authenticated as ${auth.email}`);

    const response = await fetch("https://api.skrypt.dev/v1/generate", {
      method: "POST",
      headers: {
        Authorization: `Bearer ${auth.apiKey}`,
        "Content-Type": "application/json",
      },
      body: JSON.stringify({ source: sourcePath }),
    });

    if (!response.ok) {
      throw new Error(`API error: ${response.status}`);
    }

    const result = await response.json();
    console.log("Docs generated:", result);
  } catch (err) {
    if (err instanceof Error && err.message.includes("Not authenticated")) {
      console.error("Run `skrypt login` first.");
    } else {
      throw err;
    }
  }
}

generateDocs("./src");
// Output:
// Authenticated as ada@lovelace.io
// Docs generated: { jobId: 'job_4Kx9mNpQ', status: 'queued', outputDir: './content/docs' }

async function saveAuthConfig(config: AuthConfig): Promise<void>

type AuthConfig = {
  apiKey?: string
  provider?: string
}

// Inline mock of saveAuthConfig to demonstrate the call pattern
// In real usage: this logic lives inside skrypt's auth module
async function saveAuthConfig(config: AuthConfig): Promise<void> {
  if (!config.apiKey) {
    throw new Error("apiKey is required to authenticate with an AI provider")
  }
  // Simulates writing to ~/.skrypt/config and attempting keychain storage
  console.log(`[mock] Storing config for provider: ${config.provider ?? "openai"}`)
  console.log(`[mock] API key stored in keychain: sk-...${config.apiKey.slice(-4)}`)
}

async function main() {
  const config: AuthConfig = {
    apiKey: "sk-proj-a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6q7r8s9t0",
    provider: "openai",
  }

  try {
    await saveAuthConfig(config)
    console.log("Auth config saved — run `skrypt generate ./src -o ./docs` to get started.")
  } catch (err) {
    console.error("Failed to save auth config:", (err as Error).message)
    process.exit(1)
  }
}

main()

// Expected output:
// [mock] Storing config for provider: openai
// [mock] API key stored in keychain: sk-...t0
// Auth config saved — run `skrypt generate ./src -o ./docs` to get started.

async function clearAuth(): Promise<void>

import { existsSync, writeFileSync, unlinkSync, mkdirSync } from 'fs'
import { join } from 'path'
import { homedir } from 'os'

// --- Inline mock of skrypt's auth system ---

const AUTH_FILE = join(homedir(), '.skrypt', 'auth.json')

async function keychainDelete(): Promise<void> {
  // Simulates removing the entry from the OS keychain
  console.log('[keychain] Deleted skrypt credentials from system keychain')
}

async function clearAuth(): Promise<void> {
  await keychainDelete()
  if (existsSync(AUTH_FILE)) {
    try {
      unlinkSync(AUTH_FILE)
      console.log(`[auth] Removed local auth file: ${AUTH_FILE}`)
    } catch (err) {
      console.warn('[auth] Could not remove local auth file:', err)
    }
  } else {
    console.log('[auth] No local auth file found — nothing to remove')
  }
}

// --- Simulate a signed-in state, then clear it ---

async function main() {
  // Set up a fake auth file to demonstrate clearance
  const authDir = join(homedir(), '.skrypt')
  mkdirSync(authDir, { recursive: true })
  writeFileSync(
    AUTH_FILE,
    JSON.stringify({ token: 'sk_live_abc123xyz', email: 'dev@example.com' }, null, 2),
    { mode: 0o600 }
  )
  console.log('Before clearAuth — auth file exists:', existsSync(AUTH_FILE))

  try {
    await clearAuth()
    console.log('After clearAuth  — auth file exists:', existsSync(AUTH_FILE))
    // Expected output:
    // Before clearAuth — auth file exists: true
    // [keychain] Deleted skrypt credentials from system keychain
    // [auth] Removed local auth file: /Users/you/.skrypt/auth.json
    // After clearAuth  — auth file exists: false
  } catch (err) {
    console.error('Failed to clear auth:', err)
  }
}

main()

async function getKeyStorageMethod(): Promise<'keychain' | 'file' | 'env' | 'none'>

type KeyStorageMethod = 'keychain' | 'file' | 'env' | 'none'

// Simulated implementations of the underlying storage checks
async function checkEnv(): Promise<boolean> {
  return !!process.env.SKRYPT_API_KEY
}

async function checkKeychain(): Promise<boolean> {
  // In production, this queries the OS keychain
  return false
}

async function checkFile(): Promise<boolean> {
  const fs = await import('fs')
  const path = await import('path')
  const os = await import('os')
  const authFile = path.join(os.homedir(), '.skrypt', 'auth.json')
  if (!fs.existsSync(authFile)) return false
  try {
    const data = JSON.parse(fs.readFileSync(authFile, 'utf8'))
    return !!data.apiKey
  } catch {
    return false
  }
}

async function getKeyStorageMethod(): Promise<KeyStorageMethod> {
  if (await checkEnv()) return 'env'
  if (await checkKeychain()) return 'keychain'
  if (await checkFile()) return 'file'
  return 'none'
}

const STATUS_MESSAGES: Record<KeyStorageMethod, string> = {
  env:      '✓ Authenticated via SKRYPT_API_KEY environment variable',
  keychain: '✓ Authenticated via system keychain',
  file:     '✓ Authenticated via credentials file (~/.skrypt/auth.json)',
  none:     '✗ Not authenticated — run `skrypt auth login` to get started',
}

async function printAuthStatus() {
  try {
    const method = await getKeyStorageMethod()
    console.log(STATUS_MESSAGES[method])

    if (method === 'none') {
      process.exit(1)
    }
  } catch (err) {
    console.error('Failed to check auth status:', err)
    process.exit(1)
  }
}

printAuthStatus()
// Example output (when SKRYPT_API_KEY is set):
// ✓ Authenticated via SKRYPT_API_KEY environment variable

async function checkPlan(apiKey: string): Promise<PlanCheckResponse>

const API_BASE = "https://api.skrypt.ai";

interface PlanCheckResponse {
  plan: "free" | "pro" | "enterprise";
  generationsUsed: number;
  generationsLimit: number;
  features: {
    multiLanguage: boolean;
    byTopic: boolean;
    customTemplates: boolean;
  };
}

async function checkPlan(apiKey: string): Promise<PlanCheckResponse> {
  const response = await fetch(`${API_BASE}/api/auth/plan`, {
    headers: {
      Authorization: `Bearer ${apiKey}`,
      "Content-Type": "application/json",
    },
  });

  if (!response.ok) {
    throw new Error(`Auth failed: ${response.status} ${response.statusText}`);
  }

  return response.json();
}

async function main() {
  const apiKey = "sk_live_4f8a2b1c9d3e7f6a0b5c8d2e1f4a7b3c";

  try {
    const plan = await checkPlan(apiKey);

    console.log(`Plan: ${plan.plan}`);
    console.log(`Generations: ${plan.generationsUsed} / ${plan.generationsLimit}`);
    console.log(`Multi-language support: ${plan.features.multiLanguage}`);

    if (plan.generationsUsed >= plan.generationsLimit) {
      console.log("Generation limit reached — upgrade your plan to continue.");
      return;
    }

    console.log("Key is valid. Ready to generate docs.");
    // Expected output:
    // Plan: pro
    // Generations: 42 / 500
    // Multi-language support: true
    // Key is valid. Ready to generate docs.
  } catch (err) {
    console.error("Could not verify API key:", (err as Error).message);
  }
}

main();

async function requirePro(commandName: string): Promise<boolean>

// Simulated keychain and license state
const mockLicense = {
  key: 'sk_pro_4f8a2b1c9d3e7f6a',
  plan: 'pro',
  email: 'ada@example.com',
}

// Inline mock of requirePro — mirrors real behavior without importing autodocs
async function validateLicense(licenseKey: string): Promise<{ valid: boolean; plan: string; email: string }> {
  // Simulate API validation
  if (licenseKey.startsWith('sk_pro_')) {
    return { valid: true, plan: 'pro', email: mockLicense.email }
  }
  return { valid: false, plan: 'free', email: '', error: 'Invalid license key' } as any
}

async function requirePro(commandName: string): Promise<boolean> {
  if (process.env.SKRYPT_DEV === '1') {
    return true
  }

  const storedKey = mockLicense.key // in production: retrieved from keychain
  if (!storedKey) {
    console.error(`✗ "${commandName}" requires a Pro license.`)
    console.error(`  Upgrade at https://skrypt.ai/pricing`)
    return false
  }

  const result = await validateLicense(storedKey)
  if (!result.valid || result.plan !== 'pro') {
    console.error(`✗ "${commandName}" requires a Pro license. You're on the ${result.plan} plan.`)
    console.error(`  Upgrade at https://skrypt.ai/pricing`)
    return false
  }

  return true
}

// Simulated "generate --multi-lang" command handler
async function generateMultiLang(source: string, output: string) {
  try {
    const allowed = await requirePro('generate --multi-lang')
    if (!allowed) {
      process.exitCode = 1
      return
    }

    // Pro-only logic runs here
    console.log(`✓ License verified for ada@example.com`)
    console.log(`Generating multi-language docs from ${source} → ${output}`)
    // => Generating multi-language docs from ./src → ./docs
  } catch (err) {
    console.error('Unexpected error:', err)
    process.exitCode = 1
  }
}

generateMultiLang('./src', './docs')