import 'dart:async';
import 'dart:developer' as dev;
import 'package:pubnub/pubnub.dart';
import 'package:connectivity_plus/connectivity_plus.dart';
import '../../config/constants/app_constant.dart';
import '../../network/kafkahandler.dart';
import '../../providers/utils_singleton.dart';

class UserContext {
  final String username;
  UserContext({required this.username});
}

class PubNubManager {
  // CRITICAL FIX: True singleton pattern - NEVER dispose during app lifecycle
  static PubNubManager? _instance;
  static PubNubManager get instance {
    _instance ??= PubNubManager._();
    return _instance!;
  }

  PubNubManager._();
  StreamSubscription? _kafkaLocationSubscription;
  // Core PubNub components
  PubNub? _pubnub;
  Subscription? _subscription;

  // Timers and subscriptions
  Timer? _heartbeatTimer;
  Timer? _reconnectTimer;
  StreamSubscription? _connectivitySubscription;
  Timer? _cleanupTimer;
  Timer? _subscriptionWatchdog;

  // CRITICAL FIX: Stream controller that NEVER gets disposed during app lifecycle
  StreamController<Map<String, dynamic>>? _rideUpdateController;
  bool _streamControllerCreated = false;

  Stream<Map<String, dynamic>> get rideUpdateStream {
    _ensureStreamController();
    return _rideUpdateController!.stream;
  }

  // State management - REMOVED _isDisposed completely
  bool _isInitialized = false;
  bool _isConnected = false;
  String? _currentUsername;
  int _reconnectAttempts = 0;

  // More conservative settings
  static const int _maxReconnectAttempts = 3;
  static const Duration _reconnectBaseDelay = Duration(seconds: 5);
  static const Duration _heartbeatInterval = Duration(seconds: 45);
  static const Duration _subscriptionWatchdogInterval = Duration(seconds: 60);

  // Message deduplication
  final Set<String> _processedMessages = <String>{};
  static const int _maxProcessedMessages = 100;

  // Track subscription health
  DateTime? _lastMessageReceived;
  int _messageCount = 0;
  bool _subscriptionHealthy = true;

  // CRITICAL FIX: Stream controller created once and NEVER disposed
  void _ensureStreamController() {
    if (!_streamControllerCreated) {
      _rideUpdateController = StreamController<Map<String, dynamic>>.broadcast(
        onListen: () {
          dev.log(
              '🎧 PubNub stream listener added (total listeners: ${_rideUpdateController?.hasListener})');
          _startSubscriptionWatchdog();
        },
        onCancel: () => dev.log('🎧 PubNub stream listener cancelled'),
      );
      _streamControllerCreated = true;
      _startMessageCleanup();
      dev.log('✅ Stream controller created permanently for app lifecycle');
    }
  }

  void _startSubscriptionWatchdog() {
    _subscriptionWatchdog?.cancel();
    _subscriptionWatchdog =
        Timer.periodic(_subscriptionWatchdogInterval, (timer) {
      final now = DateTime.now();
      if (_lastMessageReceived != null) {
        final silentDuration = now.difference(_lastMessageReceived!);
        if (silentDuration.inMinutes > 5 && _isConnected) {
          dev.log(
              '⚠️ Subscription silent for ${silentDuration.inMinutes} minutes, forcing reconnect...');
          _subscriptionHealthy = false;
          forceReconnect();
        }
      }

      dev.log(
          '🐕 Subscription watchdog: ${_messageCount} messages received, healthy: $_subscriptionHealthy');
    });
  }

  void _startMessageCleanup() {
    _cleanupTimer?.cancel();
    _cleanupTimer = Timer.periodic(const Duration(minutes: 2), (timer) {
      if (_processedMessages.length > _maxProcessedMessages) {
        _processedMessages.clear();
        dev.log('🧹 Cleaned processed messages cache');
      }
    });
  }

  // CRITICAL FIX: Allow re-initialization even if previously "disposed"
  Future<void> init(UserContext userContext) async {
    dev.log('🔄 PubNub Manager init called for ${userContext.username}');

    // Always ensure stream controller exists first
    _ensureStreamController();

    if (_isInitialized &&
        _currentUsername == userContext.username &&
        _isConnected &&
        _subscriptionHealthy) {
      dev.log(
          '✅ PubNub already initialized and healthy for ${userContext.username}');
      return;
    }

    dev.log('🔄 Initializing PubNub Manager for ${userContext.username}...');

    _currentUsername = userContext.username;
     KafkaHandler.instance.connect();
    _reconnectAttempts = 0;
    _subscriptionHealthy = true;

    try {
      // Always create fresh PubNub instance
      await _createFreshPubNubInstance(userContext);

      _setupConnectivityListener();
      await _subscribe(userContext.username);
      _startHeartbeat();

      _isInitialized = true;
      dev.log('✅ PubNub Manager initialized successfully');
    } catch (e, stackTrace) {
      dev.log('🔴 Error initializing PubNub: $e',
          error: e, stackTrace: stackTrace);
      _handleInitializationError(e);
    }
  }

  Future<void> _createFreshPubNubInstance(UserContext userContext) async {
    dev.log('🏗️ Creating fresh PubNub instance...');

    // Dispose old instance completely
    if (_pubnub != null) {
      try {
        await _cleanupSubscriptions();
        _pubnub = null;
      } catch (e) {
        dev.log('⚠️ Error disposing old PubNub: $e');
      }
    }

    // Create completely new instance
    final keyset = Keyset(
      subscribeKey: subKey,
      publishKey: pubKey,
      userId: UserId(userContext.username),
    );

    _pubnub = PubNub(defaultKeyset: keyset);

    // Small delay to ensure proper initialization
    await Future.delayed(const Duration(milliseconds: 500));

    dev.log('✅ Fresh PubNub instance created');
  }

  void _handleInitializationError(dynamic error) {
    _isConnected = false;
    _subscriptionHealthy = false;
    _safeAddToStream({
      'error': true,
      'message': 'Connection error. Retrying...',
      'details': error.toString(),
      'timestamp': DateTime.now().millisecondsSinceEpoch,
    });
    _scheduleReconnect();
  }

  void _setupConnectivityListener() {
    _connectivitySubscription?.cancel();
    _connectivitySubscription = Connectivity().onConnectivityChanged.listen(
      (result) async {
        List<ConnectivityResult> results;
        if (result is List<ConnectivityResult>) {
          results = result;
        } else if (result is ConnectivityResult) {
          results = result;
        } else {
          results = [ConnectivityResult.none];
        }

        final nowOnline = results.any((r) => r != ConnectivityResult.none);

        if (nowOnline && !_isConnected) {
          dev.log('📡 Network restored, reconnecting PubNub...');
          _reconnectAttempts = 0;
          await _reconnect();
        } else if (!nowOnline && _isConnected) {
          dev.log('📡 Network lost');
          _isConnected = false;
          _subscriptionHealthy = false;
          _safeAddToStream({
            'error': true,
            'message':
                'Network connection lost. Will reconnect automatically...',
            'timestamp': DateTime.now().millisecondsSinceEpoch,
          });
        }
      },
      onError: (error) {
        dev.log('🔴 Connectivity listener error: $error');
      },
    );
  }

  Future<void> _subscribe(String username) async {
    if (_pubnub == null) return;

    await _cleanupSubscriptions();

    final channels = {
      'user-ride_request-$username',
      'user-ride_updates-$username',
      // 'driver-location',
    };
    await _kafkaLocationSubscription?.cancel(); // Clean up old listener
    _kafkaLocationSubscription = KafkaHandler.instance.driverLocationStream.listen((locationData) {
      dev.log('📨 Message received via [Kafka/WebSocket]: $locationData');
      // Add a type or key to identify it as a location update if needed
      locationData['type'] = 'DRIVER_LOCATION_UPDATE';
      _safeAddToStream(locationData);
    });
    KafkaHandler.instance.subscribeToDriverLocations();
    dev.log('📡 Subscribed to Kafka driver-locations topic');
    dev.log('📡 Subscribing to channels: $channels');

    try {
      _subscription =
          _pubnub!.subscribe(channels: channels, withPresence: true);

      // CRITICAL FIX: Robust message handling
      _subscription!.messages.listen(
        (envelope) {
          _lastMessageReceived = DateTime.now();
          _messageCount++;
          _isConnected = true;
          _subscriptionHealthy = true;
          _reconnectAttempts = 0;

          final messageId = _generateMessageId(envelope);

          if (_processedMessages.contains(messageId)) {
            dev.log('⚠️ Duplicate message ignored: $messageId');
            return;
          }

          _processedMessages.add(messageId);
          dev.log(
              '📨 Message received on ${envelope.channel}: ${envelope.payload}');

          try {
            if (envelope.payload is Map<String, dynamic>) {
              final payload = Map<String, dynamic>.from(
                  envelope.payload as Map<String, dynamic>);

              payload['_channel'] = envelope.channel;
              payload['_timestamp'] = DateTime.now().millisecondsSinceEpoch;
              payload['_messageId'] = messageId;
              payload['_timetoken'] = envelope.timetoken;

              _safeAddToStream(payload);
            } else {
              dev.log('⚠️ Received non-map payload: ${envelope.payload}');
            }
          } catch (e) {
            dev.log('🔴 Error processing message: $e');
          }
        },
        onError: (error, stackTrace) {
          dev.log('🔴 Message subscription error: $error');

          _isConnected = false;
          _subscriptionHealthy = false;
          _safeAddToStream({
            'error': true,
            'message': 'Message subscription error. Reconnecting...',
            'timestamp': DateTime.now().millisecondsSinceEpoch,
          });
          _scheduleReconnect();
        },
        onDone: () {
          dev.log('🔴 Message subscription closed unexpectedly');
          _isConnected = false;
          _subscriptionHealthy = false;
          _scheduleReconnect();
        },
        cancelOnError: false,
      );

      // Presence handling
      _subscription!.presence.listen(
        (event) {
          dev.log('👥 Presence event: $event');
          _isConnected = true;
          _subscriptionHealthy = true;

          _safeAddToStream({
            'presence': true,
            'event': event.toString(),
            'connected': true,
            'timestamp': DateTime.now().millisecondsSinceEpoch,
          });
        },
        onError: (error) {
          dev.log('🔴 Presence subscription error: $error');
          _subscriptionHealthy = false;
        },
        cancelOnError: false,
      );

      dev.log('✅ Successfully subscribed to PubNub channels');

      // Send connection confirmation
      _safeAddToStream({
        'connected': true,
        'message': 'Connected to ride updates',
        'channels': channels.toList(),
        'timestamp': DateTime.now().millisecondsSinceEpoch,
      });
    } catch (e, stackTrace) {
      dev.log('🔴 Failed to subscribe: $e');
      dev.log('StackTrace: $stackTrace');

      _isConnected = false;
      _subscriptionHealthy = false;
      _safeAddToStream({
        'error': true,
        'message': 'Failed to connect. Retrying...',
        'timestamp': DateTime.now().millisecondsSinceEpoch,
      });

      _scheduleReconnect();
    }
  }

  String _generateMessageId(dynamic envelope) {
    return '${envelope.channel}_${envelope.timetoken}_${envelope.payload.hashCode}_${DateTime.now().millisecondsSinceEpoch}';
  }

  // CRITICAL FIX: Always safe to add to stream - never fails
  void _safeAddToStream(Map<String, dynamic> data) {
    _ensureStreamController();

    try {
      if (_rideUpdateController != null && !_rideUpdateController!.isClosed) {
        _rideUpdateController!.add(data);
        // dev.log('✅ Added data to stream: ${data.keys.join(', ')}');
      } else {
        dev.log('🔴 Stream controller is null or closed - recreating!');
        // Force recreate if somehow closed
        _streamControllerCreated = false;
        _ensureStreamController();
        _rideUpdateController!.add(data);
      }
    } catch (e, stackTrace) {
      dev.log('🔴 Error adding to stream: $e');
      dev.log('StackTrace: $stackTrace');
    }
  }

  void _scheduleReconnect() {
    if (_reconnectAttempts >= _maxReconnectAttempts) {
      dev.log('🔴 Max reconnection attempts reached');
      _safeAddToStream({
        'error': true,
        'message': 'Connection failed. Please restart the app.',
        'maxAttemptsReached': true,
        'timestamp': DateTime.now().millisecondsSinceEpoch,
      });
      return;
    }

    _reconnectTimer?.cancel();

    final delay = _reconnectBaseDelay * (_reconnectAttempts + 1);
    dev.log(
        '⏰ Scheduling reconnect in ${delay.inSeconds} seconds (attempt ${_reconnectAttempts + 1})');

    _reconnectTimer = Timer(delay, () {
      _reconnect();
    });
  }

  Future<void> _reconnect() async {
    if (!_isInitialized || _currentUsername == null) return;

    _reconnectAttempts++;
    dev.log(
        '🔄 Reconnecting PubNub (attempt $_reconnectAttempts/$_maxReconnectAttempts)...');

    _safeAddToStream({
      'reconnecting': true,
      'message':
          'Reconnecting... (${_reconnectAttempts}/$_maxReconnectAttempts)',
      'attempt': _reconnectAttempts,
      'timestamp': DateTime.now().millisecondsSinceEpoch,
    });

    try {
      await _createFreshPubNubInstance(
          UserContext(username: _currentUsername!));
      await _subscribe(_currentUsername!);
    } catch (e) {
      dev.log('🔴 Reconnection failed: $e');
      _scheduleReconnect();
    }
  }

  void _startHeartbeat() {
    _heartbeatTimer?.cancel();
    _heartbeatTimer = Timer.periodic(_heartbeatInterval, (timer) {
      if (!_isConnected &&
          _isInitialized &&
          _reconnectAttempts < _maxReconnectAttempts) {
        dev.log('💔 Heartbeat detected disconnection, reconnecting...');
        _reconnect();
      } else if (_isConnected && _subscriptionHealthy) {
        dev.log(
            '💓 Heartbeat: Connection healthy, ${_messageCount} messages received');
      }
    });
  }

  Future<bool> publish(String channel, Map<String, dynamic> message) async {
    if (_pubnub == null) {
      dev.log('⚠️ Cannot publish - PubNub not initialized');
      return false;
    }

    if (!_isConnected) {
      dev.log('⚠️ Not connected, cannot publish message');
      return false;
    }

    dev.log('📤 Publishing to $channel: $message');

    try {
      await _pubnub!.publish(channel, message);
      dev.log('✅ Message published successfully');
      return true;
    } catch (e) {
      dev.log('🔴 Publish failed: $e');
      _isConnected = false;
      _subscriptionHealthy = false;
      _scheduleReconnect();
      return false;
    }
  }

  Future<void> _cleanupSubscriptions() async {
    dev.log('🧹 Cleaning up PubNub & Kafka subscriptions...');

    // ✨ 6. CLEAN UP the Kafka subscription as well
    await _kafkaLocationSubscription?.cancel();
    _kafkaLocationSubscription = null;
    KafkaHandler.instance.unsubscribeFromDriverLocations();

    if (_subscription != null && !_subscription!.isCancelled) {
      try {
        _subscription!.dispose();
        dev.log('✅ PubNub subscription disposed');
      } catch (e) {
        dev.log('⚠️ Error disposing subscription: $e');
      }
    }
    _subscription = null;
  }

  // CRITICAL FIX: Never fully dispose during app lifecycle
  void _cleanup() {
    dev.log('🧹 Cleaning up PubNub resources (keeping core alive)...');

    _cleanupSubscriptions();

    _heartbeatTimer?.cancel();
    _heartbeatTimer = null;

    _reconnectTimer?.cancel();
    _reconnectTimer = null;

    _subscriptionWatchdog?.cancel();
    _subscriptionWatchdog = null;

    // Keep connectivity listener and stream controller alive!
    // _connectivitySubscription?.cancel(); // DON'T cancel this
    // _rideUpdateController?.close(); // NEVER close this

    _isConnected = false;
    _subscriptionHealthy = false;
  }

  // IMPROVED: Better force reconnect
  Future<void> forceReconnect() async {
    if (!_isInitialized || _currentUsername == null) {
      dev.log('⚠️ Cannot force reconnect - not initialized or no username');
      return;
    }

    dev.log('🔄 Force reconnecting PubNub...');
    _reconnectAttempts = 0;
    _isConnected = false;
    _subscriptionHealthy = false;

    _safeAddToStream({
      'reconnecting': true,
      'message': 'Force reconnecting...',
      'forced': true,
      'timestamp': DateTime.now().millisecondsSinceEpoch,
    });

    try {
      await _createFreshPubNubInstance(
          UserContext(username: _currentUsername!));
      await _subscribe(_currentUsername!);
    } catch (e) {
      dev.log('🔴 Force reconnect failed: $e');
      _scheduleReconnect();
    }
  }

  bool get isConnected => _isConnected && _subscriptionHealthy;
  bool get isInitialized => _isInitialized;

  Map<String, dynamic> getStatus() {
    return {
      'isConnected': _isConnected,
      'isInitialized': _isInitialized,
      'subscriptionHealthy': _subscriptionHealthy,
      'currentUsername': _currentUsername,
      'reconnectAttempts': _reconnectAttempts,
      'hasActiveSubscription':
          _subscription != null && !_subscription!.isCancelled,
      'hasStreamController':
          _rideUpdateController != null && !_rideUpdateController!.isClosed,
      'processedMessagesCount': _processedMessages.length,
      'messageCount': _messageCount,
      'lastMessageReceived': _lastMessageReceived?.toIso8601String(),
      'maxReconnectAttempts': _maxReconnectAttempts,
      'streamControllerCreated': _streamControllerCreated,
    };
  }

  // CRITICAL FIX: Only allow disposal on app termination, not screen navigation
  void disposeOnAppTermination() {
    dev.log('💀 PubNub Manager disposing on app termination');

    _cleanup();

    _connectivitySubscription?.cancel();
    _connectivitySubscription = null;

    _cleanupTimer?.cancel();
    _cleanupTimer = null;

    // Only now close the stream controller
    if (_rideUpdateController != null && !_rideUpdateController!.isClosed) {
      _rideUpdateController!.close();
    }
    _rideUpdateController = null;
    _streamControllerCreated = false;

    _processedMessages.clear();

    _isInitialized = false;
    _isConnected = false;
    _subscriptionHealthy = false;
    _currentUsername = null;
    _reconnectAttempts = 0;
    _messageCount = 0;
    _lastMessageReceived = null;

    dev.log('✅ PubNub Manager disposed completely');
  }

// REMOVED: Regular dispose() method to prevent accidental disposal
}