import 'dart:developer' as dev;
import 'dart:developer';

import 'package:flutter/material.dart';
import 'package:get_it/get_it.dart';
import 'package:muaawana/models/booking_product/Result.dart';
import 'package:muaawana/models/services/result.dart';

import '../models/booking_service/Result.dart';
import '../services/request_status_service.dart';
import '../utils/connection.dart';
import '../utils/date_time_utils.dart';

enum BookingStatus { inProgress, done }

enum BookingType { product, service }

class ViewListModel {
  int id;
  String name;
  String status;
  int bookingId;
  double rating;
  String date;
  String startTime;
  String endTime;
  BookingStatus bookingStatus;
  BookingType bookingType;
  Technician? technician;
  bool? notification;

  ViewListModel(
      {required this.id,
        required this.name,
        required this.status,
        required this.bookingId,
        required this.rating,
        required this.date,
        required this.startTime,
        required this.endTime,
        required this.bookingStatus,
        required this.bookingType,
        this.technician,
        this.notification});
}

class RequestStatusProvider with ChangeNotifier {
  UserRequestStatus get service => GetIt.I<UserRequestStatus>();

  List<ProductDetail> productBookingList = [];
  //List<ProductDetail> productBookingList = [];
  List<ServiceResult> serviceBookingList = [];
  List<ViewListModel> bookingList= [];
  List<ViewListModel> bookingListCompleted = [];
  ServiceResult? serviceRequestById;
  bool loader = false;
  bool _isFetching = false;

  Set<int> notifiedRequest = {};

  addActiveNotificationRequest(int id) {
    //print("****************** adding id : $id");
    notifiedRequest.add(id);
    notifyListeners();
  }

  removeNotificationRequest(int id, bool isService, bool isDone) {
    notifiedRequest.removeWhere((element) => element == id);
    if (isService && isDone) {
      final idToRemove =
      bookingListCompleted.indexWhere((element) => element.id == id);
      final serviceRemoved = bookingListCompleted.removeAt(idToRemove);
      serviceRemoved.notification = false;
      bookingListCompleted.insert(0, serviceRemoved);
    }
    if (isService && !isDone) {
      final idToRemove = bookingList.indexWhere((element) => element.id == id);
      final serviceRemoved = bookingList.removeAt(idToRemove);
      serviceRemoved.notification = false;
      bookingList.insert(0, serviceRemoved);
    }
    notifyListeners();
  }

  refreshListOrder(int changedOrderID) async {
    // First, remove any existing instances of this order from both lists
    bookingList.removeWhere((order) => order.id == changedOrderID);
    bookingListCompleted.removeWhere((order) => order.id == changedOrderID);

    // Fetch the updated order
    await fetchServiceRequestById(changedOrderID);

    if (serviceRequestById != null) {
      final calculateEndTime = bookingInstant(serviceRequestById!.date!)
          .add(Duration(minutes: serviceRequestById!.serviceduration!.toInt()));

      final updatedOrder = ViewListModel(
          id: serviceRequestById!.id!,
          name: serviceRequestById!.service!.name!,
          status: serviceRequestById!.requeststate!,
          bookingId: serviceRequestById!.id!,
          rating: serviceRequestById!.service!.ratingAverage!,
          date: formatBookingDate(serviceRequestById!.date!),
          startTime: Dates.convertDateTimeToTime(bookingInstant(serviceRequestById!.date!)),
          endTime: Dates.convertDateTimeToTime(calculateEndTime),
          bookingStatus: serviceRequestById!.driverState == "COMPLETED" ? BookingStatus.done : BookingStatus.inProgress,
          bookingType: BookingType.service,
          technician: serviceRequestById!.technician,
          notification: true
      );

      // Add to the appropriate list based on status
      if (serviceRequestById!.driverState == "COMPLETED") {
        bookingListCompleted.insert(0, updatedOrder);
      } else {
        bookingList.insert(0, updatedOrder);
      }

      notifyListeners();
    }
  }

  fetchServiceRequestById(int id) async {
    serviceRequestById = null;
    if (await Connection.checkConnection()) {
      loader = true;
      notifyListeners();
      try {
        final fetchServiceRequestResult =
        await service.fetchUserServiceRequestById(id);
        if ((fetchServiceRequestResult.statusCode == 200 ||
            fetchServiceRequestResult.statusCode == 201) &&
            fetchServiceRequestResult.data != null) {
          serviceRequestById = fetchServiceRequestResult.data!;
          loader = false;
          notifyListeners();
        } else {
          loader = false;
          notifyListeners();
        }
      } catch (e, stackTrace) {
        loader = false;
        notifyListeners();
        dev.log("-----> Product Request Caught Error : ");
        dev.log(e.toString());
        dev.log("-----> Product Request Caught Error StackTrace : ");
        dev.log(stackTrace.toString());
      }
    } else {
      /// No Internet Connection
      dev.log("-----> No Internet Connection");
      loader = false;
      notifyListeners();
    }
  }

  fetchProductRequestById(int id) {}

  Future<void> fetchAllRequest(String filter) async {
    if (_isFetching) return;

    _isFetching = true;
    _clearAllLists();

    loader = true;
    notifyListeners();

    try {
      if (filter == 'Products & Services') {
        await Future.wait([_handleProducts(), _handleServices()]);
      } else if (filter == 'Products') {
        await _handleProducts();
      } else if (filter == 'Services') {
        await _handleServices();
      }

      loader = false;
      notifyListeners();
    } catch (e, stackTrace) {
      loader = false;
      notifyListeners();
      dev.log("fetchAllRequest error: $e\n$stackTrace");
    }  finally {
      _isFetching = false;
      loader = false;
      notifyListeners();
    }
  }

  void _addToListWithoutDuplicates(ViewListModel model) {
    // Remove any existing item with the same ID
    bookingList.removeWhere((item) => item.id == model.id);
    bookingListCompleted.removeWhere((item) => item.id == model.id);

    // Add to the appropriate list
    if (model.bookingStatus == BookingStatus.done) {
      bookingListCompleted.add(model);
    } else {
      bookingList.add(model);
    }
  }

  Future getProductRequestPg() async {
    if (await Connection.checkConnection()) {
      loader = true;
      notifyListeners();
      try {
        final fetchProductRequestResult =
        await service.fetchUserProductRequestPg();
        if ((fetchProductRequestResult.statusCode == 200 ||
            fetchProductRequestResult.statusCode == 201) &&
            fetchProductRequestResult.data != null) {
          productBookingList = fetchProductRequestResult.data!.result!;
          loader = false;
          notifyListeners();
        } else {
          loader = false;
          notifyListeners();
        }
      } catch (e, stackTrace) {
        loader = false;
        notifyListeners();
        dev.log("-----> Product Request Caught Error : ");
        dev.log(e.toString());
        dev.log("-----> Product Request Caught Error StackTrace : ");
        dev.log(stackTrace.toString());
      }
    } else {
      /// No Internet Connection
      dev.log("-----> No Internet Connection");
      loader = false;
      notifyListeners();
    }
  }

  Future<void> getServiceRequestPg() async {
    serviceBookingList.clear();
    if (await Connection.checkConnection()) {
      loader = true;
      notifyListeners();
      try {
        final fetchServiceRequestResult =
        await service.fetchUserServiceRequestPg();
        dev.log("-----> getServiceRequestPg : ${fetchServiceRequestResult.statusCode}");
        dev.log("-----> getServiceRequestPg : ${fetchServiceRequestResult.data}");
        if ((fetchServiceRequestResult.statusCode == 200 ||
            fetchServiceRequestResult.statusCode == 201) &&
            fetchServiceRequestResult.data != null) {
          serviceBookingList = fetchServiceRequestResult.data!.result!;
          loader = false;
          notifyListeners();
        } else {
          loader = false;
          notifyListeners();
        }
      } catch (e, stackTrace) {
        loader = false;
        notifyListeners();
        dev.log("-----> Product Request Caught Error : ");
        dev.log(e.toString());
        dev.log("-----> Product Request Caught Error StackTrace : ");
        dev.log(stackTrace.toString());
      }
    } else {
      /// No Internet Connection
      dev.log("-----> No Internet Connection");
      loader = false;
      notifyListeners();
    }
  }

  Future<bool> cancelRequest(int id) async {
    // serviceRequestById = null;
    if (await Connection.checkConnection()) {
      // loader = true;
      // notifyListeners();
      try {
        final fetchServiceRequestResult =
        await service.cancelServiceRequest(id);
        if (fetchServiceRequestResult.statusCode == 200 ||
            fetchServiceRequestResult.statusCode == 201) {
          // serviceRequestById = fetchServiceRequestResult.data!;
          // loader = false;
          // notifyListeners();
          return true;
        } else {
          // loader = false;
          // notifyListeners();
          return false;
        }
      } catch (e, stackTrace) {
        // loader = false;
        // notifyListeners();
        // dev.log("-----> Product Request Caught Error : ");
        dev.log(e.toString());
        // dev.log("-----> Product Request Caught Error StackTrace : ");
        dev.log(stackTrace.toString());
        return false;
      }
    } else {
      /// No Internet Connection
      dev.log("-----> No Internet Connection");
      // loader = false;
      // notifyListeners();
      return false;
    }
  }

  Future<Service?> getServiceById(int id) async {
    // serviceRequestById = null;
    if (await Connection.checkConnection()) {
      // loader = true;
      // notifyListeners();
      try {
        final fetchServiceRequestResult = await service.fetchService(id);
        if ((fetchServiceRequestResult.statusCode == 200 ||
            fetchServiceRequestResult.statusCode == 201) &&
            fetchServiceRequestResult.data != null) {
          // serviceRequestById = fetchServiceRequestResult.data!;
          // loader = false;
          // notifyListeners();
          return fetchServiceRequestResult.data!;
        } else {
          // loader = false;
          // notifyListeners();
          return null;
        }
      } catch (e, stackTrace) {
        // loader = false;
        // notifyListeners();
        // dev.log("-----> Product Request Caught Error : ");
        dev.log(e.toString());
        // dev.log("-----> Product Request Caught Error StackTrace : ");
        dev.log(stackTrace.toString());
        return null;
      }
    } else {
      /// No Internet Connection
      dev.log("-----> No Internet Connection");
      // loader = false;
      // notifyListeners();
      return null;
    }
  }

  Future<void> _handleProducts() async {
    await getProductRequestPg();
    for (var product in productBookingList) {
      final endTime = _calculateEndTime(product.date!, product.serviceduration!);
      final model = ViewListModel(
        id: product.id!,
        name: product.product!.name!,
        status: product.requeststate!,
        bookingId: product.id!,
        rating: product.product!.ratingAverage!,
        date: formatBookingDate(product.date!),
        startTime: Dates.convertDateTimeToTime(bookingInstant(product.date!)),
        endTime: Dates.convertDateTimeToTime(endTime),
        bookingStatus: _mapStatus(product.requeststate!),
        bookingType: BookingType.product,
      );

      _addToList(model);
    }
  }

  Future<void> _handleServices() async {
    dev.log("_handleServices: Starting to fetch services");
    await getServiceRequestPg();
    dev.log("_handleServices: Found ${serviceBookingList.length} services");

    for (var service in serviceBookingList) {
      dev.log("Processing service ID: ${service.id}, Status: ${service.requeststate}");

      final endTime = _calculateEndTime(service.date!, service.serviceduration!);
      final model = ViewListModel(
        id: service.id!,
        name: service.service!.name!,
        status: service.requeststate!,
        bookingId: service.id!,
        rating: service.service!.ratingAverage!,
        date: formatBookingDate(service.date!),
        startTime: Dates.convertDateTimeToTime(bookingInstant(service.date!)),
        endTime: Dates.convertDateTimeToTime(endTime),
        bookingStatus: _mapStatus(service.requeststate!),
        bookingType: BookingType.service,
        technician: service.technician,
      );

      _addToList(model);
    }

    dev.log("_handleServices: bookingList now has ${bookingList.length} items");
    dev.log("_handleServices: bookingListCompleted now has ${bookingListCompleted.length} items");
  }

  DateTime _calculateEndTime(int startMillis, double durationMinutes) {
    return bookingInstant(startMillis)
        .add(Duration(minutes: durationMinutes.toInt()));
  }

  BookingStatus _mapStatus(String status) {
    return (status == 'COMPLETED' || status == 'CANCELLED')
        ? BookingStatus.done
        : BookingStatus.inProgress;
  }

  void _addToList(ViewListModel model) {
    _addToListWithoutDuplicates(model);
  }


  void _clearAllLists() {
    bookingList.clear();
    bookingListCompleted.clear();
    productBookingList.clear();
    serviceBookingList.clear();
  }


}