class NotificationTrayErrorHandler(private val context: Context) {
    private val repository = AmityCoreClient.newNotificationRepository()
    private var retryAttempts = 0
    private val maxRetryAttempts = 3
    
    fun markTraySeenWithErrorHandling(callback: (Boolean) -> Unit) {
        repository.markNotificationTraySeen()
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe({
                retryAttempts = 0
                callback(true)
            }, { error ->
                handleMarkSeenError(error, callback)
            })
    }
    
    private fun handleMarkSeenError(error: Throwable, callback: (Boolean) -> Unit) {
        retryAttempts++
        
        when {
            error is NetworkException -> {
                if (retryAttempts < maxRetryAttempts) {
                    // Exponential backoff retry
                    val delay = (2.0.pow(retryAttempts.toDouble()) * 1000).toLong()
                    Handler(Looper.getMainLooper()).postDelayed({
                        markTraySeenWithErrorHandling(callback)
                    }, delay)
                } else {
                    // Fail silently but log error
                    Log.w("NotificationTray", "Failed to mark tray as seen after $maxRetryAttempts attempts")
                    callback(false)
                }
            }
            
            error.message?.contains("unauthorized") == true -> {
                // Handle authentication issues
                handleAuthenticationError()
                callback(false)
            }
            
            else -> {
                // For other errors, fail silently
                Log.w("NotificationTray", "Error marking tray as seen", error)
                callback(false)
            }
        }
    }
    
    private fun handleAuthenticationError() {
        // Trigger re-authentication flow
        val intent = Intent(ACTION_AUTHENTICATION_REQUIRED)
        LocalBroadcastManager.getInstance(context).sendBroadcast(intent)
    }
    
    companion object {
        const val ACTION_AUTHENTICATION_REQUIRED = "com.app.authentication_required"
    }
}

class NotificationTrayErrorHandler {
    private repository: AmityNotificationTrayRepository;
    private retryAttempts: number = 0;
    private maxRetryAttempts: number = 3;
    
    constructor() {
        this.repository = new AmityNotificationTrayRepository();
    }
    
    async markTraySeenWithErrorHandling(): Promise<boolean> {
        try {
            await this.repository.markNotificationTraySeen();
            this.retryAttempts = 0;
            return true;
        } catch (error: any) {
            return await this.handleMarkSeenError(error);
        }
    }
    
    private async handleMarkSeenError(error: any): Promise<boolean> {
        this.retryAttempts++;
        
        switch (error.code) {
            case 'NETWORK_ERROR':
                if (this.retryAttempts < this.maxRetryAttempts) {
                    // Exponential backoff retry
                    const delay = Math.pow(2, this.retryAttempts) * 1000;
                    await new Promise(resolve => setTimeout(resolve, delay));
                    return await this.markTraySeenWithErrorHandling();
                } else {
                    // Fail silently but log error
                    console.warn(`Failed to mark tray as seen after ${this.maxRetryAttempts} attempts`);
                    return false;
                }
                
            case 'UNAUTHORIZED':
                // Handle authentication issues
                this.handleAuthenticationError();
                return false;
                
            default:
                // For other errors, fail silently
                console.warn('Error marking tray as seen:', error);
                return false;
        }
    }
    
    private handleAuthenticationError(): void {
        // Emit authentication required event
        const event = new CustomEvent('authenticationRequired');
        window.dispatchEvent(event);
    }
}