import 'dart:developer';
import 'dart:io';

import 'package:flutter/material.dart';
import 'package:get_it/get_it.dart';
import 'package:muaawana/config/provider.dart';
import 'package:muaawana/models/emergency/Result.dart';

import '../models/Property/PropertyAsset.dart';
import '../models/order/order_response.dart';
import '../services/technician_services.dart';
import '../utils/connection.dart';
import '../utils/image_picker.dart';
import 'order_status_provider.dart';

class ItemPriceModel {
  String? name;
  double? price;

  ItemPriceModel({this.name, this.price});
}

class TechnicianProvider with ChangeNotifier {
  TechnicianService get service => GetIt.I<TechnicianService>();
  File? _image;
  File? get image => _image;
  bool loader = false;
  List<Order> orderList = [];
  List<PropertyAsset> propertyList=[];

  int nbrTodayRequest = 0;
  int nbrWeekRequest = 0;
  Order? _currentOrder;
  double total = 0.0;
  List<ItemPriceModel> itemList = [];
  UrgentRequest? _currentUrgentRequest;
  setCurrentUrgentRequest(UrgentRequest urgentRequest) {
    _currentUrgentRequest = urgentRequest;
    notifyListeners();
  }

  setCurrentOrder(Order order) {
    _currentOrder = order;
    notifyListeners();
  }

  Order get currentOrder => _currentOrder!;
  UrgentRequest get currentUrgentRequest => _currentUrgentRequest!;

  addItemToList(String name, double price) {
    itemList.add(ItemPriceModel(name: name, price: price));
    sumPrice();
    notifyListeners();
  }

  sumPrice() {
    total = 0.0;
    for (var e in itemList) {
      total = total + e.price!;
    }
    notifyListeners();
  }

  Future<void> pickPicture(String source,context) async {
    final imagePicker = ImagePick();
    final image = await imagePicker.pick(source,context);
    if (image != null) {
      _image = image;
      notifyListeners();
    }
  }

  Future<bool> acceptRequest(int requestId, bool isUrgent) async {
    if (await Connection.checkConnection()) {
      loader = true;
      notifyListeners();
      try {
        final acceptRequestResult =
            await service.acceptRequest(requestId, isUrgent);
        if (acceptRequestResult.statusCode == 200 ||
            acceptRequestResult.statusCode == 201) {
          setCurrentOrder(acceptRequestResult.data as Order);
          loader = false;
          notifyListeners();
          return true;
        } else {
          loader = false;
          notifyListeners();
          return false;
        }
      } catch (e, stackTrace) {
        log(stackTrace.toString());
        loader = false;
        notifyListeners();
        return false;
      }
    } else {
      /// No Internet Connection
      loader = false;
      notifyListeners();
      return false;
    }
  }

  Future<bool> rejectRequest(int requestId) async {
    if (await Connection.checkConnection()) {
      loader = true;
      notifyListeners();
      try {
        final rejectRequestResult = await service.rejectRequest(requestId);
        if (rejectRequestResult.statusCode == 200 ||
            rejectRequestResult.statusCode == 201) {
          loader = false;
          notifyListeners();
          return true;
        } else {
          loader = false;
          notifyListeners();
          return false;
        }
      } catch (e, stackTrace) {
        log(stackTrace.toString());
        loader = false;
        notifyListeners();
        return false;
      }
    } else {
      /// No Internet Connection
      loader = false;
      notifyListeners();
      return false;
    }
  }

  requestItem(String comment, String name, int serviceId) async {
    if (await Connection.checkConnection()) {
      loader = true;
      notifyListeners();
      try {
        final requestItemResult =
            await service.requestItem(comment, name, serviceId);
        if (requestItemResult.statusCode == 200 ||
            requestItemResult.statusCode == 201) {
          loader = false;
          notifyListeners();
        } else {
          loader = false;
          notifyListeners();
        }
      } catch (e, stackTrace) {
        log(stackTrace.toString());
        loader = false;
        notifyListeners();
      }
    } else {
      /// No Internet Connection
      loader = false;
      notifyListeners();
    }
  }

  Future<bool> addItem(
      String comment, String name, int serviceId, double paidAmount) async {
    if (await Connection.checkConnection()) {
      loader = true;
      notifyListeners();
      try {
        final requestItemResult =
            await service.addItem(comment, name, paidAmount, serviceId);
        if (requestItemResult.statusCode == 200 ||
            requestItemResult.statusCode == 201) {
          addItemToList(name, paidAmount);
          loader = false;
          notifyListeners();
          return true;
        } else {
          loader = false;
          notifyListeners();
          return false;
        }
      } catch (e, stackTrace) {
        log(stackTrace.toString());
        loader = false;
        notifyListeners();
        return false;
      }
    } else {
      /// No Internet Connection
      loader = false;
      notifyListeners();
      return false;
    }
  }

  Future<int> countRequestByState(String state) async {
    if (await Connection.checkConnection()) {
      loader = true;
      notifyListeners();
      try {
        final countRequestResult = await service.countRequestByState(state);
        if (countRequestResult.statusCode == 200 ||
            countRequestResult.statusCode == 201) {
          loader = false;
          notifyListeners();
          return countRequestResult.data!;
        } else {
          loader = false;
          notifyListeners();
          return 0;
        }
      } catch (e, stackTrace) {
        log(stackTrace.toString());
        loader = false;
        notifyListeners();
        return 0;
      }
    } else {
      /// No Internet Connection
      loader = false;
      notifyListeners();
      return 0;
    }
  }

  Future countTodayRequest() async {
    if (await Connection.checkConnection()) {
      loader = true;
      notifyListeners();
      try {
        final countRequestResult = await service.countTodayRequests();
        if (countRequestResult.statusCode == 200 ||
            countRequestResult.statusCode == 201) {
          log('todays requests : ${countRequestResult.data!}');
          nbrTodayRequest = countRequestResult.data!;
          loader = false;
          notifyListeners();
        } else {
          loader = false;
          notifyListeners();
          return 0;
        }
      } catch (e, stackTrace) {
        log(stackTrace.toString());
        loader = false;
        notifyListeners();
        return 0;
      }
    } else {
      /// No Internet Connection
      loader = false;
      notifyListeners();
      return 0;
    }
  }

  Future countWeekRequest() async {
    if (await Connection.checkConnection()) {
      loader = true;
      notifyListeners();
      try {
        final countRequestResult = await service.countWeekRequests();
        if (countRequestResult.statusCode == 200 ||
            countRequestResult.statusCode == 201) {
          log('todays requests : ${countRequestResult.data!}');
          nbrWeekRequest = countRequestResult.data!;
          loader = false;
          notifyListeners();
        } else {
          loader = false;
          notifyListeners();
          return 0;
        }
      } catch (e, stackTrace) {
        log(stackTrace.toString());
        loader = false;
        notifyListeners();
        return 0;
      }
    } else {
      /// No Internet Connection
      loader = false;
      notifyListeners();
      return 0;
    }
  }

  Future fetchRequestsByState(int page, int size, String state) async {
    if (await Connection.checkConnection()) {
      loader = true;
      notifyListeners();
      try {
        final fetchRequestResult =
            await service.getMyRequestByState(state, size, page);
        if (fetchRequestResult.statusCode == 200 ||
            fetchRequestResult.statusCode == 201) {
          log("fetchRequestResult-- ${fetchRequestResult.data!}");
          orderList = fetchRequestResult.data!.result!;
          log("orderList-- ${orderList}");
          //print('Order List Length $orderList');
          loader = false;
          notifyListeners();
        } else {
          loader = false;
          notifyListeners();
        }
      } catch (e, stackTrace) {
        log(stackTrace.toString());
        loader = false;
        notifyListeners();
      }
    } else {
      /// No Internet Connection
      loader = false;
      notifyListeners();
    }
  }

  Future fetchPropertyCorporate(int propertyId) async {
    if (!await Connection.checkConnection()) {
      loader = false;
      notifyListeners();
      return;
    }
    loader = true;
    notifyListeners();
    log("fetchPropertyCorporate***************************************** $propertyId");
    try {
      final response =
      await service.getPropertyCorporate(propertyId);
        log("fetchPropertyCorporate***************************************** $propertyId");
        log("fetchPropertyCorporate************response.statusCode***************************** ${response.statusCode}");
      if (response.statusCode == 200 && response.data != null) {
        propertyList = response.data!;
        log("***************************************** ${response.data}");
      } else {
        propertyList = [];
      }
    } catch (e, st) {
      log(st.toString());
      propertyList = [];
    } finally {
      loader = false;
      notifyListeners();
    }
  }

  Future<bool> completeOrder(
      String description, int requestId,List<int>? propertyAssetsIds, BuildContext context) async {
    if (await Connection.checkConnection()) {
      loader = true;
      notifyListeners();
      log("completeOrder Provide ++++++++++++++++++++++$description ++++++++++++++++ $propertyAssetsIds ++++++++++++++$requestId");
      try {
        final requestItemResult =
            await service.completeRequest(image!, description,propertyAssetsIds, requestId);
        log("completeOrder Provide ++++++++++++++++++++++ ++++++++++++++++ $requestItemResult ++++++++++++++");

        if (requestItemResult.statusCode == 200 ||
            requestItemResult.statusCode == 201) {
          // await changeRequestState(requestId,'WORK_PAYMENT_DONE');
          context.read<OrderStatusProvider>().pickedOrder =
              requestItemResult.data;
          loader = false;
          notifyListeners();
          return true;
        } else {
          loader = false;
          notifyListeners();
          return false;
        }
      } catch (e, stackTrace) {
        log(stackTrace.toString());
        loader = false;
        notifyListeners();
        return false;
      }
    } else {
      /// No Internet Connection
      loader = false;
      notifyListeners();
      return false;
    }
  }

  Future<bool> workNotDone(int requestId, String description) async {
    if (await Connection.checkConnection()) {
      loader = true;
      notifyListeners();
      try {
        final rejectRequestResult =
            await service.workNotDone(requestId, description);
        if (rejectRequestResult.statusCode == 200 ||
            rejectRequestResult.statusCode == 201) {
          // await changeRequestState(requestId,'WORK_NOT_DONE');
          loader = false;
          notifyListeners();
          return true;
        } else {
          loader = false;
          notifyListeners();
          return false;
        }
      } catch (e, stackTrace) {
        log(stackTrace.toString());
        loader = false;
        notifyListeners();
        return false;
      }
    } else {
      loader = false;
      notifyListeners();
      return false;
    }
  }

  changeRequestState(int requestId, String state) async {
    if (await Connection.checkConnection()) {
      loader = true;
      notifyListeners();
      try {
        final rejectRequestResult =
            await service.changeRequestState(requestId, state);
        if (rejectRequestResult.statusCode == 200 ||
            rejectRequestResult.statusCode == 201) {
          loader = false;
          notifyListeners();
        } else {
          loader = false;
          notifyListeners();
        }
      } catch (e, stackTrace) {
        log(stackTrace.toString());
        loader = false;
        notifyListeners();
      }
    } else {
      /// No Internet Connection
      loader = false;
      notifyListeners();
    }
  }
}