interface InitializeRequest {
  password: string // User's E2EE password
  deviceId?: string // Optional device ID (generated if not provided)
  deviceName?: string // Human-readable device name
  deviceLockPolicy?: {
    type: 'pin' | 'biometric' | 'pin_biometric' | 'none'
    pinLength?: 4 | 6 | 8
    biometricFallbackAllowed?: boolean
    timeoutMinutes?: number // Minutes until re-auth required
    wipeAfterFailedAttempts?: number // Default: 10
  }
}

interface InitializeResponse {
  success: boolean
  status: {
    initialized: boolean
    masterKeyInitialized: boolean
    deviceKeysGenerated: boolean
    deviceId: string
    registrationId: number
  }
  recoveryCode: string | null // Only returned on first setup
  deviceLockConfigured: boolean
  message: string
}

// src/app/api/e2ee/initialize/route.ts
import { NextRequest, NextResponse } from 'next/server'
import { getE2EEManager } from '@/lib/e2ee'
import { getApolloClient } from '@/lib/apollo-client'
import { rateLimit } from '@/lib/rate-limit'

export async function POST(request: NextRequest) {
  // Rate limiting: 5 attempts per 15 minutes
  const rateLimitResult = await rateLimit(request, {
    maxAttempts: 5,
    windowMs: 15 * 60 * 1000,
  })

  if (!rateLimitResult.success) {
    return NextResponse.json(
      { error: 'Too many attempts. Please try again later.' },
      { status: 429 }
    )
  }

  try {
    const body = await request.json()
    const { password, deviceId, deviceName, deviceLockPolicy } = body

    if (!password || password.length < 8) {
      return NextResponse.json({ error: 'Password must be at least 8 characters' }, { status: 400 })
    }

    const apolloClient = getApolloClient()
    const e2eeManager = getE2EEManager(apolloClient)

    // Initialize E2EE
    await e2eeManager.initialize(password, deviceId)

    // Configure device lock policy if provided
    if (deviceLockPolicy && deviceLockPolicy.type !== 'none') {
      await e2eeManager.configureDeviceLock(deviceLockPolicy)
    }

    const status = e2eeManager.getStatus()
    const recoveryCode = e2eeManager.getRecoveryCode()

    return NextResponse.json({
      success: true,
      status,
      recoveryCode,
      deviceLockConfigured: !!deviceLockPolicy,
      message: 'E2EE initialized successfully',
    })
  } catch (error: any) {
    console.error('E2EE initialization error:', error)
    return NextResponse.json(
      { error: 'Failed to initialize E2EE', message: error.message },
      { status: 500 }
    )
  }
}

interface ReplenishRequest {
  count?: number // Number of prekeys to generate (default: 50)
  deviceId?: string // Optional, uses current device if not provided
}

interface ReplenishResponse {
  success: boolean
  newPreKeyCount: number
  totalPreKeyCount: number
  message: string
}

interface RecoverRequest {
  recoveryCode: string // 12-word recovery code
  newPassword: string // New E2EE password
  deviceId?: string // New device ID
  deviceName?: string // Device name
}

interface RecoverResponse {
  success: boolean
  status: E2EEStatus
  newRecoveryCode: string | null // New recovery code if regenerated
  message: string
}

// GET /api/e2ee/safety-number/[userId]
// Query params:
interface SafetyNumberQuery {
  deviceId?: string // Specific device (defaults to primary)
  format?: 'numeric' | 'qr' | 'both'
}

interface SafetyNumberResponse {
  success: boolean
  safetyNumber: string // 60-digit number
  formattedSafetyNumber: string // "12345 67890 12345 ..."
  qrCodeData: string // QR-encodable string
  qrCodeSvg?: string // SVG for QR code display
  isVerified: boolean
  verifiedAt: string | null
  peerUserId: string
  peerDeviceId: string
}

interface DeviceLockVerifyRequest {
  type: 'pin' | 'biometric'
  pin?: string // Hashed PIN
  biometricToken?: string // Platform biometric token
  deviceId: string
}

interface DeviceLockVerifyResponse {
  success: boolean
  sessionToken: string // Short-lived token for E2EE operations
  expiresAt: string // Token expiration
  remainingAttempts?: number
  message: string
}

interface DeviceLockConfigureRequest {
  policy: {
    type: 'pin' | 'biometric' | 'pin_biometric' | 'none'
    pinLength?: 4 | 6 | 8
    biometricFallbackAllowed?: boolean
    requirePinInterval?: 'never' | 'daily' | 'weekly'
    timeoutMinutes?: number
    wipeAfterFailedAttempts?: number
  }
  currentPin?: string // Required if changing from PIN
  newPin?: string // Required if setting up PIN
}

interface DeviceLockConfigureResponse {
  success: boolean
  policy: DeviceLockPolicy
  message: string
}

interface DeviceLockWipeRequest {
  reason: 'failed_attempts' | 'user_request' | 'remote_wipe'
  deviceId: string
  preserveRecoveryOption?: boolean // Keep server-side backup
}

interface DeviceLockWipeResponse {
  success: boolean
  wipedData: string[] // List of data categories wiped
  recoveryPossible: boolean
  message: string
}

// src/lib/e2ee/signal-client.ts (Enhanced)

import * as SignalClient from '@signalapp/libsignal-client'
import { crypto } from './crypto'

// ============================================================================
// KEY GENERATION (Current implementation is correct)
// ============================================================================

/**
 * Generate a new identity key pair using Curve25519
 * This is the long-term device identity
 */
export async function generateIdentityKeyPair(): Promise<IdentityKeyPair> {
  const keyPair = SignalClient.IdentityKeyPair.generate()
  return {
    publicKey: keyPair.publicKey.serialize(),
    privateKey: keyPair.privateKey.serialize(),
  }
}

/**
 * Generate a signed prekey (medium-term, rotated weekly)
 * Signed with the identity key for authentication
 */
export async function generateSignedPreKey(
  identityKeyPair: IdentityKeyPair,
  signedPreKeyId: number
): Promise<SignedPreKeyPair> {
  const identityPrivateKey = SignalClient.PrivateKey.deserialize(
    Buffer.from(identityKeyPair.privateKey)
  )

  const keyPair = SignalClient.PrivateKey.generate()
  const publicKey = keyPair.getPublicKey()
  const signature = identityPrivateKey.sign(publicKey.serialize())

  return {
    keyId: signedPreKeyId,
    keyPair: {
      publicKey: publicKey.serialize(),
      privateKey: keyPair.serialize(),
    },
    signature,
  }
}

/**
 * Generate multiple one-time prekeys
 * These provide additional forward secrecy and are consumed once
 */
export async function generateOneTimePreKeys(
  startId: number,
  count: number
): Promise<PreKeyPair[]> {
  const preKeys: PreKeyPair[] = []

  for (let i = 0; i < count; i++) {
    const keyId = startId + i
    const privateKey = SignalClient.PrivateKey.generate()
    const publicKey = privateKey.getPublicKey()

    preKeys.push({
      keyId,
      publicKey: publicKey.serialize(),
      privateKey: privateKey.serialize(),
    })
  }

  return preKeys
}

// src/lib/e2ee/session-manager.ts (Enhanced)

/**
 * Create a new session with a peer using X3DH key agreement
 */
export async function createSession(peerUserId: string, peerDeviceId: string): Promise<void> {
  // 1. Fetch peer's prekey bundle from server
  const { data } = await apolloClient.query({
    query: GET_PREKEY_BUNDLE,
    variables: { userId: peerUserId, deviceId: peerDeviceId },
    fetchPolicy: 'network-only',
  })

  if (!data.nchat_prekey_bundles.length) {
    throw new Error('No prekey bundle available for peer')
  }

  const bundle = data.nchat_prekey_bundles[0]

  // 2. Build PreKeyBundle object
  const prekeyBundle = buildPreKeyBundle(bundle)

  // 3. Get local identity keys
  const deviceKeys = await keyManager.loadDeviceKeys(deviceId)
  if (!deviceKeys) {
    throw new Error('Local device keys not found')
  }

  // 4. Create protocol address for peer
  const remoteAddress = SignalClient.ProtocolAddress.new(peerUserId, parseInt(peerDeviceId, 10))

  // 5. Process prekey bundle (performs X3DH)
  await SignalClient.processPreKeyBundle(
    prekeyBundle,
    remoteAddress,
    sessionStore,
    identityKeyStore
  )

  // 6. Mark one-time prekey as consumed
  if (bundle.one_time_prekey_id) {
    await consumeOneTimePreKey(peerUserId, peerDeviceId, bundle.one_time_prekey_id)
  }

  // 7. Log session creation for audit
  await logE2EEEvent('session_created', {
    peerUserId,
    peerDeviceId,
    isInitiator: true,
  })
}

// src/lib/e2ee/message-encryption.ts (Enhanced)

/**
 * Encrypt a message for sending
 */
export async function encryptMessageForSending(
  plaintext: string,
  options: EncryptionOptions,
  apolloClient: ApolloClient<any>
): Promise<EncryptedMessagePayload> {
  const e2eeManager = getE2EEManager(apolloClient)

  if (!e2eeManager.isInitialized()) {
    throw new Error('E2EE not initialized')
  }

  // Get all recipient devices (for multi-device support)
  const recipientDevices = await getRecipientDevices(options.recipientUserId, apolloClient)

  // Encrypt for each device
  const encryptedPayloads: DeviceEncryptedPayload[] = []

  for (const device of recipientDevices) {
    const result = await e2eeManager.encryptMessage(
      plaintext,
      options.recipientUserId,
      device.deviceId
    )

    encryptedPayloads.push({
      deviceId: device.deviceId,
      encryptedPayload: result.encryptedPayload,
      messageType: result.type,
    })
  }

  return {
    senderDeviceId: e2eeManager.getDeviceId()!,
    encryptedPayloads,
    encryptionVersion: 1,
    timestamp: Date.now(),
  }
}

/**
 * Decrypt a received message
 */
export async function decryptReceivedMessage(
  message: EncryptedMessage,
  apolloClient: ApolloClient<any>
): Promise<string> {
  const e2eeManager = getE2EEManager(apolloClient)

  if (!e2eeManager.isInitialized()) {
    throw new Error('E2EE not initialized')
  }

  // Find the payload for our device
  const myDeviceId = e2eeManager.getDeviceId()
  const payload = message.encryptedPayloads.find((p) => p.deviceId === myDeviceId)

  if (!payload) {
    throw new Error('No encrypted payload for this device')
  }

  return await e2eeManager.decryptMessage(
    payload.encryptedPayload,
    payload.messageType,
    message.senderUserId,
    message.senderDeviceId
  )
}

// src/lib/e2ee/storage/secure-key-storage.ts

import { SecureStorage } from '@/lib/crypto/secure-storage'
import { Platform } from '@/lib/platform'

/**
 * Platform-aware secure key storage
 * - Web: IndexedDB with encryption
 * - iOS: Keychain via Capacitor SecureStorage
 * - Android: Keystore via Capacitor SecureStorage
 * - Desktop: OS keychain via Electron safeStorage
 */
export class SecureKeyStorage {
  private storage: SecureStorage
  private platform: Platform

  constructor() {
    this.platform = Platform.detect()
    this.storage = new SecureStorage({
      prefix: 'nchat_e2ee_',
      defaultEncrypt: true,
    })
  }

  async initialize(masterKey: Uint8Array): Promise<void> {
    if (this.platform.isNative()) {
      // Use native secure storage
      await this.initializeNativeStorage(masterKey)
    } else {
      // Use IndexedDB with Web Crypto
      await this.storage.initialize()
    }
  }

  async storeMasterKey(key: Uint8Array, salt: Uint8Array): Promise<void> {
    if (this.platform.isNative()) {
      await NativeSecureStorage.set('master_key', {
        key: Array.from(key),
        salt: Array.from(salt),
      })
    } else {
      // Never store master key in browser storage
      // Only keep in memory during session
      throw new Error('Master key should not be stored in browser')
    }
  }

  async storeDeviceKeys(deviceKeys: DeviceKeys): Promise<void> {
    const key = `device_keys_${deviceKeys.deviceId}`

    // Encrypt private keys before storage
    const encryptedKeys = await this.encryptDeviceKeys(deviceKeys)

    await this.storage.set(key, encryptedKeys)
  }

  async loadDeviceKeys(deviceId: string): Promise<DeviceKeys | null> {
    const key = `device_keys_${deviceId}`
    const encryptedKeys = await this.storage.get<EncryptedDeviceKeys>(key)

    if (!encryptedKeys) return null

    return await this.decryptDeviceKeys(encryptedKeys)
  }

  async storeSession(
    peerUserId: string,
    peerDeviceId: string,
    sessionState: Uint8Array
  ): Promise<void> {
    const key = `session_${peerUserId}_${peerDeviceId}`
    await this.storage.set(key, Array.from(sessionState))
  }

  async loadSession(peerUserId: string, peerDeviceId: string): Promise<Uint8Array | null> {
    const key = `session_${peerUserId}_${peerDeviceId}`
    const data = await this.storage.get<number[]>(key)
    return data ? new Uint8Array(data) : null
  }

  async clearAll(): Promise<void> {
    await this.storage.clearAll()
    if (this.platform.isNative()) {
      await NativeSecureStorage.clear()
    }
  }

  private async initializeNativeStorage(masterKey: Uint8Array): Promise<void> {
    // Platform-specific initialization
    if (this.platform.isIOS() || this.platform.isAndroid()) {
      // Capacitor SecureStorage plugin
      const { SecureStoragePlugin } = await import('@capacitor-community/secure-storage-plugin')
      await SecureStoragePlugin.set({
        key: 'e2ee_initialized',
        value: 'true',
      })
    } else if (this.platform.isElectron()) {
      // Electron safeStorage
      const { safeStorage } = require('electron')
      // Verify safeStorage is available
      if (!safeStorage.isEncryptionAvailable()) {
        throw new Error('Secure storage not available on this platform')
      }
    }
  }

  private async encryptDeviceKeys(keys: DeviceKeys): Promise<EncryptedDeviceKeys> {
    // Encrypt private keys with master key
    // Implementation uses AES-256-GCM
    return {
      deviceId: keys.deviceId,
      registrationId: keys.registrationId,
      identityKeyPublic: Array.from(keys.identityKeyPair.publicKey),
      identityKeyPrivateEncrypted: await this.encrypt(keys.identityKeyPair.privateKey),
      signedPreKeyPublic: Array.from(keys.signedPreKey.keyPair.publicKey),
      signedPreKeyPrivateEncrypted: await this.encrypt(keys.signedPreKey.keyPair.privateKey),
      signedPreKeySignature: Array.from(keys.signedPreKey.signature),
      signedPreKeyId: keys.signedPreKey.keyId,
      oneTimePreKeys: await Promise.all(
        keys.oneTimePreKeys.map(async (pk) => ({
          keyId: pk.keyId,
          publicKey: Array.from(pk.publicKey),
          privateKeyEncrypted: await this.encrypt(pk.privateKey),
        }))
      ),
    }
  }
}

export const secureKeyStorage = new SecureKeyStorage()

// src/lib/e2ee/device-lock/device-lock-manager.ts

export interface DeviceLockPolicy {
  type: 'pin' | 'biometric' | 'pin_biometric' | 'none'
  pinLength?: 4 | 6 | 8
  biometricFallbackAllowed: boolean
  requirePinInterval: 'never' | 'daily' | 'weekly'
  timeoutMinutes: number
  wipeAfterFailedAttempts: number
}

export class DeviceLockManager {
  private policy: DeviceLockPolicy | null = null
  private failedAttempts: number = 0
  private lastVerifiedAt: Date | null = null
  private lastPinVerifiedAt: Date | null = null
  private sessionToken: string | null = null
  private sessionExpiresAt: Date | null = null

  /**
   * Configure device lock policy
   */
  async configure(policy: DeviceLockPolicy, pin?: string): Promise<void> {
    // Validate policy
    this.validatePolicy(policy)

    // If PIN policy, hash and store PIN
    if (policy.type === 'pin' || policy.type === 'pin_biometric') {
      if (!pin) {
        throw new Error('PIN required for this policy type')
      }
      await this.hashAndStorePIN(pin, policy.pinLength || 6)
    }

    // If biometric, verify biometric capability
    if (policy.type === 'biometric' || policy.type === 'pin_biometric') {
      const biometricAvailable = await this.checkBiometricAvailability()
      if (!biometricAvailable && !policy.biometricFallbackAllowed) {
        throw new Error('Biometric not available on this device')
      }
    }

    // Store policy
    this.policy = policy
    await this.persistPolicy(policy)

    // Log configuration
    await this.logEvent('policy_configured', { type: policy.type })
  }

  /**
   * Verify device lock (PIN or biometric)
   */
  async verify(type: 'pin' | 'biometric', credential?: string): Promise<DeviceLockSession> {
    if (!this.policy) {
      throw new Error('No device lock policy configured')
    }

    // Check if locked out
    if (this.isLockedOut()) {
      throw new Error('Device is locked due to too many failed attempts')
    }

    // Check if session still valid
    if (this.hasValidSession()) {
      return this.getCurrentSession()!
    }

    // Determine if PIN is required
    const pinRequired = this.isPINRequired()

    if (type === 'pin') {
      if (!credential) {
        throw new Error('PIN is required')
      }
      await this.verifyPIN(credential)
    } else if (type === 'biometric') {
      if (pinRequired) {
        throw new Error('PIN verification required before biometric')
      }
      await this.verifyBiometric()
    }

    // Create session
    const session = await this.createSession(type)

    // Reset failed attempts
    this.failedAttempts = 0
    this.lastVerifiedAt = new Date()
    if (type === 'pin') {
      this.lastPinVerifiedAt = new Date()
    }

    // Log success
    await this.logEvent('verify_success', { method: type })

    return session
  }

  /**
   * Check if PIN verification is required based on policy
   */
  private isPINRequired(): boolean {
    if (!this.policy) return false
    if (this.policy.type === 'pin') return true
    if (this.policy.type !== 'pin_biometric') return false

    const interval = this.policy.requirePinInterval
    if (interval === 'never') return false
    if (!this.lastPinVerifiedAt) return true

    const now = new Date()
    const hoursSincePin = (now.getTime() - this.lastPinVerifiedAt.getTime()) / (1000 * 60 * 60)

    switch (interval) {
      case 'daily':
        return hoursSincePin >= 24
      case 'weekly':
        return hoursSincePin >= 168
      default:
        return false
    }
  }

  /**
   * Verify PIN against stored hash
   */
  private async verifyPIN(pin: string): Promise<void> {
    const storedHash = await this.getStoredPINHash()
    if (!storedHash) {
      throw new Error('No PIN configured')
    }

    const isValid = await this.verifyPINHash(pin, storedHash)
    if (!isValid) {
      this.failedAttempts++
      await this.logEvent('verify_failed', { method: 'pin', attempts: this.failedAttempts })

      if (this.failedAttempts >= this.policy!.wipeAfterFailedAttempts) {
        await this.wipeOnFailure()
        throw new Error('Too many failed attempts. Data has been wiped.')
      }

      throw new Error(
        `Invalid PIN. ${this.policy!.wipeAfterFailedAttempts - this.failedAttempts} attempts remaining.`
      )
    }
  }

  /**
   * Verify biometric authentication
   */
  private async verifyBiometric(): Promise<void> {
    const platform = Platform.detect()

    if (platform.isIOS() || platform.isAndroid()) {
      // Use Capacitor biometric plugin
      const { BiometricAuth } = await import('@aparajita/capacitor-biometric-auth')

      const result = await BiometricAuth.authenticate({
        reason: 'Verify identity to access encrypted messages',
        cancelTitle: 'Cancel',
        allowDeviceCredential: this.policy?.biometricFallbackAllowed ?? true,
      })

      if (!result.success) {
        this.failedAttempts++
        throw new Error('Biometric verification failed')
      }
    } else if (platform.isWeb()) {
      // Use WebAuthn if available
      if (!window.PublicKeyCredential) {
        throw new Error('Biometric not supported on this browser')
      }

      // WebAuthn implementation
      await this.performWebAuthn()
    }
  }

  /**
   * Wipe E2EE data after too many failed attempts
   */
  private async wipeOnFailure(): Promise<void> {
    await this.logEvent('wipe', { reason: 'failed_attempts' })

    // Clear all E2EE data
    const e2eeManager = getE2EEManager()
    e2eeManager.destroy()

    // Clear secure storage
    await secureKeyStorage.clearAll()

    // Clear device lock data
    this.policy = null
    this.failedAttempts = 0
    this.sessionToken = null

    // Notify user
    await this.notifyWipe()
  }

  /**
   * Create a short-lived session after successful verification
   */
  private async createSession(method: 'pin' | 'biometric'): Promise<DeviceLockSession> {
    const token = crypto.generateDeviceId() // Random 32 bytes
    const expiresAt = new Date(Date.now() + this.policy!.timeoutMinutes * 60 * 1000)

    this.sessionToken = token
    this.sessionExpiresAt = expiresAt

    // Store session in database
    await this.persistSession(token, method, expiresAt)

    return {
      token,
      expiresAt,
      method,
    }
  }

  /**
   * Check if device is currently locked out
   */
  private isLockedOut(): boolean {
    return this.failedAttempts >= (this.policy?.wipeAfterFailedAttempts ?? 10)
  }

  /**
   * Check if there's a valid session
   */
  private hasValidSession(): boolean {
    if (!this.sessionToken || !this.sessionExpiresAt) return false
    return new Date() < this.sessionExpiresAt
  }

  /**
   * Get current session if valid
   */
  private getCurrentSession(): DeviceLockSession | null {
    if (!this.hasValidSession()) return null
    return {
      token: this.sessionToken!,
      expiresAt: this.sessionExpiresAt!,
      method: 'cached',
    }
  }
}

export const deviceLockManager = new DeviceLockManager()

// Server-side encrypted backup implementation
interface KeyBackup {
  encryptedMasterKey: Uint8Array // Encrypted with recovery-derived key
  salt: Uint8Array
  iterations: number
  algorithm: string
  version: number
  createdAt: Date
}

async function createKeyBackup(masterKey: Uint8Array, recoveryCode: string): Promise<KeyBackup> {
  const salt = crypto.generateSalt()
  const recoveryKey = await crypto.deriveRecoveryKey(recoveryCode, salt)
  const { ciphertext, iv } = await crypto.encryptAESGCM(masterKey, recoveryKey)

  return {
    encryptedMasterKey: crypto.encodeEncryptedData(ciphertext, iv),
    salt,
    iterations: PBKDF2_ITERATIONS,
    algorithm: 'AES-256-GCM',
    version: 1,
    createdAt: new Date(),
  }
}

// Multi-device message flow
async function sendToAllDevices(
  recipientUserId: string,
  plaintext: string
): Promise<MultiDeviceMessage> {
  // Get all active devices for recipient
  const devices = await getRecipientDevices(recipientUserId)

  // Encrypt message for each device
  const payloads: DevicePayload[] = []

  for (const device of devices) {
    // Ensure session exists
    await ensureSession(recipientUserId, device.deviceId)

    // Encrypt for this device
    const encrypted = await encryptForDevice(plaintext, recipientUserId, device.deviceId)

    payloads.push({
      deviceId: device.deviceId,
      payload: encrypted,
    })
  }

  return {
    recipientUserId,
    payloads,
  }
}

// Non-sensitive metadata logging
interface E2EEAuditEvent {
  eventType:
    | 'e2ee_initialized'
    | 'keys_generated'
    | 'session_created'
    | 'session_refreshed'
    | 'message_encrypted'
    | 'message_decrypted'
    | 'prekeys_replenished'
    | 'signed_prekey_rotated'
    | 'safety_number_verified'
    | 'device_lock_verified'
    | 'device_lock_failed'
    | 'data_wiped'
  deviceId: string
  peerUserId?: string // For session events
  metadata: {
    messageCount?: number // Never content
    prekeyCount?: number
    verificationMethod?: string
    failedAttempts?: number
  }
  ipAddress: string
  userAgent: string
  timestamp: Date
}

// src/lib/platform/native-crypto.ts

import { Capacitor } from '@capacitor/core'
import { SecureStoragePlugin } from '@capacitor-community/secure-storage-plugin'
import { BiometricAuth } from '@aparajita/capacitor-biometric-auth'

export class NativeCrypto {
  /**
   * Store a key securely using platform keychain
   */
  static async storeKey(key: string, value: string): Promise<void> {
    if (Capacitor.isNativePlatform()) {
      await SecureStoragePlugin.set({ key, value })
    } else {
      // Web fallback - use IndexedDB with encryption
      await webSecureStorage.set(key, value)
    }
  }

  /**
   * Retrieve a key from platform keychain
   */
  static async getKey(key: string): Promise<string | null> {
    if (Capacitor.isNativePlatform()) {
      try {
        const result = await SecureStoragePlugin.get({ key })
        return result.value
      } catch {
        return null
      }
    } else {
      return webSecureStorage.get(key)
    }
  }

  /**
   * Check biometric availability
   */
  static async checkBiometric(): Promise<BiometricCapability> {
    if (Capacitor.isNativePlatform()) {
      const result = await BiometricAuth.checkBiometry()
      return {
        available: result.isAvailable,
        biometryType: result.biometryType,
        reason: result.reason,
      }
    }

    // Web: Check WebAuthn
    if (window.PublicKeyCredential) {
      const available = await PublicKeyCredential.isUserVerifyingPlatformAuthenticatorAvailable()
      return {
        available,
        biometryType: 'webauthn',
      }
    }

    return { available: false }
  }

  /**
   * Perform biometric authentication
   */
  static async authenticate(reason: string): Promise<boolean> {
    if (Capacitor.isNativePlatform()) {
      const result = await BiometricAuth.authenticate({
        reason,
        cancelTitle: 'Cancel',
        allowDeviceCredential: true,
      })
      return result.success
    }

    // Web: Use WebAuthn
    return this.webAuthnAuthenticate(reason)
  }
}

// src/lib/e2ee/__tests__/crypto.test.ts

describe('Cryptographic Operations', () => {
  describe('Key Derivation', () => {
    it('derives consistent master key from password', async () => {
      const password = 'test-password-123'
      const salt = crypto.generateSalt()

      const key1 = await crypto.deriveMasterKey(password, salt)
      const key2 = await crypto.deriveMasterKey(password, salt)

      expect(key1).toEqual(key2)
      expect(key1.length).toBe(32)
    })

    it('produces different keys with different salts', async () => {
      const password = 'test-password-123'
      const salt1 = crypto.generateSalt()
      const salt2 = crypto.generateSalt()

      const key1 = await crypto.deriveMasterKey(password, salt1)
      const key2 = await crypto.deriveMasterKey(password, salt2)

      expect(key1).not.toEqual(key2)
    })

    it('uses correct number of PBKDF2 iterations', async () => {
      // Verify timing is consistent with 100k iterations
      const password = 'test-password-123'
      const salt = crypto.generateSalt()

      const start = performance.now()
      await crypto.deriveMasterKey(password, salt)
      const duration = performance.now() - start

      // Should take at least 50ms with 100k iterations
      expect(duration).toBeGreaterThan(50)
    })
  })

  describe('Symmetric Encryption', () => {
    it('encrypts and decrypts correctly', async () => {
      const key = crypto.generateRandomBytes(32)
      const plaintext = new Uint8Array([1, 2, 3, 4, 5])

      const { ciphertext, iv } = await crypto.encryptAESGCM(plaintext, key)
      const decrypted = await crypto.decryptAESGCM(ciphertext, key, iv)

      expect(decrypted).toEqual(plaintext)
    })

    it('produces different ciphertext with same plaintext', async () => {
      const key = crypto.generateRandomBytes(32)
      const plaintext = new Uint8Array([1, 2, 3, 4, 5])

      const { ciphertext: ct1 } = await crypto.encryptAESGCM(plaintext, key)
      const { ciphertext: ct2 } = await crypto.encryptAESGCM(plaintext, key)

      expect(ct1).not.toEqual(ct2)
    })

    it('fails to decrypt with wrong key', async () => {
      const key1 = crypto.generateRandomBytes(32)
      const key2 = crypto.generateRandomBytes(32)
      const plaintext = new Uint8Array([1, 2, 3, 4, 5])

      const { ciphertext, iv } = await crypto.encryptAESGCM(plaintext, key1)

      await expect(crypto.decryptAESGCM(ciphertext, key2, iv)).rejects.toThrow()
    })
  })

  describe('Safety Number Generation', () => {
    it('generates 60-digit safety number', () => {
      const localKey = crypto.generateRandomBytes(32)
      const remoteKey = crypto.generateRandomBytes(32)

      const safetyNumber = crypto.generateSafetyNumber(localKey, 'user-1', remoteKey, 'user-2')

      expect(safetyNumber.replace(/\s/g, '')).toHaveLength(60)
      expect(safetyNumber.replace(/\s/g, '')).toMatch(/^\d+$/)
    })

    it('produces same number regardless of order', () => {
      const key1 = crypto.generateRandomBytes(32)
      const key2 = crypto.generateRandomBytes(32)

      const sn1 = crypto.generateSafetyNumber(key1, 'user-a', key2, 'user-b')
      const sn2 = crypto.generateSafetyNumber(key2, 'user-b', key1, 'user-a')

      expect(sn1).toEqual(sn2)
    })

    it('produces different numbers for different keys', () => {
      const key1 = crypto.generateRandomBytes(32)
      const key2 = crypto.generateRandomBytes(32)
      const key3 = crypto.generateRandomBytes(32)

      const sn1 = crypto.generateSafetyNumber(key1, 'user-a', key2, 'user-b')
      const sn2 = crypto.generateSafetyNumber(key1, 'user-a', key3, 'user-b')

      expect(sn1).not.toEqual(sn2)
    })
  })
})

// src/lib/e2ee/__tests__/key-exchange.test.ts

describe('X3DH Key Exchange', () => {
  let alice: TestUser
  let bob: TestUser

  beforeEach(async () => {
    alice = await createTestUser('alice')
    bob = await createTestUser('bob')
  })

  it('establishes session between two users', async () => {
    // Bob uploads prekey bundle
    await bob.e2eeManager.uploadDeviceKeys(bob.deviceKeys)

    // Alice initiates session
    await alice.sessionManager.createSession(bob.userId, bob.deviceId)

    // Verify session exists
    const hasSession = await alice.sessionManager.hasSession(bob.userId, bob.deviceId)
    expect(hasSession).toBe(true)
  })

  it('consumes one-time prekey on first message', async () => {
    const initialOPKCount = await bob.getOneTimePreKeyCount()

    await alice.sessionManager.createSession(bob.userId, bob.deviceId)

    const finalOPKCount = await bob.getOneTimePreKeyCount()
    expect(finalOPKCount).toBe(initialOPKCount - 1)
  })

  it('derives same shared secret on both sides', async () => {
    await alice.sessionManager.createSession(bob.userId, bob.deviceId)

    // Alice encrypts message
    const plaintext = 'Hello Bob!'
    const encrypted = await alice.sessionManager.encryptMessage(plaintext, bob.userId, bob.deviceId)

    // Bob decrypts (this establishes session on his side)
    const decrypted = await bob.sessionManager.decryptMessage(
      encrypted,
      alice.userId,
      alice.deviceId
    )

    expect(decrypted).toBe(plaintext)
  })

  it('works without one-time prekey', async () => {
    // Exhaust Bob's one-time prekeys
    await bob.exhaustOneTimePreKeys()

    // Alice should still be able to establish session
    await alice.sessionManager.createSession(bob.userId, bob.deviceId)

    const plaintext = 'Hello Bob!'
    const encrypted = await alice.sessionManager.encryptMessage(plaintext, bob.userId, bob.deviceId)
    const decrypted = await bob.sessionManager.decryptMessage(
      encrypted,
      alice.userId,
      alice.deviceId
    )

    expect(decrypted).toBe(plaintext)
  })
})

// e2e/e2ee/message-encryption.spec.ts

import { test, expect } from '@playwright/test'

test.describe('E2EE Message Flow', () => {
  test('sends and receives encrypted message', async ({ page, context }) => {
    // Create two browser contexts for Alice and Bob
    const alicePage = await context.newPage()
    const bobPage = await context.newPage()

    // Sign in as Alice
    await alicePage.goto('/auth/signin')
    await alicePage.fill('[name="email"]', '[email protected]')
    await alicePage.fill('[name="password"]', 'password123')
    await alicePage.click('button[type="submit"]')

    // Initialize E2EE for Alice
    await alicePage.goto('/settings/security')
    await alicePage.click('text=Enable End-to-End Encryption')
    await alicePage.fill('[name="e2eePassword"]', 'e2ee-password-alice')
    await alicePage.click('text=Initialize')

    // Save recovery code
    const aliceRecoveryCode = await alicePage.textContent('[data-testid="recovery-code"]')
    expect(aliceRecoveryCode).toBeTruthy()
    await alicePage.click('text=I saved my recovery code')

    // Sign in as Bob and initialize E2EE
    await bobPage.goto('/auth/signin')
    await bobPage.fill('[name="email"]', '[email protected]')
    await bobPage.fill('[name="password"]', 'password123')
    await bobPage.click('button[type="submit"]')

    await bobPage.goto('/settings/security')
    await bobPage.click('text=Enable End-to-End Encryption')
    await bobPage.fill('[name="e2eePassword"]', 'e2ee-password-bob')
    await bobPage.click('text=Initialize')
    await bobPage.click('text=I saved my recovery code')

    // Alice sends message to Bob
    await alicePage.goto('/chat/dm/bob')
    await alicePage.fill('[data-testid="message-input"]', 'Hello Bob! This is encrypted.')
    await alicePage.click('[data-testid="send-button"]')

    // Verify encryption indicator
    await expect(alicePage.locator('[data-testid="encryption-indicator"]')).toBeVisible()

    // Bob receives and decrypts message
    await bobPage.goto('/chat/dm/alice')
    await expect(bobPage.locator('text=Hello Bob! This is encrypted.')).toBeVisible()
    await expect(bobPage.locator('[data-testid="encryption-indicator"]')).toBeVisible()

    // Bob replies
    await bobPage.fill('[data-testid="message-input"]', 'Hi Alice! Got your encrypted message.')
    await bobPage.click('[data-testid="send-button"]')

    // Alice sees reply
    await expect(alicePage.locator('text=Hi Alice! Got your encrypted message.')).toBeVisible()
  })

  test('verifies safety numbers', async ({ page, context }) => {
    // Setup Alice and Bob with E2EE (abbreviated)
    // ...

    // Open safety number verification on Alice's side
    await alicePage.goto('/chat/dm/bob')
    await alicePage.click('[data-testid="chat-menu"]')
    await alicePage.click('text=Verify Safety Number')

    const aliceSafetyNumber = await alicePage.textContent('[data-testid="safety-number"]')

    // Open on Bob's side
    await bobPage.goto('/chat/dm/alice')
    await bobPage.click('[data-testid="chat-menu"]')
    await bobPage.click('text=Verify Safety Number')

    const bobSafetyNumber = await bobPage.textContent('[data-testid="safety-number"]')

    // Verify they match
    expect(aliceSafetyNumber).toEqual(bobSafetyNumber)

    // Mark as verified
    await alicePage.click('text=Mark as Verified')
    await expect(alicePage.locator('[data-testid="verified-badge"]')).toBeVisible()
  })

  test('device lock protects encrypted data', async ({ page }) => {
    // Setup E2EE with device lock
    await page.goto('/settings/security')
    await page.click('text=Configure Device Lock')
    await page.click('text=PIN')
    await page.fill('[name="pin"]', '123456')
    await page.fill('[name="confirmPin"]', '123456')
    await page.click('text=Enable Device Lock')

    // Close and reopen app
    await page.goto('/')

    // Should show lock screen
    await expect(page.locator('[data-testid="pin-entry"]')).toBeVisible()

    // Enter wrong PIN
    await page.fill('[data-testid="pin-input"]', '000000')
    await page.click('text=Unlock')
    await expect(page.locator('text=Invalid PIN')).toBeVisible()

    // Enter correct PIN
    await page.fill('[data-testid="pin-input"]', '123456')
    await page.click('text=Unlock')

    // Should be unlocked
    await expect(page.locator('[data-testid="pin-entry"]')).not.toBeVisible()
  })
})