TOTP Hosted Integration

https://app.akedly.io/totp/setup?pipeline={pipelineID}&identifier={userIdentifier}

<key>CFBundleURLTypes</key>
<array>
  <dict>
    <key>CFBundleURLName</key>
    <string>com.yourapp.totp</string>
    <key>CFBundleURLSchemes</key>
    <array>
      <string>yourapp</string>
    </array>
  </dict>
</array>

<activity android:name=".MainActivity">
  <intent-filter android:autoVerify="true">
    <action android:name="android.intent.action.VIEW" />
    <category android:name="android.intent.category.DEFAULT" />
    <category android:name="android.intent.category.BROWSABLE" />
    <data android:scheme="yourapp" />
  </intent-filter>
</activity>

// Error handling for hosted TOTP integration

class TOTPErrorHandler {
  static handleCallback(url) {
    const params = new URLSearchParams(url.split('?')[1])
    const status = params.get('status')
    const reason = params.get('reason')
    const identifier = params.get('identifier')

    switch (status) {
      case 'success':
        return this.handleSuccess(params)

      case 'cancelled':
        return this.handleCancellation(reason)

      case 'expired':
        return this.handleExpiration(identifier)

      case 'error':
        return this.handleError(reason, identifier)

      default:
        return this.handleUnknownStatus(status)
    }
  }

  static handleSuccess(params) {
    const totpID = params.get('totpID')
    const requestID = params.get('requestID')
    const identifier = params.get('identifier')

    if (totpID) {
      // Setup success
      return {
        type: 'setup_success',
        message: 'Two-factor authentication has been set up successfully!',
        action: () => this.updateTOTPStatus(identifier, true),
        redirect: '/settings/security',
      }
    } else if (requestID) {
      // Auth success
      return {
        type: 'auth_success',
        message: 'Authentication successful!',
        action: () => this.completeAuthentication(identifier),
        redirect: this.getIntendedUrl() || '/dashboard',
      }
    }

    return {
      type: 'unknown_success',
      message: 'Operation completed successfully.',
      redirect: '/',
    }
  }

  static handleCancellation(reason) {
    const messages = {
      user_cancelled: 'You cancelled the authentication process.',
      browser_closed: 'The authentication window was closed.',
      timeout: 'The authentication process timed out.',
    }

    return {
      type: 'cancelled',
      message: messages[reason] || 'Authentication was cancelled.',
      action: () => this.showRetryOption(),
      redirect: null, // Stay on current page
    }
  }

  static handleExpiration(identifier) {
    return {
      type: 'expired',
      message: 'The authentication request expired. Please try again.',
      action: () => this.offerRetry(identifier),
      redirect: null,
    }
  }

  static handleError(reason, identifier) {
    const errorMessages = {
      totp_not_setup: {
        message: 'Two-factor authentication is not set up for this account.',
        action: () => this.redirectToSetup(identifier),
        redirect: '/settings/security',
      },
      quota_exceeded: {
        message: 'Account quota exceeded. Please contact support.',
        action: () => this.contactSupport(),
        redirect: '/support',
      },
      invalid_pipeline: {
        message: 'Configuration error. Please contact support.',
        action: () => this.logConfigError(),
        redirect: '/support',
      },
      network_error: {
        message:
          'Network error occurred. Please check your connection and try again.',
        action: () => this.showRetryOption(),
        redirect: null,
      },
    }

    const errorInfo = errorMessages[reason] || {
      message: 'An unexpected error occurred. Please try again.',
      action: () => console.log('Unknown error:', reason),
      redirect: null,
    }

    return {
      type: 'error',
      ...errorInfo,
    }
  }

  static handleUnknownStatus(status) {
    console.error('Unknown TOTP callback status:', status)
    return {
      type: 'unknown',
      message: 'An unexpected response was received. Please try again.',
      redirect: '/',
    }
  }

  // Helper methods
  static updateTOTPStatus(identifier, enabled) {
    // Update user's TOTP status in your system
    fetch('/api/users/totp-status', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ identifier, enabled }),
    })
  }

  static completeAuthentication(identifier) {
    // Complete login process
    sessionStorage.setItem('authenticated', 'true')
    sessionStorage.setItem('user_email', identifier)
  }

  static getIntendedUrl() {
    return sessionStorage.getItem('intended_url')
  }

  static showRetryOption() {
    // Show UI element allowing user to retry
    const retryBtn = document.getElementById('retry-totp')
    if (retryBtn) {
      retryBtn.style.display = 'block'
    }
  }

  static offerRetry(identifier) {
    if (
      confirm(
        'The authentication request expired. Would you like to try again?',
      )
    ) {
      // Restart authentication process
      window.location.href = `/totp/auth?email=${encodeURIComponent(identifier)}`
    }
  }

  static redirectToSetup(identifier) {
    window.location.href = `/totp/setup?email=${encodeURIComponent(identifier)}`
  }

  static contactSupport() {
    window.location.href = '/support'
  }

  static logConfigError() {
    console.error('TOTP configuration error - invalid pipeline')
    // Send error report to your logging service
  }
}

// Usage
document.addEventListener('DOMContentLoaded', () => {
  if (window.location.search.includes('status=')) {
    const result = TOTPErrorHandler.handleCallback(window.location.href)

    // Execute action if provided
    if (result.action) {
      result.action()
    }

    // Show message to user
    if (result.message) {
      showMessage(result.message, result.type)
    }

    // Redirect if specified
    if (result.redirect) {
      setTimeout(() => {
        window.location.href = result.redirect
      }, 2000)
    }
  }
})

function showMessage(message, type) {
  const messageDiv = document.createElement('div')
  messageDiv.className = `message ${type}`
  messageDiv.textContent = message
  document.body.insertBefore(messageDiv, document.body.firstChild)

  // Auto-remove after 5 seconds
  setTimeout(() => messageDiv.remove(), 5000)
}

// Comprehensive testing for hosted TOTP integration

class TOTPIntegrationTester {
  constructor(pipelineId, apiKey) {
    this.pipelineId = pipelineId
    this.apiKey = apiKey
    this.testResults = []
  }

  async runAllTests() {
    console.log('🧪 Starting TOTP Hosted Integration Tests...\n')

    await this.testPipelineConfiguration()
    await this.testSetupFlow()
    await this.testAuthenticationFlow()
    await this.testCallbackHandling()
    await this.testErrorScenarios()
    await this.testMobileIntegration()

    this.printResults()
  }

  async testPipelineConfiguration() {
    console.log('Testing Pipeline Configuration...')

    try {
      // Test pipeline exists and is accessible
      const testURL = `https://app.akedly.io/totp/setup?pipeline=${this.pipelineId}&identifier=test@example.com`

      const response = await fetch(testURL, { method: 'HEAD' })

      if (response.status === 200) {
        this.testResults.push({
          test: 'Pipeline Configuration',
          status: 'PASS',
        })
      } else if (response.status === 404) {
        this.testResults.push({
          test: 'Pipeline Configuration',
          status: 'FAIL',
          error: 'Pipeline not found',
        })
      } else {
        this.testResults.push({
          test: 'Pipeline Configuration',
          status: 'FAIL',
          error: `HTTP ${response.status}`,
        })
      }
    } catch (error) {
      this.testResults.push({
        test: 'Pipeline Configuration',
        status: 'ERROR',
        error: error.message,
      })
    }
  }

  async testSetupFlow() {
    console.log('Testing Setup Flow...')

    try {
      // Test setup URL generation
      const setupURL = `https://app.akedly.io/totp/setup?pipeline=${this.pipelineId}&identifier=test-setup@example.com`

      if (
        setupURL.includes(this.pipelineId) &&
        setupURL.includes('test-setup@example.com')
      ) {
        this.testResults.push({ test: 'Setup URL Generation', status: 'PASS' })
      } else {
        this.testResults.push({ test: 'Setup URL Generation', status: 'FAIL' })
      }

      // Test callback URL handling
      const callbackURL =
        'https://yourapp.com/totp-callback?status=success&identifier=test-setup@example.com&totpID=test123'
      const result = this.simulateCallback(callbackURL)

      if (result.type === 'setup_success') {
        this.testResults.push({
          test: 'Setup Callback Handling',
          status: 'PASS',
        })
      } else {
        this.testResults.push({
          test: 'Setup Callback Handling',
          status: 'FAIL',
        })
      }
    } catch (error) {
      this.testResults.push({
        test: 'Setup Flow',
        status: 'ERROR',
        error: error.message,
      })
    }
  }

  async testAuthenticationFlow() {
    console.log('Testing Authentication Flow...')

    try {
      // Test auth request creation
      const response = await fetch(
        'https://api.akedly.io/api/v1/totp/request-auth',
        {
          method: 'POST',
          headers: { 'Content-Type': 'application/json' },
          body: JSON.stringify({
            APIKey: this.apiKey,
            identifier: 'test-auth@example.com',
            pipelineID: this.pipelineId,
          }),
        },
      )

      const data = await response.json()

      if (data.status === 'success' && data.data.authRequestID) {
        this.testResults.push({ test: 'Auth Request Creation', status: 'PASS' })

        // Test auth URL generation
        const authURL = `https://app.akedly.io/totp/request?requestID=${data.data.authRequestID}`

        if (authURL.includes(data.data.authRequestID)) {
          this.testResults.push({ test: 'Auth URL Generation', status: 'PASS' })
        } else {
          this.testResults.push({ test: 'Auth URL Generation', status: 'FAIL' })
        }
      } else {
        this.testResults.push({
          test: 'Auth Request Creation',
          status: 'FAIL',
          error: data.message,
        })
      }
    } catch (error) {
      this.testResults.push({
        test: 'Authentication Flow',
        status: 'ERROR',
        error: error.message,
      })
    }
  }

  async testCallbackHandling() {
    console.log('Testing Callback Handling...')

    const testCases = [
      {
        name: 'Success Setup Callback',
        url: 'https://yourapp.com/callback?status=success&identifier=user@example.com&totpID=abc123',
        expectedType: 'setup_success',
      },
      {
        name: 'Success Auth Callback',
        url: 'https://yourapp.com/callback?status=success&identifier=user@example.com&requestID=req123',
        expectedType: 'auth_success',
      },
      {
        name: 'Cancelled Callback',
        url: 'https://yourapp.com/callback?status=cancelled&reason=user_cancelled',
        expectedType: 'cancelled',
      },
      {
        name: 'Expired Callback',
        url: 'https://yourapp.com/callback?status=expired&identifier=user@example.com',
        expectedType: 'expired',
      },
      {
        name: 'Error Callback',
        url: 'https://yourapp.com/callback?status=error&reason=quota_exceeded',
        expectedType: 'error',
      },
    ]

    testCases.forEach((testCase) => {
      try {
        const result = this.simulateCallback(testCase.url)

        if (result.type === testCase.expectedType) {
          this.testResults.push({ test: testCase.name, status: 'PASS' })
        } else {
          this.testResults.push({
            test: testCase.name,
            status: 'FAIL',
            error: `Expected ${testCase.expectedType}, got ${result.type}`,
          })
        }
      } catch (error) {
        this.testResults.push({
          test: testCase.name,
          status: 'ERROR',
          error: error.message,
        })
      }
    })
  }

  async testErrorScenarios() {
    console.log('Testing Error Scenarios...')

    // Test invalid pipeline ID
    const invalidURL =
      'https://app.akedly.io/totp/setup?pipeline=invalid&identifier=test@example.com'

    try {
      const response = await fetch(invalidURL, { method: 'HEAD' })

      if (response.status === 404 || response.status === 400) {
        this.testResults.push({
          test: 'Invalid Pipeline Handling',
          status: 'PASS',
        })
      } else {
        this.testResults.push({
          test: 'Invalid Pipeline Handling',
          status: 'FAIL',
        })
      }
    } catch (error) {
      this.testResults.push({
        test: 'Invalid Pipeline Handling',
        status: 'ERROR',
        error: error.message,
      })
    }
  }

  async testMobileIntegration() {
    console.log('Testing Mobile Integration...')

    // Test mobile redirect URL format
    const mobileCallbackURL =
      'myapp://totp-complete?status=success&identifier=user@example.com&totpID=abc123'

    try {
      const result = this.simulateCallback(mobileCallbackURL)

      if (result.type === 'setup_success') {
        this.testResults.push({
          test: 'Mobile Deep Link Callback',
          status: 'PASS',
        })
      } else {
        this.testResults.push({
          test: 'Mobile Deep Link Callback',
          status: 'FAIL',
        })
      }
    } catch (error) {
      this.testResults.push({
        test: 'Mobile Deep Link Callback',
        status: 'ERROR',
        error: error.message,
      })
    }
  }

  simulateCallback(url) {
    // Simulate TOTPErrorHandler.handleCallback for testing
    const params = new URLSearchParams(url.split('?')[1])
    const status = params.get('status')
    const totpID = params.get('totpID')
    const requestID = params.get('requestID')

    if (status === 'success') {
      if (totpID) {
        return { type: 'setup_success' }
      } else if (requestID) {
        return { type: 'auth_success' }
      }
    }

    return { type: status || 'unknown' }
  }

  printResults() {
    console.log('\n📊 Test Results:')
    console.log('==================')

    this.testResults.forEach((result) => {
      const emoji =
        result.status === 'PASS' ? '✅' : result.status === 'FAIL' ? '❌' : '⚠️'
      console.log(`${emoji} ${result.test}: ${result.status}`)
      if (result.error) {
        console.log(`   Error: ${result.error}`)
      }
    })

    const passCount = this.testResults.filter((r) => r.status === 'PASS').length
    const totalCount = this.testResults.length

    console.log(`\nResults: ${passCount}/${totalCount} tests passed`)

    if (passCount === totalCount) {
      console.log('🎉 All tests passed! Ready for production.')
    } else {
      console.log('⚠️ Some tests failed. Please review before going live.')
    }
  }
}

// Run tests
const tester = new TOTPIntegrationTester('your_pipeline_id', 'your_api_key')
await tester.runAllTests()