cloudsolutions-atoms/lib/controllers/notification/firebase_notification_manger.dart

import 'dart:convert';
import 'dart:developer';
import 'dart:io';

import 'package:firebase_messaging/firebase_messaging.dart';
import 'package:flutter/material.dart';
import 'package:google_api_availability/google_api_availability.dart';
import 'package:huawei_push/huawei_push.dart' as h_push;
import 'package:provider/provider.dart';
import 'package:test_sa/controllers/notification/notification_manger.dart';
import 'package:test_sa/controllers/providers/api/notifications_provider.dart';
import 'package:test_sa/models/all_requests_and_count_model.dart';
import 'package:test_sa/models/device/device_transfer.dart';
import 'package:test_sa/models/new_models/gas_refill_model.dart';
import 'package:test_sa/modules/cm_module/cm_detail_page.dart';
import 'package:test_sa/modules/cx_module/survey/survey_page.dart';
import 'package:test_sa/modules/demo_module/demo_detail_view_page.dart';
import 'package:test_sa/modules/incident_module/incident_detail_page.dart';
import 'package:test_sa/modules/internal_audit_module/pages/equipment_internal_audit/equipment_internal_audit_detail_page.dart';
import 'package:test_sa/modules/internal_audit_module/pages/system_internal_audit/system_internal_audit_detail_page.dart';
import 'package:test_sa/modules/loan_module/pages/loan_equipment_detail_page.dart';
import 'package:test_sa/modules/medical_gas_inspection/medical_gas_inspection_detail_page.dart';
import 'package:test_sa/modules/pm_module/ppm_wo/ppm_details_page.dart';
import 'package:test_sa/modules/pm_module/recurrent_wo/recurrent_work_order_view.dart';
import 'package:test_sa/modules/tm_module/device_transfer/device_transfer_details.dart';
import 'package:test_sa/modules/tm_module/tasks/task_request_detail_view.dart';
import 'package:test_sa/modules/tm_module/gas_refill/gas_refill_details.dart';
import 'package:test_sa/modules/traf_module/traf_request_detail_page.dart';
import 'package:test_sa/new_views/common_widgets/default_app_bar.dart';
import 'package:test_sa/views/widgets/loaders/no_data_found.dart';

@pragma('vm:entry-point')
Future<void> firebaseMessagingBackgroundHandler(RemoteMessage message) async {}

class FirebaseNotificationManger {
  static FirebaseMessaging messaging = FirebaseMessaging.instance;
  static String? token;

  static Future<void> getToken() async {
    NotificationSettings settings = await messaging.requestPermission(alert: true, announcement: false, badge: true, carPlay: false, criticalAlert: false, provisional: false, sound: true);

    if (Platform.isAndroid) {
      try {
        if (!(await isGoogleServicesAvailable())) {
          h_push.Push.enableLogger();
          final result = await h_push.Push.setAutoInitEnabled(true);
          h_push.Push.onMessageReceivedStream.listen(_onMessageReceived, onError: _onMessageReceiveError);

          h_push.Push.getTokenStream.listen((hToken) {
            // onToken(token);
            // print("Huawei Token: ${hToken}");
            token = hToken;
          }, onError: (e) {
            print("Huawei TokenError" + e.toString());
          });
          h_push.Push.getToken('');
        } else {
          if (settings.authorizationStatus == AuthorizationStatus.authorized) {
            try {
              token = await messaging.getToken();
            } catch (ex) {}
          }
        }
      } catch (ex) {
        print("Notification Exception: " + ex.toString());
      }
    } else {
      if (settings.authorizationStatus == AuthorizationStatus.authorized) {
        try {
          token = await messaging.getToken();
        } catch (ex) {}
      }
    }
    //print("pushToken:$token");
  }

  static void _onMessageReceived(h_push.RemoteMessage remoteMessage) {
    print("onMessageReceivedStream:${remoteMessage.toMap()}");
  }

  static void _onMessageReceiveError(Object error) {
    print("onMessageReceivedStream:${error.toString()}");
  }

  static Future<bool> isGoogleServicesAvailable() async {
    try {
      GooglePlayServicesAvailability availability = await GoogleApiAvailability.instance.checkGooglePlayServicesAvailability();
      String status = availability.toString().split('.').last;
      if (status == "success") {
        return true;
      }
      return false;
    } catch (ex) {
      return false;
    }
  }

  static void handleMessage(context, Map<String, dynamic> messageData) {
    if (messageData["requestType"] != null && messageData["requestNumber"] != null) {
      Widget? serviceClass;

      String? transactionType = messageData["transactionType"]?.toString();

      if (transactionType == null) {
        return;
      } else if (transactionType == "17" && messageData["requestType"] == "chat") {
        int moduleId = int.parse(messageData["moduleId"].toString());
        int requestNumber = int.parse(messageData["requestNumber"].toString());

        switch (moduleId) {
          case 1: // cm
            serviceClass = CMDetailPage(requestId: requestNumber, moduleId: moduleId);
            break;
          case 2: // gas refill
            serviceClass = GasRefillDetailsPage(
              priority: messageData["priority"],
              date: messageData["createdOn"],
              moduleId: moduleId,
              model: GasRefillModel(id: requestNumber),
            );
            break;
          case 3: //transfer
            serviceClass = DeviceTransferDetails(model: DeviceTransfer(id: requestNumber), moduleId: moduleId);
            break;
          case 6: // task
            serviceClass = TaskRequestDetailsView(
              taskId: requestNumber,
              moduleId: moduleId,
              // requestDetails: RequestsDetails(nameOfType: requestData?.nameOfType, status: requestData?.statusName, priority: requestData?.priorityName, date: requestData?.transactionDate,                  ),
            );
            // ServiceRequestDetailMain(requestId: int.parse(messageData["requestNumber"].toString()), moduleId: 1);
            break;

          default:
            serviceClass = const Scaffold(appBar: DefaultAppBar(), body: Center(child: NoDataFound()));
        }

        Navigator.of(context).push(MaterialPageRoute(builder: (_) => serviceClass!));
        return;
      }

      switch (transactionType) {
        case "1":
          serviceClass = CMDetailPage(requestId: int.parse(messageData["requestNumber"].toString()), moduleId: 1);
          break;
        case "2":
          serviceClass = GasRefillDetailsPage(
            priority: messageData["priority"],
            date: messageData["createdOn"],
            moduleId: 2,
            model: GasRefillModel(id: int.parse(messageData["requestNumber"].toString())),
          );
          break;
        case "3":
          serviceClass = DeviceTransferDetails(model: DeviceTransfer(id: int.parse(messageData["requestNumber"].toString())), moduleId: 3);
          break;
        case "4":
          serviceClass = PpmDetailsPage(requestId: int.parse(messageData["requestNumber"].toString()));
          break;
        case "5":
          serviceClass = RecurrentWorkOrderView(taskId: int.parse(messageData["requestNumber"].toString()));
          break;
        case "6":
          serviceClass = TaskRequestDetailsView(
              taskId: int.parse(messageData["requestNumber"].toString()),
              requestDetails: RequestsDetails(nameOfType: messageData["sourceName"], status: messageData["statusName"], priority: messageData["priorityName"], date: messageData["createdDate"]),
              moduleId: 6);
          break;
        case "7":
          serviceClass = TaskRequestDetailsView(
              taskId: int.parse(messageData["requestNumber"].toString()),
              requestDetails: RequestsDetails(nameOfType: messageData["sourceName"], status: messageData["statusName"], priority: messageData["priorityName"], date: messageData["createdDate"]),
              moduleId: 7);
          break;
      // case "8":
      //   serviceClass = AssetInventoryDetailView(requestId: int.parse(messageData["requestNumber"].toString()), moduleId: 1);
      //   break;
        case "9":
          serviceClass = TrafRequestDetailPage(trafId: int.parse(messageData["requestNumber"].toString()));
          break;
        case "10":
          serviceClass = EquipmentInternalAuditDetailPage(auditId: int.parse(messageData["requestNumber"].toString()));
          break;
        case "11":
          serviceClass = SystemInternalAuditDetailPage(auditId: int.parse(messageData["requestNumber"].toString()));
          break;
        case "12":
          serviceClass = LoanEquipmentDetailPage(loanId: int.parse(messageData["requestNumber"].toString()));
          break;
      // case "13":
      //   serviceClass = AssetDeliveryPage(requestId: int.parse(messageData["requestNumber"].toString()));
      //   break;
        case "14":
          serviceClass = MedicalGasInspectionDetailPage(inspectionId: int.parse(messageData["requestNumber"].toString()), prority: messageData["priorityName"]);
          break;
        case "15":
          serviceClass = DemoDetailViewPage(demoId: int.parse(messageData["requestNumber"].toString()), moduleId: 15);
          break;
        case "16":
          serviceClass = IncidentDetailPage(incidentId: int.parse(messageData["requestNumber"].toString()));
          break;
        case "17":
          serviceClass = SurveyPage(surveyId: int.parse(messageData["requestNumber"].toString()));

        default:
          serviceClass = const Scaffold(appBar: DefaultAppBar(), body: Center(child: NoDataFound()));
      }

      Navigator.of(context).push(MaterialPageRoute(builder: (_) => serviceClass!));
    }
  }

  static initialized(BuildContext context) async {
//TOD0 add platform check here also
    if (!(await isGoogleServicesAvailable()) && Platform.isAndroid) {
      var initialNotification = await h_push.Push.getInitialNotification();
      if (initialNotification != null) {
        Map<String, dynamic> remoteData = Map<String, dynamic>.from(initialNotification["extras"] as Map);
        handleMessage(context, remoteData);
      }

      h_push.Push.onNotificationOpenedApp.listen((message) {
        try {
          if (message is Map<String, dynamic>) {
            Map<String, dynamic> remoteData = message;
            remoteData = remoteData["extras"];

            handleMessage(context, remoteData);
          }
        } catch (ex) {
          print("parsingError:$ex");
        }
      }, onError: (e) => print("onNotificationOpenedApp Error${e.toString()}"));
      return;
    }

    NotificationSettings settings;

    try {
      settings = await messaging.requestPermission(
        alert: true,
        announcement: false,
        badge: true,
        carPlay: false,
        criticalAlert: false,
        provisional: false,
        sound: true,
      );
    } catch (error) {
      return;
    }

    if (settings.authorizationStatus != AuthorizationStatus.authorized) {
      return;
    }

    await FirebaseMessaging.instance.setAutoInitEnabled(true);
    await FirebaseMessaging.instance.setForegroundNotificationPresentationOptions(alert: true, badge: false, sound: true);

    FirebaseMessaging.instance.getInitialMessage().then((initialMessage) {
      if (initialMessage != null) {
        handleMessage(context, initialMessage.data);
      }
    });

    FirebaseMessaging.onMessage.listen((RemoteMessage message) {
      if (Platform.isAndroid) {
        if (message.data["notificationType"] != 'NurseConfirmArrive') {
          // Extract title and body from notification field first, fallback to data field
          final String title = message.notification?.title ?? message.data['title'] ?? 'ATOMS';
          final String body = message.notification?.body ?? message.data['body'] ?? 'New notification';

          // Always show with our grouping logic
          NotificationManger.showNotification(
              title: title,
              subtext: body,
              hashcode: DateTime.now().millisecondsSinceEpoch.hashCode,
              payload: json.encode(message.data),
              context: context);

          // Update unread notification count badge when new notification arrives
          try {
            final notificationsProvider = Provider.of<NotificationsProvider>(context, listen: false);
            notificationsProvider.getUnreadCount();
          } catch (e) {
            log('Error updating notification count: $e');
          }
        }
      }
      return;
    });
    FirebaseMessaging.onMessageOpenedApp.listen((RemoteMessage message) {
      handleMessage(context, message.data);
    });
    FirebaseMessaging.onBackgroundMessage(firebaseMessagingBackgroundHandler);
  }
}