object NotificationAnalytics {
    fun trackNotificationInteraction(item: AmityNotificationTrayItem) {
        val properties = bundleOf(
            "notification_id" to item.notificationId,
            "action_type" to item.actionType,
            "target_type" to item.targetType,
            "actor_count" to item.actorCount,
            "time_to_interaction" to calculateTimeToInteraction(item),
            "was_seen_before" to item.isSeen
        )
        
        Analytics.track("notification_item_interacted", properties)
    }
    
    private fun calculateTimeToInteraction(item: AmityNotificationTrayItem): Long {
        return System.currentTimeMillis() - item.lastOccuredAt.time
    }
}

class NotificationAnalytics {
    static trackNotificationInteraction(item: AmityNotificationTrayItem): void {
        const properties = {
            notification_id: item.notificationId,
            action_type: item.actionType,
            target_type: item.targetType,
            actor_count: item.actorCount,
            time_to_interaction: this.calculateTimeToInteraction(item),
            was_seen_before: item.isSeen
        };
        
        Analytics.track('notification_item_interacted', properties);
    }
    
    private static calculateTimeToInteraction(item: AmityNotificationTrayItem): number {
        return Date.now() - new Date(item.lastOccuredAt).getTime();
    }
}

class NotificationItemErrorHandler(private val context: Context) {
    
    fun markItemSeenWithErrorHandling(
        item: AmityNotificationTrayItem,
        callback: (Boolean) -> Unit
    ) {
        item.markSeen()
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe({
                callback(true)
            }, { error ->
                handleMarkSeenError(error, item, callback)
            })
    }
    
    private fun handleMarkSeenError(
        error: Throwable,
        item: AmityNotificationTrayItem,
        callback: (Boolean) -> Unit
    ) {
        when {
            error is NetworkException -> {
                showRetryOption(item, callback)
            }
            error.message?.contains("permission") == true -> {
                showPermissionError()
                callback(false)
            }
            error.message?.contains("not found") == true -> {
                // Item might have been deleted, treat as success
                callback(true)
            }
            else -> {
                showGenericError()
                callback(false)
            }
        }
    }
    
    private fun showRetryOption(
        item: AmityNotificationTrayItem,
        callback: (Boolean) -> Unit
    ) {
        AlertDialog.Builder(context)
            .setTitle("Connection Error")
            .setMessage("Failed to mark notification as seen. Would you like to retry?")
            .setPositiveButton("Retry") { _, _ ->
                markItemSeenWithErrorHandling(item, callback)
            }
            .setNegativeButton("Cancel") { _, _ ->
                callback(false)
            }
            .show()
    }
}

class NotificationItemErrorHandler {
    async markItemSeenWithErrorHandling(
        item: AmityNotificationTrayItem,
        retryCount: number = 0,
        maxRetries: number = 3
    ): Promise<boolean> {
        try {
            await item.markSeen();
            return true;
        } catch (error: any) {
            return await this.handleMarkSeenError(error, item, retryCount, maxRetries);
        }
    }
    
    private async handleMarkSeenError(
        error: any,
        item: AmityNotificationTrayItem,
        retryCount: number,
        maxRetries: number
    ): Promise<boolean> {
        switch (error.code) {
            case 'NETWORK_ERROR':
                if (retryCount < maxRetries) {
                    const delay = Math.pow(2, retryCount) * 1000;
                    await new Promise(resolve => setTimeout(resolve, delay));
                    return this.markItemSeenWithErrorHandling(item, retryCount + 1, maxRetries);
                }
                return await this.showRetryOption(item);
                
            case 'PERMISSION_DENIED':
                this.showPermissionError();
                return false;
                
            case 'ITEM_NOT_FOUND':
                // Item might have been deleted, treat as success
                return true;
                
            default:
                this.showGenericError();
                return false;
        }
    }
    
    private async showRetryOption(item: AmityNotificationTrayItem): Promise<boolean> {
        return new Promise((resolve) => {
            const confirmed = confirm(
                'Failed to mark notification as seen. Would you like to retry?'
            );
            
            if (confirmed) {
                this.markItemSeenWithErrorHandling(item, 0, 3)
                    .then(resolve)
                    .catch(() => resolve(false));
            } else {
                resolve(false);
            }
        });
    }
}