import 'dart:developer';
import 'package:wanisdriver/Provider/utils_singleton.dart';
import 'package:flutter/cupertino.dart';
import 'package:get/get.dart';
import '../Screen/RideRequestQueueScreen.dart';
import '../config/constants/app_constant.dart';
import '../services/DriverServices.dart';
import '../services/driver_location_service_manager.dart';
import '../services/ride_socket_service_manager.dart';
import 'RideProvider.dart';
class RideNotification extends ChangeNotifier {

  final driverservice driverservices = driverservice();

  // The list of pending ride IDs. This is our queue.
  final List<int> _pendingRideIds = [];
  List<int> get pendingRideIds => _pendingRideIds;

  int get requestCount => _pendingRideIds.length;
  bool _isQueueScreenOpen = false;
  /// Adds a new ride ID to the queue and shows the queue screen.
  void enqueue(int rideId) {
    if (!_pendingRideIds.contains(rideId)) {
      _pendingRideIds.add(rideId);
      log("✅ Ride enqueued. Total requests: $requestCount");
      notifyListeners();
    }

    // If the queue screen isn't already visible, open it.
    if (!_isQueueScreenOpen) {
      _isQueueScreenOpen = true;
      Get.to(() => const RideRequestQueueScreen())?.whenComplete(() {
        // When the queue screen is finally closed (e.g., by accepting a ride),
        // reset the flag.
        _isQueueScreenOpen = false;
        log("RideRequestQueueScreen closed.");
      });
    }
  }

  /// Removes the specified ride from the queue (on decline).
  void removeRide(int rideId) {
    _pendingRideIds.remove(rideId);
    log("❌ Ride $rideId removed. Remaining requests: $requestCount");

    notifyListeners();
  }

  /// Clears the entire queue (on accept).
  void clearAllPendingRides() {
    _pendingRideIds.clear();
    log("🗑️ All pending rides cleared.");
    notifyListeners();
  }

  rideconnectionsocket() async {
    if(utils.user!.driver!.available){
      String token = await driverservices.getToken();
      bool isserviceruning  = await RideSocketServiceManager.isServiceRunning();
      if(!isserviceruning){
        if (utils.user!=null  && utils.user!.driver!.id != null && token != 'InvalidToken') {
          await RideSocketServiceManager.startService(username: utils.user!.username!, pubKey: pubKey, subKey: subKey);
          log("----------------driver ride start service----------------");
        }else{
          log("----------------driver ride error service some data is null  user = ${utils.user}----------------");
        }
      }else{
        log("----------------driver ride service is already running----------------");
      }
    }else{

      log("----------------driver ride stop service----------------");
    }
  }

  /// Periodically clean up rides that are no longer available
  void cleanupExpiredRides() async {
    if (_pendingRideIds.isEmpty) return;

    try {
      final rideProvider = Get.find<RideProvider>();
      final ridesToRemove = <int>[];

      for (final rideId in List<int>.from(_pendingRideIds)) {
        final ride = await rideProvider.getRideDetails(rideId, forceRefresh: true);

        if (ride == null ||
            ride.driverId != null ||
            ["CANCELLED", "ONGOING", "COMPLETED"].contains(ride.rideStatus)) {
          ridesToRemove.add(rideId);
        }
      }

      for (final rideId in ridesToRemove) {
        removeRide(rideId);
        log("🧹 Cleaned up expired ride $rideId");
      }
    } catch (e) {
      log("❌ Error during cleanup: $e");
    }
  }

  Future<void> locationconnectionservice() async {
    if (utils.user?.driver == null) return;

    // ✅ CORRECTED LOGIC: REMOVED THE "if (available)" CHECK
    bool isRunningLocation = await DriverLocationServiceManager.isServiceRunning();

    if (!isRunningLocation) {
      String token = await driverservices.getToken();
      if (utils.user!.driver!.id != null && token != 'InvalidToken') {
        await DriverLocationServiceManager.startService(
          authToken: token,
          driverId: utils.user!.driver!.id!,
        );
        log("----------------driver location START service----------------");
      } else {
        log("----------------driver location error: some data is null----------------");
      }
    } else {
      log("----------------driver location service is already running----------------");
    }
  }
  static final RideNotification _instance = RideNotification._internal();

  RideNotification._internal();
  factory RideNotification() {
    return _instance;
  }
}

final rideNotificationService = RideNotification();