import 'dart:async';
import 'dart:convert';
import 'dart:io';
import 'package:intl/date_symbol_data_local.dart';
import 'package:sefer_driver/views/home/Captin/orderCaptin/order_request_page.dart';
import 'package:firebase_core/firebase_core.dart';
import 'package:firebase_messaging/firebase_messaging.dart';
import 'package:flutter/material.dart';
import 'package:flutter_local_notifications/flutter_local_notifications.dart';
import 'package:flutter_overlay_window/flutter_overlay_window.dart';
import 'package:flutter_secure_storage/flutter_secure_storage.dart';
import 'package:flutter_stripe/flutter_stripe.dart';
import 'package:get/get.dart';
import 'package:get_storage/get_storage.dart';
import 'package:flutter/services.dart';
import 'package:wakelock_plus/wakelock_plus.dart';
import 'constant/api_key.dart';
import 'constant/info.dart';
import 'controller/firebase/firbase_messge.dart';
import 'controller/firebase/local_notification.dart';
import 'controller/functions/add_error.dart';
import 'controller/functions/battery_status.dart';
import 'controller/functions/crud.dart';
import 'controller/functions/encrypt_decrypt.dart';
import 'controller/functions/secure_storage.dart';
import 'controller/local/local_controller.dart';
import 'controller/local/translations.dart';
import 'firebase_options.dart';
import 'models/db_sql.dart';
import 'print.dart';
import 'splash_screen_page.dart';
import 'views/home/Captin/driver_map_page.dart';
import 'views/home/Captin/orderCaptin/order_over_lay.dart';

final box = GetStorage();
const storage = FlutterSecureStorage();
DbSql sql = DbSql.instance;
final GlobalKey<NavigatorState> navigatorKey = GlobalKey<NavigatorState>();
const platform = MethodChannel('com.example.intaleq_driver/app_control');

@pragma('vm:entry-point')
Future<void> backgroundMessageHandler(RemoteMessage message) async {
  WidgetsFlutterBinding.ensureInitialized();
  await Firebase.initializeApp(options: DefaultFirebaseOptions.currentPlatform);
  await GetStorage.init();

  if (!Get.isRegistered<NotificationController>()) {
    Get.put(NotificationController());
  }
  if (!Get.isRegistered<FirebaseMessagesController>()) {
    Get.put(FirebaseMessagesController());
  }

  if (!await FlutterOverlayWindow.isPermissionGranted()) {
    Log.print("Overlay permission not granted; showing only notification.");
  }

  if (Platform.isAndroid) {
    if (message.notification != null && message.notification!.title != null) {
      Log.print('message.notification!.title: ${message.notification!.title}');

      if (message.notification?.title == 'Order' ||
          message.notification?.title == 'OrderSpeed') {
        var myListString = message.data['DriverList'] ?? '[]';
        Log.print('myListString: $myListString');

        List<dynamic> myList;
        try {
          myList = jsonDecode(myListString) as List<dynamic>;
        } catch (e) {
          Log.print('Error decoding JSON: $e');
          myList = [];
        }

        bool isOverlayActive = await FlutterOverlayWindow.isActive();
        if (isOverlayActive) {
          await FlutterOverlayWindow.shareData(myList);
        } else {
          await FlutterOverlayWindow.showOverlay(
            enableDrag: true,
            flag: OverlayFlag.focusPointer,
            positionGravity: PositionGravity.auto,
            height: 1400,
            width: WindowSize.matchParent,
            startPosition: const OverlayPosition(0, -30),
          );
          await FlutterOverlayWindow.shareData(myList);
        }

        NotificationController().showNotification(
          message.notification!.title.toString(),
          message.notification!.body.toString(),
          'order',
          myListString,
        );
      } else {
        FirebaseMessagesController().fireBaseTitles(message);
      }
    }
  }
}

@pragma('vm:entry-point')
void notificationTapBackground(NotificationResponse notificationResponse) {
  Log.print('Notification tapped in background!');
  NotificationController().handleNotificationResponse(notificationResponse);
}

@pragma('vm:entry-point')
void overlayMain() async {
  WidgetsFlutterBinding.ensureInitialized();
  await GetStorage.init();
  await Firebase.initializeApp(
    options: DefaultFirebaseOptions.currentPlatform,
  );

  if (!Get.isRegistered<NotificationController>()) {
    Get.put(NotificationController());
  }

  runApp(const MaterialApp(
    debugShowCheckedModeBanner: false,
    home: OrderOverlay(),
  ));
}

Future<void> closeOverLay() async {
  bool isOverlayActive = await FlutterOverlayWindow.isActive();
  if (isOverlayActive) {
    await FlutterOverlayWindow.closeOverlay();
  }
}

void main() async {
  WidgetsFlutterBinding.ensureInitialized();
  await Firebase.initializeApp(options: DefaultFirebaseOptions.currentPlatform);

  await WakelockPlus.enable();
  await GetStorage.init();
  await initializeDateFormatting();
  Stripe.publishableKey = AK.publishableKeyStripe;
  SystemChrome.setPreferredOrientations([
    DeviceOrientation.portraitUp,
    DeviceOrientation.portraitDown,
  ]);
  runZonedGuarded<Future<void>>(() async {
    runApp(const MyApp());
  }, (error, stack) {
    // ==== START: ERROR FILTER ====
    String errorString = error.toString();

    // Print all errors to the local debug console for development
    print("Caught Dart error: $error");
    print(stack);

    // We will check if the error contains keywords for errors we want to ignore.
    // If it's one of them, we will NOT send it to the server.
    bool isIgnoredError = errorString.contains('PERMISSION_DENIED') ||
        errorString.contains('FormatException') ||
        errorString.contains('Null check operator used on a null value');

    if (!isIgnoredError) {
      // Only send the error to the server if it's not in our ignore list.
      CRUD.addError(error.toString(), stack.toString(), 'main');
    } else {
      print("Ignoring error and not sending to server: $errorString");
    }
    // ==== END: ERROR FILTER ====
  });
}

class MyApp extends StatefulWidget {
  const MyApp({Key? key}) : super(key: key);

  @override
  _MyAppState createState() => _MyAppState();
}

class _MyAppState extends State<MyApp> with WidgetsBindingObserver {
  @override
  void initState() {
    super.initState();
    WidgetsBinding.instance.addObserver(this);
    _initApp();
  }

  @override
  void dispose() {
    super.dispose();
  }

  Future<void> _initApp() async {
    try {
      final AppInitializer initializer = AppInitializer();
      await initializer.initializeApp();
      await EncryptionHelper.initialize();

      if (!Get.isRegistered<NotificationController>()) {
        Get.put(NotificationController());
      }

      if (!Get.isRegistered<FirebaseMessagesController>()) {
        Get.put(FirebaseMessagesController());
      }

      await FirebaseMessaging.instance.requestPermission();
      FirebaseMessaging.onBackgroundMessage(backgroundMessageHandler);
      await FirebaseMessagesController().getToken();
      await NotificationController().initNotifications();
    } catch (e) {
      Log.print("Error during _initApp: $e");
    }
  }

  @override
  Widget build(BuildContext context) {
    LocaleController localController = Get.put(LocaleController());
    return GetMaterialApp(
      navigatorKey: navigatorKey,
      title: AppInformation.appName,
      translations: MyTranslation(),
      debugShowCheckedModeBanner: false,
      locale: localController.language,
      theme: localController.appTheme,
      initialRoute: '/',
      getPages: [
        GetPage(name: '/', page: () => SplashScreen()),
        GetPage(name: '/order-page', page: () => OrderRequestPage()),
        GetPage(
            name: '/passenger-location-map',
            page: () => PassengerLocationMapPage()),
      ],
    );
  }
}
