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

import 'package:http_parser/http_parser.dart';
import 'package:shared_preferences/shared_preferences.dart';
import 'package:http/http.dart' as http;

import '../models/emergency/Result.dart';
import '../models/emergency/emergency_list.dart';
import '../models/utils/api_response.dart';

const url = 'server.muaawana.com';

class UrgentRequestService {
  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> userAddUrgentRequest(
    List<File>? filesList,
    String comment,
    String date,
    String address,
    double altitude,
    double longitude,
  ) async {
    errorToken = false;
    statusCode = -1;
    await getToken();
    final request = http.MultipartRequest(
        'POST', Uri.https(url, '/api/v1/user_urgent_request/add'));
    Map<String, String> headers = {
      'Authorization': 'Bearer $token',
      'Accept': 'application/json',
      "Content-type": "multipart/form-data",
    };
    request.headers.addAll(headers);

    if (filesList != null && filesList.isNotEmpty) {
      for (File file in filesList) {
        var multipartFile = await http.MultipartFile(
          'file',
          file.readAsBytes().asStream(),
          file.lengthSync(),
          filename: file.path.split("/").last,
          contentType: MediaType("image", file.path.split(".").last),
        );

        // Add the multipart file to the request
        request.files.add(multipartFile);
      }
    }

    Map<String, String> query = {
      "address": address,
      "altitude": '$altitude',
      "longitude": '$longitude',
      "comment": comment,
      "date": date,
    };
    //print(query);
    request.fields.addAll(query);
    http.Response response =
        await http.Response.fromStream(await request.send());
    if (response.statusCode == 200 || response.statusCode == 201) {

      return APIResponse(
        statusCode: response.statusCode,
      );
    } else {

      return APIResponse(
        statusCode: response.statusCode,
        errorMessage: 'Please check your info',
      );
    }
  }

  Future<APIResponse> updateUrgentRequest(
      int addressId, List<File>? filesList, String comment, String date) async {
    errorToken = false;
    statusCode = -1;
    await getToken();
    final request = http.MultipartRequest(
        'PATCH', Uri.https(url, '/api/v1/user_urgent_request/update'));
    Map<String, String> headers = {
      'Authorization': 'Bearer $token',
      'Accept': 'application/json',
      "Content-type": "multipart/form-data",
    };
    request.headers.addAll(headers);

    if (filesList != null && filesList.isNotEmpty) {
      for (File file in filesList) {
        var multipartFile = await http.MultipartFile(
          'file',
          file.readAsBytes().asStream(),
          file.lengthSync(),
          filename: file.path.split("/").last,
          contentType: MediaType("image", file.path.split(".").last),
        );

        // Add the multipart file to the request
        request.files.add(multipartFile);
      }
    }

    Map<String, String> query = {
      "addressid": '$addressId',
      "comment": comment,
      "date": date,
    };
    //print(query);
    request.fields.addAll(query);
    http.Response response =
        await http.Response.fromStream(await request.send());
    if (response.statusCode == 200 || response.statusCode == 201) {
      return APIResponse(
        statusCode: response.statusCode,
      );
    } else {
      return APIResponse(
        statusCode: response.statusCode,
        errorMessage: 'Please check your info',
      );
    }
  }

  Future<APIResponse> getUrgentRequestById(int urgentRequestId) async {
    errorToken = false;
    statusCode = -1;
    await getToken();
    return await http.get(
      Uri.https(url, '/api/v1/user_urgent_request/get_by/$urgentRequestId'),
      headers: <String, String>{
        'Authorization': 'Bearer $token',
        'Content-type': 'application/json',
        'Accept': 'application/json'
      },
    ).then((data) async {
      statusCode = data.statusCode;
      if (data.statusCode == 200 || data.statusCode == 201) {
        log("success rating");
        return APIResponse(
          statusCode: statusCode,
        );
      }
      return APIResponse(
          statusCode: statusCode, errorMessage: 'Please check your info');
    }).catchError((_) => APIResponse(
        statusCode: statusCode, errorMessage: 'no internet connection'));
  }

  Future<APIResponse<EmergencyList>> getUrgentRequestByState(
      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": '', "page": ''};
    }
    return await http.get(
      Uri.https(url, 'api/v1/technician/get_my_all_urgent_requests', 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);
        final result = EmergencyList.fromJson(jsonData);
        return APIResponse<EmergencyList>(statusCode: statusCode, data: result);
      }
      return APIResponse<EmergencyList>(
          statusCode: statusCode, errorMessage: 'Please check your info');
    }).catchError((_) => APIResponse<EmergencyList>(
        statusCode: statusCode, errorMessage: 'no internet connection'));
  }

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

  Future<APIResponse> changeUrgentRequestState(
      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_urgent_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) {
        return APIResponse(
          statusCode: statusCode,
        );
      }
      return APIResponse(
          statusCode: statusCode, errorMessage: 'Please check your info');
    }).catchError((_) => APIResponse(
        statusCode: statusCode, errorMessage: 'no internet connection'));
  }

  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_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) {
        return APIResponse(
          statusCode: statusCode,
        );
      }
      return APIResponse(
          statusCode: statusCode, errorMessage: 'Please check your info');
    }).catchError((_) => APIResponse(
        statusCode: statusCode, errorMessage: 'no internet connection'));
  }

  Future<APIResponse<UrgentRequest>> completeRequest(
      File file, double description, int requestId) async {
    errorToken = false;
    statusCode = -1;
    await getToken();
    final request = http.MultipartRequest(
        'PATCH',
        Uri.https(
            url, '/api/v1/technician/complete_urgent_request/$requestId'));
    Map<String, String> headers = {
      'Authorization': 'Bearer $token',
      'Accept': 'application/json',
      "Content-type": "multipart/form-data",
    };
    request.headers.addAll(headers);

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

    // Add the multipart file to the request
    request.files.add(multipartFile);

    Map<String, String> query = {
      "amount": '$description',
    };
    //print(query);
    request.fields.addAll(query);
    http.Response response =
        await http.Response.fromStream(await request.send());
    if (response.statusCode == 200 || response.statusCode == 201) {
      final jsonData = json.decode(response.body);
      //print(jsonData);
      final UrgentRequest result = UrgentRequest.fromJson(jsonData);
      // final result =ServiceRequestResponse.fromJson(jsonData);
      return APIResponse(statusCode: response.statusCode, data: result);
    } else {
      //print(response.statusCode);
      //print(response.body);
      //print("please Check");
      return APIResponse(
        statusCode: response.statusCode,
        errorMessage: 'Please check your info',
      );
    }
  }
}