// Check APNs configuration
#if DEBUG
let apnsEnvironment = "development"
#else  
let apnsEnvironment = "production"
#endif

print("APNs Environment: \(apnsEnvironment)")

// Verify device token format
func application(_ application: UIApplication, 
                 didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
    let tokenString = deviceToken.map { String(format: "%02.2hhx", $0) }.joined()
    print("Device Token: \(tokenString)")
    
    // Register with social.plus Video SDK
    VideoNotificationManager.shared.registerDevice(token: tokenString)
}

// Handle silent notifications for stream events
func application(_ application: UIApplication, 
                 didReceiveRemoteNotification userInfo: [AnyHashable: Any], 
                 fetchCompletionHandler completionHandler: @escaping (UIBackgroundFetchResult) -> Void) {
    
    if let streamEvent = userInfo["stream_event"] as? String {
        // Process stream event silently
        VideoStreamManager.shared.processBackgroundEvent(userInfo)
        completionHandler(.newData)
    } else {
        completionHandler(.noData)
    }
}

// Check FCM configuration
class VideoFirebaseMessagingService : FirebaseMessagingService() {
    
    override fun onNewToken(token: String) {
        super.onNewToken(token)
        Log.d("FCM", "New token: $token")
        
        // Register with social.plus Video SDK
        VideoNotificationManager.getInstance().registerDevice(token)
    }
    
    override fun onMessageReceived(remoteMessage: RemoteMessage) {
        super.onMessageReceived(remoteMessage)
        
        Log.d("FCM", "Message received from: ${remoteMessage.from}")
        Log.d("FCM", "Message data: ${remoteMessage.data}")
        
        // Process video notification
        VideoNotificationHandler.processMessage(remoteMessage)
    }
}

// Handle background video events
class VideoBackgroundProcessor : JobIntentService() {
    
    override fun onHandleWork(intent: Intent) {
        val eventType = intent.getStringExtra("event_type")
        val streamId = intent.getStringExtra("stream_id")
        
        when (eventType) {
            "stream.started" -> handleStreamStarted(streamId)
            "recording.ready" -> handleRecordingReady(intent.extras)
        }
    }
}

// Check service worker registration
if ('serviceWorker' in navigator && 'PushManager' in window) {
  navigator.serviceWorker.register('/sw.js')
    .then(registration => {
      console.log('Service Worker registered:', registration);
      
      // Check if already subscribed
      return registration.pushManager.getSubscription();
    })
    .then(subscription => {
      if (!subscription) {
        // Subscribe to push notifications
        return subscribeUserToPush();
      }
      console.log('Already subscribed:', subscription);
    })
    .catch(error => {
      console.error('Service Worker registration failed:', error);
    });
}

// Verify VAPID key configuration
function subscribeUserToPush() {
  const applicationServerKey = urlBase64ToUint8Array(VAPID_PUBLIC_KEY);
  
  return navigator.serviceWorker.ready
    .then(registration => {
      return registration.pushManager.subscribe({
        userVisibleOnly: true,
        applicationServerKey: applicationServerKey
      });
    })
    .then(subscription => {
      console.log('Push subscription:', subscription);
      
      // Send subscription to server
      return sendSubscriptionToServer(subscription);
    })
    .catch(error => {
      console.error('Failed to subscribe user:', error);
    });
}

// Prevent memory leaks from event listeners
class EventListenerManager {
  private listeners: Map<string, Function[]> = new Map();
  
  addListener(event: string, callback: Function): () => void {
    if (!this.listeners.has(event)) {
      this.listeners.set(event, []);
    }
    
    this.listeners.get(event)!.push(callback);
    
    // Return cleanup function
    return () => {
      const callbacks = this.listeners.get(event);
      if (callbacks) {
        const index = callbacks.indexOf(callback);
        if (index > -1) {
          callbacks.splice(index, 1);
        }
      }
    };
  }
  
  cleanup(): void {
    this.listeners.clear();
  }
}

// Manage event queue to prevent overflow
class EventQueue {
  private queue: StreamEvent[] = [];
  private processing = false;
  private maxQueueSize = 1000;
  
  addEvent(event: StreamEvent): void {
    if (this.queue.length >= this.maxQueueSize) {
      // Remove oldest events
      this.queue.splice(0, this.queue.length - this.maxQueueSize + 1);
    }
    
    this.queue.push(event);
    this.processQueue();
  }
  
  private async processQueue(): Promise<void> {
    if (this.processing || this.queue.length === 0) return;
    
    this.processing = true;
    
    while (this.queue.length > 0) {
      const event = this.queue.shift()!;
      try {
        await this.processEvent(event);
      } catch (error) {
        console.error('Event processing failed:', error);
      }
    }
    
    this.processing = false;
  }
}

// Enable comprehensive debugging
VideoStreamManager.configure({
  debug: {
    enabled: true,
    logLevel: 'verbose',
    logEvents: true,
    logNotifications: true,
    logWebhooks: true
  }
});

// Custom debug logger
VideoStreamManager.setDebugLogger((level, message, data) => {
  console.log(`[VIDEO-${level.toUpperCase()}]`, message, data);
  
  // Send to analytics if needed
  if (level === 'error') {
    Analytics.track('video_debug_error', { message, data });
  }
});

// Test notification delivery
async function testNotificationFlow() {
  const testCases = [
    { event: 'stream.started', platform: 'ios' },
    { event: 'viewer.milestone', platform: 'android' },
    { event: 'recording.ready', platform: 'web' }
  ];
  
  for (const testCase of testCases) {
    try {
      const result = await VideoNotifications.test(testCase);
      console.log(`✅ ${testCase.event} on ${testCase.platform}:`, result);
    } catch (error) {
      console.error(`❌ ${testCase.event} on ${testCase.platform}:`, error);
    }
  }
}