import {
  generateRegistrationOptions,
  verifyRegistrationResponse,
} from 'ts-auth'

// Generate registration options
const options = generateRegistrationOptions({
  rpName: 'My App',
  rpID: 'example.com',
  userID: 'user-123',
  userName: 'john@example.com',
  userDisplayName: 'John Doe',
  authenticatorSelection: {
    authenticatorAttachment: 'platform',
    userVerification: 'preferred',
  },
})

// Send `options` to the browser...

// After receiving the response from the browser:
const verification = await verifyRegistrationResponse(
  credential,
  expectedChallenge,
  'https://example.com',
  'example.com',
)

if (verification.verified) {
  // Store verification.registrationInfo.credential in your database
}

import {
  startRegistration,
  browserSupportsWebAuthn,
  platformAuthenticatorIsAvailable,
} from 'ts-auth'

// Check for WebAuthn support
if (!browserSupportsWebAuthn()) {
  console.log('WebAuthn is not supported')
}

// Check for platform authenticator (Face ID, Touch ID, Windows Hello)
if (await platformAuthenticatorIsAvailable()) {
  console.log('Platform authenticator available')
}

// Start registration with options from your server
const credential = await startRegistration(optionsFromServer)

// Send credential to your server for verification

import {
  generateAuthenticationOptions,
  verifyAuthenticationResponse,
} from 'ts-auth'

// Generate authentication options
const options = generateAuthenticationOptions({
  rpID: 'example.com',
  allowCredentials: [{
    id: storedCredentialId,
    type: 'public-key',
  }],
})

// After receiving the response from the browser:
const verification = await verifyAuthenticationResponse(
  credential,
  expectedChallenge,
  'https://example.com',
  'example.com',
  storedPublicKey,
  storedCounter,
)

if (verification.verified) {
  // Update the stored counter with verification.authenticationInfo.newCounter
}

import {
  generateTOTPSecret,
  generateTOTP,
  verifyTOTP,
  totpKeyUri,
} from 'ts-auth'

// Generate a secret for the user
const secret = generateTOTPSecret()

// Generate the otpauth:// URI for QR codes
const uri = totpKeyUri('user@example.com', 'MyApp', secret)

// Generate a TOTP code (for testing/display)
const code = generateTOTP({ secret })

// Verify a code submitted by the user
const isValid = verifyTOTP(userSubmittedCode, {
  secret,
  window: 1, // Allow 1 step before/after for clock drift
})

import {
  generateQRCodeSVG,
  generateQRCodeDataURL,
  QRErrorCorrection,
  totpKeyUri,
} from 'ts-auth'

// Generate a QR code for TOTP setup
const uri = totpKeyUri('user@example.com', 'MyApp', secret)

// Generate as SVG (browser environment)
const svg = generateQRCodeSVG({
  text: uri,
  width: 256,
  height: 256,
  correctLevel: QRErrorCorrection.H,
})

// Generate as data URL for <img> tags
const dataUrl = await generateQRCodeDataURL({
  text: uri,
  width: 256,
  height: 256,
})

// === SERVER SIDE ===
import {
  generateRegistrationOptions,
  generateAuthenticationOptions,
  verifyRegistrationResponse,
  verifyAuthenticationResponse,
} from 'ts-auth'

// Store for demo purposes (use a real database in production)
const userCredentials = new Map()
const challenges = new Map()

// 1. Registration: Generate options
function handleRegistrationStart(userId: string, userName: string) {
  const options = generateRegistrationOptions({
    rpName: 'My Application',
    rpID: 'example.com',
    userID: userId,
    userName: userName,
  })

  // Store challenge for verification
  challenges.set(userId, options.challenge)

  return options
}

// 2. Registration: Verify response
async function handleRegistrationFinish(userId: string, credential: any) {
  const expectedChallenge = challenges.get(userId)

  const verification = await verifyRegistrationResponse(
    credential,
    expectedChallenge,
    'https://example.com',
    'example.com',
  )

  if (verification.verified && verification.registrationInfo) {
    // Store credential for future authentication
    userCredentials.set(userId, {
      credentialId: verification.registrationInfo.credential.id,
      publicKey: verification.registrationInfo.credential.publicKey,
      counter: verification.registrationInfo.credential.counter,
    })

    return { success: true }
  }

  return { success: false }
}

// 3. Authentication: Generate options
function handleAuthenticationStart(userId: string) {
  const stored = userCredentials.get(userId)

  const options = generateAuthenticationOptions({
    rpID: 'example.com',
    allowCredentials: stored ? [{
      id: stored.credentialId,
      type: 'public-key',
    }] : [],
  })

  challenges.set(userId, options.challenge)

  return options
}

// 4. Authentication: Verify response
async function handleAuthenticationFinish(userId: string, credential: any) {
  const stored = userCredentials.get(userId)
  const expectedChallenge = challenges.get(userId)

  const verification = await verifyAuthenticationResponse(
    credential,
    expectedChallenge,
    'https://example.com',
    'example.com',
    stored.publicKey,
    stored.counter,
  )

  if (verification.verified) {
    // Update counter
    stored.counter = verification.authenticationInfo!.newCounter
    userCredentials.set(userId, stored)

    return { success: true }
  }

  return { success: false }
}

// === BROWSER SIDE ===
import { startRegistration, startAuthentication } from 'ts-auth'

// Registration
async function register() {
  // Get options from server
  const options = await fetch('/api/register/start').then(r => r.json())

  // Create credential
  const credential = await startRegistration(options)

  // Send to server for verification
  await fetch('/api/register/finish', {
    method: 'POST',
    body: JSON.stringify(credential),
  })
}

// Authentication
async function login() {
  // Get options from server
  const options = await fetch('/api/auth/start').then(r => r.json())

  // Get credential
  const credential = await startAuthentication(options)

  // Send to server for verification
  await fetch('/api/auth/finish', {
    method: 'POST',
    body: JSON.stringify(credential),
  })
}

import type {
  // Configuration
  AuthConfig,
  AuthOptions,

  // TOTP
  TOTPOptions,

  // WebAuthn
  RegistrationOptions,
  AuthenticationOptions,
  RegistrationCredential,
  AuthenticationCredential,
  PublicKeyCredentialCreationOptions,
  PublicKeyCredentialRequestOptions,

  // QR Code
  QRCodeOptions,
} from 'ts-auth'

import type { AuthOptions } from 'ts-auth'

const config: AuthOptions = {
  verbose: true, // Enable verbose logging
}

export default config