import 'dart:async';
import 'dart:convert';
import 'dart:io';
import 'package:f_r_e_hub/app_state.dart';
import 'package:f_r_e_hub/backend/api_requests/api_calls.dart';
import 'package:flutter/material.dart';
import 'package:firebase_messaging/firebase_messaging.dart';
import 'package:flutter_local_notifications/flutter_local_notifications.dart';
import 'package:rxdart/rxdart.dart';
import 'package:f_r_e_hub/components/templates_components/visit_request_template_component/visit_request_template_component_widget.dart';

class PushNotificationService {
  final FirebaseMessaging _firebaseMessaging = FirebaseMessaging.instance;
  final FlutterLocalNotificationsPlugin _flutterLocalNotificationsPlugin =
      FlutterLocalNotificationsPlugin();
  final Subject<RemoteMessage> _onMessage = BehaviorSubject<RemoteMessage>();
  final BehaviorSubject<BuildContext> _context =
      BehaviorSubject<BuildContext>();

  PushNotificationService() {
    _initializeLocalNotifications(_context);
    _createNotificationChannels();
  }

  Future<void> initialize(BuildContext context) async {
    _context.add(context);
    await _requestPermissions();
    _listenToForegroundMessages(context);
    _listenToBackgroundMessages();
    _listenToNotificationClicks(context);
    await updateDeviceToken();
  }

  Future<void> _requestPermissions() async {
    NotificationSettings settings = await _firebaseMessaging.requestPermission(
      alert: true,
      badge: true,
      sound: true,
    );
    if (settings.authorizationStatus == AuthorizationStatus.authorized) {
      debugPrint('User granted permission');
    } else {
      debugPrint('User declined or has not accepted permission');
    }
  }

  Map<String, dynamic> validJsonFromString(String? jsonString) {
    if (jsonString == null || jsonString.isEmpty) {
      return {};
    }

    // Passo 1 e 2: Adiciona aspas duplas em torno das chaves e valores que não estão corretamente delimitados
    String correctedJson = jsonString.replaceAllMapped(
        RegExp(r'([a-zA-Z0-9_]+)\s*:\s*([^",\}\]]+)'), (match) {
      var key = '"${match[1]!}"'; // Chaves sempre recebem aspas
      var value = match[2]!.trim();

      // Verifica se o valor é uma string (não numérica, booleana, nula ou objeto JSON)
      bool isStringValue = !RegExp(r'^-?\d+(\.\d+)?$').hasMatch(value) &&
          value != 'true' &&
          value != 'false' &&
          value != 'null' &&
          !value.startsWith('{') &&
          !value.endsWith('}');

      // Adiciona aspas duplas em torno do valor se for uma string
      String quotedValue = isStringValue ? '"$value"' : value;

      return '$key: $quotedValue';
    });

    // Passo 3: Tratar corretamente strings JSON aninhadas
    correctedJson =
        correctedJson.replaceAllMapped(RegExp(r'"{([^"]+)}"'), (match) {
      // Remove as aspas duplas extras em torno de objetos JSON aninhados
      return '{${match[1]!}}';
    });

    try {
      // Passo 4: Decodificar o JSON corrigido
      return jsonDecode(correctedJson);
    } catch (e) {
      print('Error decoding JSON: $e');
      return {};
    }
  }

  void _initializeLocalNotifications(
      BehaviorSubject<BuildContext> context) async {
    while (context.valueOrNull == null) {
      await Future.delayed(Duration(milliseconds: 100));
    }

    var initializationSettingsAndroid =
        AndroidInitializationSettings('mipmap/ic_fre_black');
    var initializationSettingsIOS = DarwinInitializationSettings(
      requestAlertPermission: true,
      requestBadgePermission: true,
      requestSoundPermission: true,
    );
    var initializationSettings = InitializationSettings(
      android: initializationSettingsAndroid,
      iOS: initializationSettingsIOS,
    );
    _flutterLocalNotificationsPlugin.initialize(
      initializationSettings,
      onDidReceiveNotificationResponse: (NotificationResponse response) async {
        debugPrint('Response payload:${response.payload}');
        if (response.payload != null) {
          try {
            Map<String, dynamic> message =
                validJsonFromString(response.payload!);
            debugPrint('Notification payload: $message');
            _handleNotificationClick(message);
          } catch (e) {
            debugPrint('Error decoding notification payload: $e');
          }
        }
      },
    );
  }

  void _createNotificationChannels() {
    List<String> actions = [
      'visit_request',
      'visit_response',
      'access',
      'mensagem',
      'enroll_cond',
      'miscellaneous'
    ];
    for (String action in actions) {
      _createNotificationChannel(action, "Channel for $action");
    }
  }

  void _createNotificationChannel(String channelId, String channelName) {
    _flutterLocalNotificationsPlugin
        .resolvePlatformSpecificImplementation<
            AndroidFlutterLocalNotificationsPlugin>()
        ?.createNotificationChannel(
          AndroidNotificationChannel(
            channelId, // Use o click_action como ID do canal
            channelName, // Nome descritivo baseado no click_action
            description: 'Channel for $channelName notifications',
            importance: Importance.max,
          ),
        );
  }

  void _listenToForegroundMessages(BuildContext context) {
    FirebaseMessaging.onMessage.listen((RemoteMessage message) {
      debugPrint('Got a message whilst in the foreground!');
      debugPrint('Message data: ${message.toMap()}');
      _onMessage.add(message);
      _showNotification(message);
    });
  }

  void _listenToBackgroundMessages() {
    FirebaseMessaging.onBackgroundMessage(_firebaseMessagingBackgroundHandler);
  }

  void _listenToNotificationClicks(BuildContext context) {
    FirebaseMessaging.onMessageOpenedApp.listen((RemoteMessage message) {
      debugPrint('Notification clicked!');

      _onMessage.add(message);
      NotificationHandler().handleMessage(message.data, context);
    });
  }

  void configureTokenRefresh() {
    _firebaseMessaging.onTokenRefresh.listen(_handleTokenUpdate).onError((err) {
      debugPrint("Error refreshing token: $err");
    });
  }

  Future<void> _updateToken(String token) async {
    FFAppState().token = token;
    final ApiCallResponse? response = await _updateTokenOnServer(token);
    if (_isTokenUpdateSuccessful(response)) {
      debugPrint('Token updated successfully on server. Token: $token');
    } else {
      debugPrint('Error updating token on server');
    }
  }

  Future<void> _handleTokenUpdate(String newToken) async {
    debugPrint('Token refreshed: $newToken');
    await _updateToken(newToken);
  }

  Future<void> updateDeviceToken() async {
    configureTokenRefresh();

    final NotificationSettings settings =
        await _requestNotificationPermission();
    if (Platform.isIOS) await _fetchAndLogApnsToken(settings);

    final String? deviceToken = await _firebaseMessaging.getToken();
    if (deviceToken != null) {
      debugPrint('Push Messaging token: $deviceToken');
      await _updateToken(deviceToken);
    } else {
      debugPrint('Failed to get Firebase Messaging token');
    }
  }

  Future<NotificationSettings> _requestNotificationPermission() async {
    final NotificationSettings settings =
        await _firebaseMessaging.requestPermission();
    debugPrint(settings.authorizationStatus == AuthorizationStatus.authorized
        ? 'User granted permission'
        : 'User declined or has not accepted permission');
    return settings;
  }

  Future<void> _fetchAndLogApnsToken(NotificationSettings settings) async {
    if (settings.authorizationStatus == AuthorizationStatus.authorized) {
      final String? apnsToken = await _firebaseMessaging.getAPNSToken();
      debugPrint(apnsToken != null
          ? 'APNS Token: $apnsToken'
          : 'Failed to get APNS token');
    }
  }

  Future<ApiCallResponse?> _updateTokenOnServer(String deviceToken) async {
    return await PhpGroup.updToken.call(
      token: deviceToken,
      devid: FFAppState().devUUID,
      useruuid: FFAppState().userUUID,
    );
  }

  bool _isTokenUpdateSuccessful(ApiCallResponse? response) {
    return PhpGroup.updToken.error((response?.jsonBody ?? '')) == false;
  }

  String _getChannelIdBasedOnClickAction(String clickAction) {
    // Retorna o ID do canal com base no click_action
    // Exemplo simples, pode ser expandido conforme necessário
    switch (clickAction) {
      case 'visit_request':
        return 'visit_request';
      case '':
        return 'visit_response';
      case 'access':
        return 'access';
      case 'mensagem':
        return 'mensagem';
      case 'enroll_cond':
        return 'enroll_cond';
      default:
        return 'miscellaneous';
    }
  }

  void _showNotification(RemoteMessage message) async {
    String channelId =
        _getChannelIdBasedOnClickAction(message.data['click_action']);
    var androidDetails = AndroidNotificationDetails(
      channelId,
      'Channel Name for $channelId',
      channelDescription: 'Channel Description for $channelId',
      importance: Importance.max,
      priority: Priority.high,
    );
    var iOSDetails = DarwinNotificationDetails();
    var generalNotificationDetails =
        NotificationDetails(android: androidDetails, iOS: iOSDetails);

    await _flutterLocalNotificationsPlugin.show(
      message.hashCode,
      message.notification?.title,
      message.notification?.body,
      generalNotificationDetails,
      payload: message.data.toString(),
    );
  }

  _handleNotificationClick(Map<String, dynamic> payload) {
    switch (payload.isNotEmpty) {
      case true:
        // Print the 'data' property
        debugPrint('Notification payload: $payload');
        // Handle the message data as needed
        NotificationHandler().handleMessage(payload, _context.value);
      // Access the 'data' property of 'RemoteMessage'
      case false:
        debugPrint('Notification payload is empty');
        // Handle the message notification as needed
        break;
    }
  }

  static Future<void> _firebaseMessagingBackgroundHandler(
      RemoteMessage message) async {
    debugPrint('Handling a background message: ${message.messageId}');
  }
}

class NotificationHandler {
  void handleMessage(Map<String, dynamic> message, BuildContext context) {
    debugPrint('Notification Received!');
    message.forEach((key, value) {
      debugPrint('$key: $value');
    });

    switch (message['click_action']) {
      case 'visit_request':
        _showVisitRequestDialog(message, context);

        break;
      case '':
        debugPrint('visit_response');
        break;
      case 'access':
        debugPrint('access');
        break;
      case 'mensagem':
        debugPrint('mensagem');
        break;
      case 'enroll_cond':
        debugPrint('enroll_cond');
        break;
      default:
        debugPrint('Notification type not recognized');
    }
  }

  void _showVisitRequestDialog(
      Map<String, dynamic> message, BuildContext context) {
    debugPrint('Showing visit request dialog');
    showDialog(
      context: context,
      builder: (BuildContext context) {
        return Dialog(
          backgroundColor: Colors.transparent,
          child: VisitRequestTemplateComponentWidget(
            vteName: message['VTE_NOME'] ?? 'Unknown',
            vteReason: message['motivo'] ?? 'Unknown',
            vteMsg: message['mensagem'] ?? 'Unknown',
            vteDocument: message['documento'],
            vteUUID: message['idVisitante'].toString(),
            vawRef: message['referencia'].toString(),
          ),
        );
      },
    );
  }
}