import 'dart:convert';
import 'package:firebase_messaging/firebase_messaging.dart';
import 'package:flutter/cupertino.dart';
import 'package:flutter_callkit_incoming/entities/entities.dart';
import 'package:flutter_callkit_incoming/flutter_callkit_incoming.dart';
import 'package:mohem_flutter_app/app_state/app_state.dart';
import 'package:mohem_flutter_app/classes/utils.dart';
import 'package:mohem_flutter_app/config/routes.dart';
import 'package:mohem_flutter_app/main.dart';
import 'package:mohem_flutter_app/models/chat/call.dart';
import 'package:mohem_flutter_app/models/chat/get_single_user_chat_list_model.dart';
import 'package:mohem_flutter_app/models/chat/get_user_login_token_model.dart' as ALM;
import 'package:mohem_flutter_app/models/chat/get_user_login_token_model.dart';
import 'package:mohem_flutter_app/provider/chat_call_provider.dart';
import 'package:mohem_flutter_app/provider/chat_provider_model.dart';
import 'package:provider/provider.dart';

class ChatVoipCall extends WidgetsBindingObserver {
  static final ChatVoipCall _instance = ChatVoipCall._internal();

  ChatVoipCall._internal();

  factory ChatVoipCall() => _instance;

  late ChatProviderModel prov;
  late ChatCallProvider cProv;
  dynamic inCallData;
  bool isUserOnline = false;
  dynamic callData;

  Future<void> showCallkitIncoming({required String uuid, RemoteMessage? data, CallDataModel? incomingCallData, bool background = false}) async {
    await ChatVoipCall().listenerEvent();
    await FlutterCallkitIncoming.endAllCalls();
    ALM.Response autoLoginData;
    SingleUserChatModel callerData;
    if (data!.data["user_token_response"] == null || data.data["user_token_response"].isEmpty) {
      logger.d(AppState().getchatUserDetails!.response!.toJson());
      // Online & App Logged In
      autoLoginData =  ALM.Response.fromJson(AppState().getchatUserDetails!.response!.toJson());
      dynamic items = jsonDecode(data!.data["user_chat_history_response"]);
      callerData = SingleUserChatModel(
          targetUserId: items["CurrentUserId"],
          targetUserEmail: items["CurrentUserEmail"],
          targetUserName: items["CurrentUserName"].split("@").first,
          currentUserId: autoLoginData.id,
          currentUserEmail: autoLoginData.email,
          currentUserName: autoLoginData.userName,
          chatEventId: 3);
      isUserOnline = true;
    } else {
      // Offline or App in Background or App is At Verify Screen
      autoLoginData = ALM.Response.fromJson(jsonDecode(data.data["user_token_response"]));
      callerData = SingleUserChatModel.fromJson(json.decode(data!.data["user_chat_history_response"]));
    }
    CallKitParams params = CallKitParams(
      id: uuid,
      nameCaller: callerData.targetUserName,
      appName: 'Mohemm',
      handle: '',
      type: 0,
      duration: 25000,
      textAccept: 'Accept',
      textDecline: 'Decline',
      textMissedCall: 'Missed call',
      textCallback: 'Call back',
      extra: {
        "loginDetails": autoLoginData.toJson(),
        "callerDetails": callerData.toJson(),
        'isIncomingCall': true,
      },
      android: const AndroidParams(
        isCustomNotification: true,
        isShowLogo: false,
        isShowCallback: false,
        isShowMissedCallNotification: true,
        ringtonePath: 'system_ringtone_default',
        backgroundColor: '#0955fa',
        backgroundUrl: 'assets/test.png',
        actionColor: '#4CAF50',
      ),
      ios: IOSParams(
        iconName: 'Mohemm',
        handleType: '',
        supportsVideo: true,
        maximumCallGroups: 2,
        maximumCallsPerCallGroup: 1,
        audioSessionMode: 'default',
        audioSessionActive: true,
        audioSessionPreferredSampleRate: 38000.0,
        audioSessionPreferredIOBufferDuration: 0.005,
        supportsDTMF: true,
        supportsHolding: true,
        supportsGrouping: false,
        supportsUngrouping: false,
        ringtonePath: 'system_ringtone_default',
      ),
    );
    if (callerData.chatEventId == 3) {
      await Utils.saveStringFromPrefs("isIncomingCall", "true");
      await FlutterCallkitIncoming.showCallkitIncoming(params);
    }
  }

  Future<void> initProviders() async {
    cProv = Provider.of<ChatCallProvider>(AppRoutes.navigatorKey.currentContext!, listen: false);
    prov = Provider.of<ChatProviderModel>(AppRoutes.navigatorKey.currentContext!, listen: false);
  }

  void connection({required data, required bool isUserOnline}) async {
    if (isUserOnline) {
      cProv.isUserOnline = isUserOnline;
      cProv.startIncomingCallViaKit(inCallData: data);
    } else {
      dynamic callData = await jsonDecode(data);
      AppState().setchatUserDetails = UserAutoLoginModel(
        response: Response.fromJson(callData[0]["loginDetails"]),
        errorResponses: null,
      );
      cProv.startIncomingCallViaKit(inCallData: data);
      try {
        await prov.buildHubConnection(context: AppRoutes.navigatorKey.currentContext!, ccProvider: cProv).whenComplete(() {
          cProv.init();
        });
      } catch (e) {
        logger.w(e);
      }
    }
  }

  Future getCurrentCall() async {
    var calls = await FlutterCallkitIncoming.activeCalls();
    if (calls is List) {
      if (calls.isNotEmpty) {
        print('DATA------------: $calls');
        return calls[0];
      } else {
        return null;
      }
    }
  }

  void checkAndNavigationCallingPage() async {
    var currentCall = await getCurrentCall();
    if (currentCall != null) {
      Future.delayed(const Duration(seconds: 2)).whenComplete(() {
        Navigator.pushNamed(AppRoutes.navigatorKey.currentContext!, AppRoutes.chatStartCall);
        // NavigationService.instance
        //     .pushNamedIfNotCurrent(AppRoute.callingPage, args: currentCall);
      });
    }
  }
  Future<void> isCall() async {
    var calls = await FlutterCallkitIncoming.activeCalls();
    if (calls is List) {
      if (calls.isNotEmpty) {
        Navigator.pushNamed(AppRoutes.navigatorKey.currentContext!, AppRoutes.chatStartCall);
      }
    }
  }
//Function(CallEvent) callback
  Future<void> listenerEvent() async {
    try {
      FlutterCallkitIncoming.onEvent.listen((CallEvent? event) async {
        switch (event!.event) {
          case Event.ACTION_CALL_INCOMING:
            break;
          case Event.ACTION_CALL_START:
            break;
          case Event.ACTION_CALL_ACCEPT:
            print("------------------------------------------Call Accepted By User ----------------------------------------------");
            if (isUserOnline) {
              checkAndNavigationCallingPage();
            } else {
              Utils.showToast("BackgroundState Else Started", longDuration: true);
              isCall();
              
            }

           // checkAndNavigationCallingPage();
            // Navigator.pushNamed(AppRoutes.navigatorKey.currentContext!, AppRoutes.chatStartCall);
            // checkAndNavigationCallingPage();

            break;
          case Event.ACTION_CALL_DECLINE:
            cProv.isIncomingCall = true;
            Utils.saveStringFromPrefs("isIncomingCall", "false");
            Utils.saveStringFromPrefs("inComingCallData", "null");
            cProv.endCall();
            FlutterCallkitIncoming.endAllCalls();
            break;
          case Event.ACTION_CALL_ENDED:
            Utils.saveStringFromPrefs("isIncomingCall", "false");
            Utils.saveStringFromPrefs("inComingCallData", "null");
            FlutterCallkitIncoming.endAllCalls();
            break;
          case Event.ACTION_CALL_TIMEOUT:
            Utils.saveStringFromPrefs("isIncomingCall", "false");
            Utils.saveStringFromPrefs("inComingCallData", "null");
            break;
          case Event.ACTION_CALL_CALLBACK:
            // TODO: only Android - click action `Call back` from missed call notification
            break;
          case Event.ACTION_CALL_TOGGLE_HOLD:
            // TODO: only iOS
            break;
          case Event.ACTION_CALL_TOGGLE_MUTE:
            // TODO: only iOS
            break;
          case Event.ACTION_CALL_TOGGLE_DMTF:
            // TODO: only iOS
            break;
          case Event.ACTION_CALL_TOGGLE_GROUP:
            // TODO: only iOS
            break;
          case Event.ACTION_CALL_TOGGLE_AUDIO_SESSION:
            // TODO: only iOS
            break;
          case Event.ACTION_DID_UPDATE_DEVICE_PUSH_TOKEN_VOIP:
            // TODO: only iOS
            break;
        }
      });
    } on Exception {}
  }

//
// void didChangeAppLifecycleState(AppLifecycleState state) {
//   super.didChangeAppLifecycleState(state);
//   switch (state) {
//     case AppLifecycleState.paused:
//       logger.i('paused');
//       break;
//     case AppLifecycleState.inactive:
//       logger.i('inactive');
//       break;
//     case AppLifecycleState.resumed:
//       logger.i('resumed');
//       break;
//     case AppLifecycleState.detached:
//       logger.i('detached');
//       break;
//   }
// }

// @override
// void dispose() {
//   WidgetsBinding.instance.removeObserver(this);
// }

  void nothing() {
    // if (!background) {
    //   await initProviders();
    //   if (data!.data["callType"] == "video") {
    //     cProv.isVideoCall = true;
    //   } else {
    //     cProv.isAudioCall = true;
    //     cProv.isVideoCall = false;
    //   }
    // }
    //
    // // if(!background){}
    // await initProviders();

    //   callData = jsonEncode([
    //       {
    //         "loginDetails": autoLoginData.toJson(),
    //         "callerDetails": callerData.toJson(),
    //       }
    //     ]);

    // connection(data: callData, isUserOnline: isUserOnline).whenComplete(() => {});
    // if (isUserOnline) {
    //   cProv.init();
    // }
    // if (!isUserOnline) {
    //   initProviders();
    // }
    // Navigator.pushNamed(AppRoutes.navigatorKey.currentContext!, AppRoutes.chatStartCall);
  }

//
// @override
// void dispose() {
//   WidgetsBinding.instance.removeObserver(this);
// }
}