App.js

import React, { useEffect } from 'react';
import { StatusBar, Linking, Platform } from 'react-native';
import { SafeAreaProvider } from 'react-native-safe-area-context';
import { NavigationContainer } from '@react-navigation/native';
import FlashMessage from 'react-native-flash-message';
import { Provider, useDispatch, useSelector } from 'react-redux';

import StackNavigator from './src/navigation/StackNavigator';
import { store } from './src/redux/store';
import { supabase } from './src/integrations/supabase/client';

import messaging from '@react-native-firebase/messaging';
import notifee, { EventType } from '@notifee/react-native';

import RingtoneService from './src/notifications/RingtoneService';
import {
  setupNotificationChannel,
  showIncomingWorkNotification,
} from './src/notifications/notificationService';

import IncomingWorkOverlay from './src/components/IncomingWorkOverlay';
import { clearIncomingWork, showIncomingWork } from './src/redux/workSlice';

function AppContainer() {
  const dispatch = useDispatch();

  // Redux state for custom notification UI
  const incomingWork = useSelector(
    state => state.work?.incomingWork
  );

  // Track current logged in worker for real-time listener
  const workerId = useSelector(state => state.auth?.user?.id);

  /*  NOTIFICATION INIT */
  useEffect(() => {
    const initNotifications = async () => {
      if (Platform.OS === 'android') {
        await notifee.requestPermission();
      }

      // FCM Token (future backend)
      const token = await messaging().getToken();
      console.log('FCM TOKEN:', token);

      await setupNotificationChannel();

      // Foreground FCM listener (future use)
      messaging().onMessage(async remoteMessage => {
        if (remoteMessage.data?.type === 'NEW_WORK') {
          await showIncomingWorkNotification(remoteMessage.data);
          RingtoneService.startRingtone();
        }
      });

      // Notification action handler
      notifee.onForegroundEvent(async ({ type, detail }) => {
        if (type === EventType.ACTION_PRESS) {
          RingtoneService.stopRingtone?.();

          const notificationId = detail.notification?.id;
          if (notificationId) {
            await notifee.cancelNotification(notificationId);
          }
        }
      });
    };

    initNotifications();
  }, []);

  /* SUPABASE REALTIME NOTIFICATIONS */
  useEffect(() => {
    if (!workerId) return;

    console.log(`Setting up Supabase real-time listener for worker ${workerId}...`);
    const channel = supabase.channel('worker_notifications');

    const subscription = channel
      .on('broadcast', { event: `new_task_worker_${workerId}` }, (payload) => {
        const jobDetails = payload.payload;
        console.log('Received new task broadcast:', jobDetails);

        // Show IncomingWorkOverlay and play ringtone
        dispatch(showIncomingWork(jobDetails));
        RingtoneService.startRingtone();
      })
      .subscribe((status) => {
        console.log(`Supabase Realtime status for worker ${workerId}:`, status);
      });

    return () => {
      console.log(`Unsubscribing from worker_notifications for worker ${workerId}`);
      supabase.removeChannel(channel);
    };
  }, [workerId, dispatch]);

  /* UI*/
  return (
    <SafeAreaProvider>
      <StatusBar barStyle="light-content" backgroundColor="#4A72FF" />

      <NavigationContainer>
        <StackNavigator />
      </NavigationContainer>

      {/* CUSTOM NOTIFICATION */}
      {incomingWork && (
        <IncomingWorkOverlay
          data={incomingWork}
          onAccept={() => {
            RingtoneService.stopRingtone?.();
            dispatch(clearIncomingWork());
          }}
          onReject={() => {
            RingtoneService.stopRingtone?.();
            dispatch(clearIncomingWork());
          }}
        />
      )}

      <FlashMessage position="top" statusBarHeight={15} />
    </SafeAreaProvider>
  );
}

export default function App() {
  return (
    <Provider store={store}>
      <AppContainer />
    </Provider>
  );
}