// Example of cross-origin detection
if (clientData.cross_origin) {
    results["errors"].append("cross_origin_not_allowed");
}

// Inspect CBOR-encoded data in browser
function inspectCborData(encodedData) {
    try {
        const decoder = new CBORDecoder();
        const decoded = decoder.decode(encodedData);
        console.log('Decoded CBOR:', decoded);
        return decoded;
    } catch (error) {
        console.error('CBOR decoding failed:', error);
        return null;
    }
}

// From server/server/static/scripts/advanced/json-editor.js
function validateAuthenticationPublicKey(publicKey) {
    if (publicKey.timeout !== undefined) {
        const timeoutValue = normalizeInteger(publicKey.timeout, 'publicKey.timeout');
        if (timeoutValue !== null && timeoutValue < 0) {
            throw new Error('publicKey.timeout must be zero or greater.');
        }
    }
    
    if (publicKey.rpId !== undefined && 
        (typeof publicKey.rpId !== 'string' || !publicKey.rpId.trim())) {
        throw new Error('publicKey.rpId must be a non-empty string when provided.');
    }
}

// Example error response structure
{
    "error": "Registration state not found or has expired. Please restart the registration process.",
    "errorCode": "STATE_EXPIRED",
    "timestamp": "2024-01-15T10:30:00Z"
}

// Example authentication error response
{
    "error": "User verification required, but user verified flag not set.",
    "errorCode": "USER_VERIFICATION_REQUIRED",
    "details": {
        "userVerificationRequired": true,
        "userVerified": false,
        "authenticatorFlags": {
            "userPresent": true,
            "userVerified": false
        }
    }
}

// From server/server/static/scripts/advanced/json-editor.js
function validateHints(hints, fieldName) {
    if (!Array.isArray(hints)) {
        throw new Error(`${fieldName} must be an array.`);
    }
    
    const validHints = ['platform', 'cross-platform'];
    for (const hint of hints) {
        if (!validHints.includes(hint)) {
            throw new Error(`Invalid hint value: ${hint}`);
        }
    }
}

function logCredentialOptions(options) {
    console.log('Credential Options:', {
        challenge: options.challenge,
        rp: options.rp,
        user: options.user,
        pubKeyCredParams: options.pubKeyCredParams.map(param => ({
            type: param.type,
            alg: param.alg,
            algorithmName: getAlgorithmName(param.alg)
        })),
        authenticatorSelection: options.authenticatorSelection,
        timeout: options.timeout,
        attestation: options.attestation
    });
}

function validateCredentialOptions(options) {
    const errors = [];
    
    // Check required fields
    if (!options.challenge) errors.push('challenge is required');
    if (!options.rp || !options.rp.id) errors.push('rp.id is required');
    if (!options.user || !options.user.name) errors.push('user.name is required');
    
    // Validate algorithm parameters
    if (options.pubKeyCredParams) {
        for (const param of options.pubKeyCredParams) {
            if (!param.type || !param.alg) {
                errors.push('Each pubKeyCredParam must have type and alg');
            }
        }
    }
    
    return errors;
}

// Extract and log authentication response headers
function logAuthResponseHeaders(response) {
    const headers = {};
    for (const [key, value] of response.headers.entries()) {
        headers[key] = value;
    }
    
    console.log('Response Headers:', {
        'content-type': headers['content-type'],
        'x-frame-options': headers['x-frame-options'],
        'x-content-type-options': headers['x-content-type-options'],
        'permissions-policy': headers['permissions-policy']
    });
}

// Enhanced error logging for WebAuthn operations
function logWebAuthnError(operation, error) {
    console.group(`WebAuthn ${operation} Error`);
    console.log('Error name:', error.name);
    console.log('Error message:', error.message);
    console.log('Error stack:', error.stack);
    
    if (error.cause) {
        console.log('Error cause:', error.cause);
    }
    
    if (error.webauthnCode) {
        console.log('WebAuthn error code:', error.webauthnCode);
    }
    
    console.groupEnd();
}

// Track authentication state changes
let authenticationState = {
    challenge: null,
    rpId: null,
    userId: null,
    timestamp: Date.now()
};

function updateAuthenticationState(newState) {
    authenticationState = { ...authenticationState, ...newState };
    console.log('Updated authentication state:', authenticationState);
}

// Inspect session storage for authentication state
function inspectSessionStorage() {
    const sessionStorageItems = {};
    for (let i = 0; i < sessionStorage.length; i++) {
        const key = sessionStorage.key(i);
        try {
            const value = sessionStorage.getItem(key);
            sessionStorageItems[key] = JSON.parse(value);
        } catch (e) {
            sessionStorageItems[key] = value;
        }
    }
    
    console.log('Session Storage:', sessionStorageItems);
}

// Validate local storage for persistent authentication data
function validateLocalStorage() {
    const localStorageItems = {};
    for (let i = 0; i < localStorage.length; i++) {
        const key = localStorage.key(i);
        if (key.startsWith('webauthn_')) {
            try {
                const value = localStorage.getItem(key);
                localStorageItems[key] = JSON.parse(value);
            } catch (e) {
                localStorageItems[key] = value;
            }
        }
    }
    
    console.log('WebAuthn Local Storage:', localStorageItems);
}

// Monitor certificate validation in development
function monitorCertificateValidation() {
    if (window.performance && performance.getEntriesByType) {
        const resources = performance.getEntriesByType('resource');
        const certificates = resources.filter(resource => 
            resource.initiatorType === 'script' && 
            resource.name.includes('webauthn')
        );
        
        console.log('Certificate Resources:', certificates);
    }
}

// Determine authenticator capabilities
async function checkAuthenticatorCapabilities() {
    const info = await navigator.credentials.get({
        publicKey: {
            challenge: new Uint8Array(32),
            allowCredentials: [],
            userVerification: 'required'
        }
    });
    
    console.log('Authenticator capabilities:', {
        residentKeys: info.getResidentKeys?.(),
        userVerification: info.getUserVerification?.(),
        extensions: info.getExtensions?.()
    });
}

// Validate user verification requirements
function validateUserVerificationRequirements(options) {
    const requirements = {
        required: false,
        preferred: false,
        discouraged: false
    };
    
    if (options.authenticatorSelection) {
        const selection = options.authenticatorSelection;
        if (selection.userVerification === 'required') {
            requirements.required = true;
        } else if (selection.userVerification === 'preferred') {
            requirements.preferred = true;
        } else if (selection.userVerification === 'discouraged') {
            requirements.discouraged = true;
        }
    }
    
    return requirements;
}

// Monitor verification status during authentication
async function monitorVerificationStatus(assertion) {
    const clientExtensions = assertion.getClientExtensionResults();
    const credProps = clientExtensions?.credProps;
    
    console.log('Verification status:', {
        userVerified: credProps?.uv,
        residentKey: credProps?.rk,
        verificationMethod: credProps?.verificationMethod
    });
}

// Log attestation details for debugging
function logAttestationDetails(attestationObject) {
    console.log('Attestation Object:', {
        format: attestationObject.format,
        authData: attestationObject.authData,
        attStmt: attestationObject.attStmt,
        raw: Array.from(new Uint8Array(attestationObject.raw))
    });
}

// Validate attestation chain structure
function validateAttestationChain(attestationObject) {
    const attStmt = attestationObject.attStmt;
    const x5c = attStmt.x5c;
    
    if (!x5c || !Array.isArray(x5c)) {
        throw new Error('Attestation chain missing or invalid');
    }
    
    console.log('Attestation chain length:', x5c.length);
    
    // Validate each certificate in the chain
    x5c.forEach((cert, index) => {
        try {
            const decodedCert = decodeCertificate(cert);
            console.log(`Certificate ${index}:`, {
                subject: decodedCert.subject,
                issuer: decodedCert.issuer,
                validFrom: decodedCert.validFrom,
                validTo: decodedCert.validTo
            });
        } catch (error) {
            console.error(`Certificate ${index} validation failed:`, error);
        }
    });
}

// Check if algorithm is supported
function isAlgorithmSupported(algorithmId) {
    const supportedAlgorithms = [
        -7, // ES256
        -257, // RS256
        -8, // EDDSA
        // ... other supported algorithms
    ];
    
    return supportedAlgorithms.includes(algorithmId);
}

// Comprehensive debugging utilities
class WebAuthnDebugger {
    constructor() {
        this.logs = [];
        this.enabled = true;
    }
    
    enable() {
        this.enabled = true;
        console.log('WebAuthn debugging enabled');
    }
    
    disable() {
        this.enabled = false;
        console.log('WebAuthn debugging disabled');
    }
    
    log(level, message, data = null) {
        if (!this.enabled) return;
        
        const timestamp = new Date().toISOString();
        const logEntry = {
            timestamp,
            level,
            message,
            data: data ? this.sanitizeData(data) : null
        };
        
        this.logs.push(logEntry);
        console[level.toLowerCase()](message, data);
    }
    
    sanitizeData(data) {
        // Remove sensitive information
        const sanitized = {...data};
        delete sanitized.privateKey;
        delete sanitized.secretKey;
        delete sanitized.password;
        return sanitized;
    }
    
    exportLogs() {
        return JSON.stringify(this.logs, null, 2);
    }
}

const debugger = new WebAuthnDebugger();

// Implement graceful degradation for authentication failures
async function safeWebAuthnOperation(operation, fallback) {
    try {
        return await operation();
    } catch (error) {
        debugger.log('error', 'WebAuthn operation failed', error);
        
        // Attempt fallback authentication
        if (fallback) {
            debugger.log('warn', 'Attempting fallback authentication');
            return fallback();
        }
        
        throw error;
    }
}

// Implement retry logic for transient failures
async function retryWithBackoff(operation, maxRetries = 3, baseDelay = 1000) {
    let lastError;
    
    for (let attempt = 1; attempt <= maxRetries; attempt++) {
        try {
            return await operation();
        } catch (error) {
            lastError = error;
            
            if (attempt < maxRetries) {
                const delay = baseDelay * Math.pow(2, attempt - 1);
                debugger.log('warn', `Attempt ${attempt} failed, retrying in ${delay}ms`);
                await new Promise(resolve => setTimeout(resolve, delay));
            }
        }
    }
    
    throw lastError;
}

// Comprehensive promise rejection handling
function handlePromiseRejection(promise, context) {
    promise.catch(error => {
        debugger.log('error', `Promise rejection in ${context}`, {
            error: error.message,
            stack: error.stack,
            name: error.name
        });
        
        // Provide user-friendly error message
        showErrorMessage(`Authentication failed: ${error.message}`);
    });
}

// Example usage
handlePromiseRejection(
    navigator.credentials.get(credentialRequestOptions),
    'navigator.credentials.get'
);

// Check for WebAuthn API availability
function checkWebAuthnSupport() {
    const features = {
        webauthn: typeof navigator?.credentials?.get === 'function',
        subtleCrypto: typeof crypto?.subtle === 'object',
        bufferSource: typeof ArrayBuffer !== 'undefined',
        base64: typeof btoa === 'function'
    };
    
    if (!features.webauthn) {
        debugger.log('error', 'WebAuthn API not supported');
        return false;
    }
    
    if (!features.subtleCrypto) {
        debugger.log('error', 'Subtle Crypto API not supported');
        return false;
    }
    
    return true;
}

// Robust event listener implementation
class WebAuthnEventHandler {
    constructor(element) {
        this.element = element;
        this.listeners = new Map();
    }
    
    addEventListener(eventName, handler, options = {}) {
        const wrappedHandler = (...args) => {
            try {
                return handler(...args);
            } catch (error) {
                debugger.log('error', `Event handler error (${eventName}):`, error);
                // Prevent error propagation
                if (options.preventDefault !== false) {
                    args[0]?.preventDefault();
                }
            }
        };
        
        this.element.addEventListener(eventName, wrappedHandler, options);
        this.listeners.set(eventName, wrappedHandler);
    }
    
    removeEventListeners() {
        for (const [eventName, handler] of this.listeners) {
            this.element.removeEventListener(eventName, handler);
        }
        this.listeners.clear();
    }
}

// Enhanced form validation
function validateWebAuthnForm(form) {
    const errors = [];
    
    // Check required fields
    const requiredFields = ['username', 'challenge'];
    requiredFields.forEach(field => {
        const input = form.querySelector(`[name="${field}"]`);
        if (!input || !input.value.trim()) {
            errors.push(`${field} is required`);
        }
    });
    
    // Validate challenge format
    const challengeInput = form.querySelector('[name="challenge"]');
    if (challengeInput && challengeInput.value) {
        try {
            // Attempt to decode challenge
            websafe_decode(challengeInput.value);
        } catch (error) {
            errors.push('Invalid challenge format');
        }
    }
    
    return errors;
}