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

import 'package:http_parser/http_parser.dart';
import 'package:muaawana/models/emergency/Result.dart';
import 'package:shared_preferences/shared_preferences.dart';
import 'package:http/http.dart' as http;

import '../models/Property/PropertyAsset.dart';
import '../models/order/Order_by_state_response.dart';
import '../models/order/order_response.dart';
import '../models/utils/api_response.dart';

const url = 'server.muaawana.com';

class TechnicianService {
  String token = "InvalidToken";
  int statusCode = -1;
  bool errorToken = false;

  Future<String> getToken() async {
    final prefs = await SharedPreferences.getInstance();
    if (prefs.getString('token') == null || prefs.getString('token') == '') {
      prefs.setString('token', 'InvalidToken');
    }
    if (prefs.getString('token') != null) {
      token = prefs.getString('token')!;
    }
    return token.toString();
  }

  Future<APIResponse> acceptRequest(int requestId, bool isUrgent) async {
    errorToken = false;
    statusCode = -1;
    await getToken();
    return await http.patch(
      Uri.https(url, '/api/v1/technician/accept_request/$requestId'),
      headers: <String, String>{
        'Authorization': 'Bearer $token',
        'Content-type': 'application/json',
        'Accept': 'application/json'
      },
    ).then((data) {
      statusCode = data.statusCode;
      if (data.statusCode == 200 || data.statusCode == 201) {
        final jsonData = json.decode(data.body);
        var result;
        if (isUrgent) {
          result = UrgentRequest.fromJson(jsonData);
        } else {
          result = Order.fromJson(jsonData);
        }
        return APIResponse(statusCode: statusCode, data: result);
      }
      return APIResponse(
          statusCode: statusCode, errorMessage: 'Please check your info');
    }).catchError((_) => APIResponse(
        statusCode: statusCode, errorMessage: 'no internet connection'));
  }

  Future<APIResponse> rejectRequest(int requestId) async {
    errorToken = false;
    statusCode = -1;
    await getToken();

    return await http.patch(
      Uri.https(url, '/api/v1/technician/reject_request/$requestId'),
      headers: <String, String>{
        'Authorization': 'Bearer $token',
        'Content-type': 'application/json',
        'Accept': 'application/json'
      },
    ).then((data) {
      statusCode = data.statusCode;
      if (data.statusCode == 200 || data.statusCode == 201) {
        final jsonData = json.decode(data.body);
        return APIResponse(
          statusCode: statusCode,
          data: jsonData
        );
      }
      return APIResponse(
          statusCode: statusCode, errorMessage: 'Please check your info');
    }).catchError((_) => APIResponse(
        statusCode: statusCode, errorMessage: 'no internet connection'));
  }

  Future<APIResponse> requestItem(
    String comment,
    String name,
    int serviceId,
  ) async {
    errorToken = false;
    statusCode = -1;
    await getToken();
    final query = {"comment": comment, "name": name};
    return await http.post(
      Uri.https(url, '/api/v1/technician/request_item/$serviceId', query),
      headers: <String, String>{
        'Authorization': 'Bearer $token',
        'Content-type': 'application/json',
        'Accept': 'application/json'
      },
    ).then((data) {
      statusCode = data.statusCode;
      if (data.statusCode == 200 || data.statusCode == 201) {
        final jsonData = json.decode(data.body);
        return APIResponse(
          statusCode: statusCode,
          data:jsonData
        );
      }
      return APIResponse(
          statusCode: statusCode, errorMessage: 'Please check your info');
    }).catchError((_) => APIResponse(
        statusCode: statusCode, errorMessage: 'no internet connection'));
  }

  Future<APIResponse> addItem(
    String comment,
    String name,
    double paidAmount,
    int serviceId,
  ) async {
    errorToken = false;
    statusCode = -1;
    await getToken();
    final query = {
      "comment": comment,
      "paidAmount": '$paidAmount',
      "name": name
    };
    return await http.post(
      Uri.https(url, '/api/v1/technician/add_item/$serviceId', query),
      headers: <String, String>{
        'Authorization': 'Bearer $token',
        'Content-type': 'application/json',
        'Accept': 'application/json'
      },
    ).then((data) {
      statusCode = data.statusCode;
      if (data.statusCode == 200 || data.statusCode == 201) {
        final jsonData = json.decode(data.body);
        return APIResponse(
          statusCode: statusCode,
          data: jsonData
        );
      }
      return APIResponse(
          statusCode: statusCode, errorMessage: 'Please check your info');
    }).catchError((_, stacktrace) {
      //print(stacktrace);
      return APIResponse(
          statusCode: statusCode, errorMessage: 'no internet connection');
    });
  }

  Future<APIResponse<int>> countRequestByState(String state) async {
    errorToken = false;
    statusCode = -1;
    await getToken();
    final query = {"requeststate": state};
    return await http.get(
      Uri.https(url, '/api/v1/technician/count_my_requests_by_state', query),
      headers: <String, String>{
        'Authorization': 'Bearer $token',
        'Content-type': 'application/json',
        'Accept': 'application/json'
      },
    ).then((data) {
      statusCode = data.statusCode;
      if (data.statusCode == 200 || data.statusCode == 201) {
        return APIResponse<int>(
            statusCode: statusCode, data: int.tryParse(data.body));
      }
      return APIResponse<int>(
          statusCode: statusCode, errorMessage: 'Please check your info');
    }).catchError((_) => APIResponse<int>(
        statusCode: statusCode, errorMessage: 'no internet connection'));
  }

  Future<APIResponse<int>> countTodayRequests() async {
    errorToken = false;
    statusCode = -1;
    await getToken();

    return await http.get(
      Uri.https(url, '/api/v1/technician/get_today_service_request_count'),
      headers: <String, String>{
        'Authorization': 'Bearer $token',
        'Content-type': 'application/json',
        'Accept': 'application/json'
      },
    ).then((data) {
      statusCode = data.statusCode;
      if (data.statusCode == 200 || data.statusCode == 201) {
        final jsonData = json.decode(data.body);
        return APIResponse<int>(
            statusCode: statusCode, data: int.tryParse(data.body));
      }
      return APIResponse<int>(
          statusCode: statusCode, errorMessage: 'Please check your info');
    }).catchError((_) => APIResponse<int>(
        statusCode: statusCode, errorMessage: 'no internet connection'));
  }

  Future<APIResponse<int>> countWeekRequests() async {
    errorToken = false;
    statusCode = -1;
    await getToken();

    return await http.get(
      Uri.https(url, '/api/v1/technician/get_week_service_request_count'),
      headers: <String, String>{
        'Authorization': 'Bearer $token',
        'Content-type': 'application/json',
        'Accept': 'application/json'
      },
    ).then((data) {
      statusCode = data.statusCode;
      if (data.statusCode == 200 || data.statusCode == 201) {
        final jsonData = json.decode(data.body);
        log("countWeekRequests -- $jsonData");
        return APIResponse<int>(
            statusCode: statusCode, data: int.tryParse(data.body));
      }
      return APIResponse<int>(
          statusCode: statusCode, errorMessage: 'Please check your info');
    }).catchError((_) => APIResponse<int>(
        statusCode: statusCode, errorMessage: 'no internet connection'));
  }

  Future<APIResponse<OrderByStateResponse>> getMyRequestByState(
      String state, int size, int page) async {
    errorToken = false;
    statusCode = -1;
    await getToken();

    Map<String, dynamic> query = {
      "requeststate": state,
      "size": '$size',
      "page": '$page'
    };
    if (state == '') {
      query = {"size": '100', "page": '0'};
    }
    print("***token*** $token");
    return await http.get(
      Uri.https(url, '/api/v1/technician/my_requests_by_state', query),
      headers: <String, String>{
        'Authorization': 'Bearer $token',
        'Content-type': 'application/json',
        'Accept': 'application/json'
      },
    ).then((data) {
      statusCode = data.statusCode;
      log("statusCode----------------------------- $statusCode");
      if (data.statusCode == 200 || data.statusCode == 201) {
        final jsonData = json.decode(data.body);
        log("jsonData -----------------------------  ${jsonData}");
        final result = OrderByStateResponse.fromJson(jsonData);
        log("result -----------------------------${result}");
        return APIResponse<OrderByStateResponse>(
            statusCode: statusCode, data: result);
      }
      return APIResponse<OrderByStateResponse>(
          statusCode: statusCode, errorMessage: 'Please check your info');
    }).catchError((_) => APIResponse<OrderByStateResponse>(
        statusCode: statusCode, errorMessage: 'no internet connection'));
  }

  Future<APIResponse<List<PropertyAsset>>> getPropertyCorporate(
      int propertyId,

      ) async {
    await getToken();


    final uri = Uri.https(
      url,
      '/api/v1/technician/get_property_assets_by_propety_id/$propertyId'
    );
    log("getPropertyCorporate***************************************** $propertyId");
    final res = await http.get(
      uri,
      headers: {
        'Authorization': 'Bearer $token',
        'Content-Type': 'application/json',
        'Accept': 'application/json',
      },
    );

    if (res.statusCode == 200 || res.statusCode == 201) {
      log("getPropertyCorporate***************************************** ${res.body}");
      final list = propertyAssetFromJson(res.body);
      return APIResponse<List<PropertyAsset>>(
        statusCode: res.statusCode,
        data: list,
      );
    } else {
      return APIResponse<List<PropertyAsset>>(
        statusCode: res.statusCode,
        errorMessage: 'Please check your info',
      );
    }
  }

  Future<APIResponse<Order>> completeRequest(
      File file,
      String description,
      List<int>? propertyAssetsIds,
      int requestId,
      ) async {
    errorToken = false;
    statusCode = -1;
    await getToken();

    // Build query parameters with repeating keys
    final Map<String, List<String>> queryParamsMulti = {
      'description': [description],
    };

    if (propertyAssetsIds != null && propertyAssetsIds.isNotEmpty) {
      queryParamsMulti['propertyAssetsIds'] =
          propertyAssetsIds.map((e) => e.toString()).toList();
    }

    final uri = Uri.https(
      url,
      '/api/v1/technician/complete_request/$requestId',
      queryParamsMulti,
    );

    final request = http.MultipartRequest('PATCH', uri);

    request.headers.addAll({
      'Authorization': 'Bearer $token',
      'Accept': 'application/json',
      'Content-type': 'multipart/form-data',
    });

    final multipartFile = await http.MultipartFile(
      'file',
      file.readAsBytes().asStream(),
      file.lengthSync(),
      filename: file.path.split("/").last,
      contentType: MediaType("image", file.path.split(".").last),
    );

    request.files.add(multipartFile);

    final streamedResponse = await request.send();
    final response = await http.Response.fromStream(streamedResponse);

    log("response.statusCode: ${response.statusCode}");
    log("response.body: ${response.body}");

    if (response.statusCode == 200 || response.statusCode == 201) {
      final Order result = Order.fromJson(json.decode(response.body));
      return APIResponse(statusCode: response.statusCode, data: result);
    } else {
      return APIResponse(
        statusCode: response.statusCode,
        errorMessage: 'Please check your info',
      );
    }
  }

  Future<APIResponse> workNotDone(int requestId, String description) async {
    errorToken = false;
    statusCode = -1;
    await getToken();
    final query = {"description": description};
    return await http.patch(
      Uri.https(
          url, '/api/v1/technician/work_not_done_request/$requestId', query),
      headers: <String, String>{
        'Authorization': 'Bearer $token',
        'Content-type': 'application/json',
        'Accept': 'application/json'
      },
    ).then((data) {
      statusCode = data.statusCode;
      if (data.statusCode == 200 || data.statusCode == 201) {
        final jsonData = json.decode(data.body);
        return APIResponse(
          statusCode: statusCode,
          data: jsonData
        );
      }
      return APIResponse(
          statusCode: statusCode, errorMessage: 'Please check your info');
    }).catchError((_) => APIResponse(
        statusCode: statusCode, errorMessage: 'no internet connection'));
  }

  Future<APIResponse> changeRequestState(int requestId, String state) async {
    errorToken = false;
    statusCode = -1;
    await getToken();
    final query = {"state": state};
    return await http.patch(
      Uri.https(
          url, '/api/v1/technician/change_request_state/$requestId', query),
      headers: <String, String>{
        'Authorization': 'Bearer $token',
        'Content-type': 'application/json',
        'Accept': 'application/json'
      },
    ).then((data) {
      statusCode = data.statusCode;
      if (data.statusCode == 200 || data.statusCode == 201) {
        final jsonData = json.decode(data.body);
        return APIResponse(
          statusCode: statusCode,
          data: jsonData
        );
      }
      return APIResponse(
          statusCode: statusCode, errorMessage: 'Please check your info');
    }).catchError((_) => APIResponse(
        statusCode: statusCode, errorMessage: 'no internet connection'));
  }

  Future<APIResponse> receivePaymentRequest(double receivedAmount,
      int requestId, String paymentMethod, String? code) async {
    errorToken = false;
    statusCode = -1;
    await getToken();

    Map<String, String> query = {
      "paymentState": "PAID",
      "receivedAmount": receivedAmount.toString(),
      "technicianPaymentMethod": paymentMethod
    };
    if (code != null) {
      query.addAll({"pos": code});
    }
    return await http.post(
      Uri.https(
          url, '/api/v1/technician/confirm_payment_request/$requestId', query),
      headers: <String, String>{
        'Authorization': 'Bearer $token',
        'Content-type': 'application/json',
        'Accept': 'application/json'
      },
    ).then((data) {
      statusCode = data.statusCode;
      if (data.statusCode == 200 || data.statusCode == 201) {
        final jsonData = json.decode(data.body);
        return APIResponse(
          statusCode: statusCode,
          data: jsonData
        );
      }
      return APIResponse(
          statusCode: statusCode, errorMessage: 'Please check your info');
    }).catchError((_) => APIResponse(
        statusCode: statusCode, errorMessage: 'no internet connection'));
  }

  Future<APIResponse> receivePaymentUrgentRequest(double receivedAmount,
      int requestId, String paymentMethod, String? code) async {
    errorToken = false;
    statusCode = -1;
    await getToken();

    Map<String, String> query = {
      "paymentState": "PAID",
      "receivedAmount": receivedAmount.toString(),
      "technicianPaymentMethod": paymentMethod
    };

    if (code != null) {
      query.addAll({"pos": code});
    }

    return await http.post(
      Uri.https(
          url,
          '/api/v1/technician/confirm_payment_urgent_request/$requestId',
          query),
      headers: <String, String>{
        'Authorization': 'Bearer $token',
        'Content-type': 'application/json',
        'Accept': 'application/json'
      },
    ).then((data) {
      statusCode = data.statusCode;
      if (data.statusCode == 200 || data.statusCode == 201) {
        final jsonData = json.decode(data.body);
        return APIResponse(
          statusCode: statusCode,
        );
      }
      return APIResponse(
          statusCode: statusCode, errorMessage: 'Please check your info');
    }).catchError((_) => APIResponse(
        statusCode: statusCode, errorMessage: 'no internet connection'));
  }
}