import 'dart:developer';

import 'package:flutter/material.dart';
import 'package:get_it/get_it.dart';

import '../models/products/product_model.dart';
import '../models/services/result.dart';
import '../services/bookmark_services.dart';
import '../utils/connection.dart';

class BookmarkProvider extends ChangeNotifier {
  BookmarkService get service => GetIt.I<BookmarkService>();
  bool loader = false;
  List<Service> servicesList = [];
  List<Product> productsList = [];

  // Add lists to track bookmarked IDs locally
  List<int> bookmarkedServiceIds = [];
  List<int> bookmarkedProductIds = [];

  // Add this method to clear all data
  void clearAllData() {
    servicesList.clear();
    productsList.clear();
    bookmarkedServiceIds.clear();
    bookmarkedProductIds.clear();
    loader = false;
    notifyListeners();
  }

  // Method to check if a service is bookmarked
  bool isServiceBookmarked(int serviceId) {
    return bookmarkedServiceIds.contains(serviceId);
  }

  // Method to check if a product is bookmarked
  bool isProductBookmarked(int productId) {
    return bookmarkedProductIds.contains(productId);
  }

  addBookmark(bool isProduct, int id) async {
    if (await Connection.checkConnection()) {
      loader = true;
      notifyListeners();

      try {
        final sendUrgentRequestResult = await service.addBookmark(isProduct, id);
        if ((sendUrgentRequestResult.statusCode == 200 ||
            sendUrgentRequestResult.statusCode == 201) &&
            sendUrgentRequestResult.data != null) {

          // Add to local bookmark tracking
          if (isProduct) {
            if (!bookmarkedProductIds.contains(id)) {
              bookmarkedProductIds.add(id);
            }
          } else {
            if (!bookmarkedServiceIds.contains(id)) {
              bookmarkedServiceIds.add(id);
            }
          }

          loader = false;
          notifyListeners();
        } else {
          loader = false;
          notifyListeners();
        }
      } catch (e, stackTrace) {
        print('Error adding bookmark: $e');
        loader = false;
        notifyListeners();
      }
    } else {
      /// No Internet Connection
      loader = false;
      notifyListeners();
    }
  }

  Future getBookmarkedProduct(int size, int page) async {
    if (await Connection.checkConnection()) {
      if (page == 0) {
        productsList.clear(); // Only clear on first page
      }
      loader = true;
      notifyListeners();

      try {
        final sendUrgentRequestResult = await service.getBookmarkedProduct(size, page);
        if ((sendUrgentRequestResult.statusCode == 200 ||
            sendUrgentRequestResult.statusCode == 201) &&
            sendUrgentRequestResult.data != null &&
            sendUrgentRequestResult.data!.productList != null) {
          log("getBookmarkedProduct === $service");

          // Avoid duplicates
          final newProducts = sendUrgentRequestResult.data!.productList!
              .where((newProduct) => !productsList.any((existing) => existing.id == newProduct.id))
              .toList();

          productsList.addAll(newProducts);

          // Update local bookmark tracking for products
          if (page == 0) {
            bookmarkedProductIds.clear();
          }
          for (var product in sendUrgentRequestResult.data!.productList!) {
            if (!bookmarkedProductIds.contains(product.id)) {
              bookmarkedProductIds.add(product.id!);
            }
          }

          loader = false;
          notifyListeners();
        } else {
          loader = false;
          notifyListeners();
        }
      } catch (e, stackTrace) {
        print('Error getting bookmarked products: $e');
        loader = false;
        notifyListeners();
      }
    } else {
      /// No Internet Connection
      loader = false;
      notifyListeners();
    }
  }

  Future getBookmarkedService(int size, int page) async {
    if (await Connection.checkConnection()) {
      if (page == 0) {
        servicesList.clear(); // Only clear on first page
      }
      loader = true;
      notifyListeners();

      try {
        final getUrgentRequestResult = await service.getBookmarkedService(size, page);
        if ((getUrgentRequestResult.statusCode == 200 ||
            getUrgentRequestResult.statusCode == 201) &&
            getUrgentRequestResult.data != null &&
            getUrgentRequestResult.data!.result != null) {
          log("getBookmarkedService === ${getUrgentRequestResult.data!}");

          // Avoid duplicates
          final newServices = getUrgentRequestResult.data!.result!
              .where((newService) => !servicesList.any((existing) => existing.id == newService.id))
              .toList();

          servicesList.addAll(newServices);

          // Update local bookmark tracking for services
          if (page == 0) {
            bookmarkedServiceIds.clear();
          }
          for (var service in getUrgentRequestResult.data!.result!) {
            if (!bookmarkedServiceIds.contains(service.id)) {
              bookmarkedServiceIds.add(service.id!);
            }
          }

          loader = false;
          notifyListeners();
        } else {
          loader = false;
          notifyListeners();
        }
      } catch (e, stackTrace) {
        print('Error getting bookmarked services: $e');
        loader = false;
        notifyListeners();
      }
    } else {
      /// No Internet Connection
      loader = false;
      notifyListeners();
    }
  }

  removeBookmark(bool isProduct, int itemId) async {
    if (await Connection.checkConnection()) {
      loader = true;
      notifyListeners();
      try {
        final getUrgentRequestResult = await service.removeBookmark(isProduct, itemId);
        if ((getUrgentRequestResult.statusCode == 200 ||
            getUrgentRequestResult.statusCode == 201)) {

          // Remove from local lists
          if (isProduct) {
            productsList.removeWhere((product) => product.id == itemId);
            bookmarkedProductIds.remove(itemId);
          } else {
            servicesList.removeWhere((service) => service.id == itemId);
            bookmarkedServiceIds.remove(itemId);
          }

          loader = false;
          notifyListeners();
        } else {
          loader = false;
          notifyListeners();
        }
      } catch (e, stackTrace) {
        print('Error removing bookmark: $e');
        loader = false;
        notifyListeners();
      }
    } else {
      /// No Internet Connection
      loader = false;
      notifyListeners();
    }
  }
}