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

import 'package:muaawana/models/booking_product/Booking_product_response.dart';
import 'package:muaawana/models/booking_service/Booking_request_response.dart';
import 'package:muaawana/models/services/result.dart';
import 'package:shared_preferences/shared_preferences.dart';
import 'package:http/http.dart' as http;

import '../models/booking_service/Result.dart';
import '../models/utils/api_response.dart';

const url = 'server.muaawana.com';

class UserRequestStatus {
  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')!;
    }
    print('token -- $token');
    return token.toString();
  }

  /// Fetching User Service Requests
  ///
  ///
  Future<APIResponse<BookingRequestResponse>>
      fetchUserServiceRequestPg() async {
    errorToken = false;
    statusCode = -1;
    await getToken();
    final params = {'page': '0', 'size': '50'};
    return await http.get(
      Uri.https(url, '/api/v1/user_request/get_all_by_state', params),
      headers: <String, String>{
        'Authorization': 'Bearer $token',
        'Content-type': 'application/json',
        'Accept': 'application/json'
      },
    ).then((data) {
      dev.log("fetchUserServiceRequestPg----------------------------${data.body}");
      statusCode = data.statusCode;
      if (data.statusCode == 200 || data.statusCode == 201) {
        final jsonData = json.decode(data.body);
        BookingRequestResponse result =
            BookingRequestResponse.fromJson(jsonData);

        return APIResponse<BookingRequestResponse>(
            statusCode: statusCode, data: result);
      }
      return APIResponse<BookingRequestResponse>(
          statusCode: statusCode, errorMessage: 'Please check your info');
    }).catchError((_, stack) {
      //print(stack);
      return APIResponse<BookingRequestResponse>(
          statusCode: statusCode, errorMessage: 'no internet connection');
    });
  }

  Future<APIResponse<ServiceResult>> fetchUserServiceRequestById(int id) async {
    errorToken = false;
    statusCode = -1;
    await getToken();
    return await http.get(
      Uri.https(
        url,
        '/api/v1/user_request/get_by/$id',
      ),
      headers: <String, String>{
        'Authorization': 'Bearer $token',
        'Content-type': 'application/json',
        'Accept': 'application/json'
      },
    ).then((data) {
      dev.log("fetchUserServiceRequestById----------------------------${data.body}");
      statusCode = data.statusCode;
      if (data.statusCode == 200 || data.statusCode == 201) {

        final jsonData = json.decode(data.body);

        ServiceResult result = ServiceResult.fromJson(jsonData);

        return APIResponse<ServiceResult>(statusCode: statusCode, data: result);
      }
      return APIResponse<ServiceResult>(
          statusCode: statusCode, errorMessage: 'Please check your info');
    }).catchError((_, stack) {
      //print(stack);
      return APIResponse<ServiceResult>(
          statusCode: statusCode, errorMessage: 'no internet connection');
    });
  }

  /// Fetching User Product Requests
  Future<APIResponse<BookingProductResponse>>
      fetchUserProductRequestPg() async {
    errorToken = false;
    statusCode = -1;
    await getToken();
    final params = {'page': '0', 'size': '50'};
    return await http.get(
      Uri.https(url, '/api/v1/user_product_request/get_all_by_state', params),
      headers: <String, String>{
        'Authorization': 'Bearer $token',
        'Content-type': 'application/json',
        'Accept': 'application/json'
      },
    ).then((data) {
      dev.log("fetchUserProductRequestPg----------------------------${data.body}");
      statusCode = data.statusCode;
      if (data.statusCode == 200 || data.statusCode == 201) {

        final jsonData = json.decode(data.body);
        BookingProductResponse result =
            BookingProductResponse.fromJson(jsonData);
        return APIResponse<BookingProductResponse>(
            statusCode: statusCode, data: result);
      }
      return APIResponse<BookingProductResponse>(
          statusCode: statusCode, errorMessage: 'Please check your info');
    }).catchError((_) => APIResponse<BookingProductResponse>(
        statusCode: statusCode, errorMessage: 'no internet connection'));
  }

  Future<APIResponse> cancelServiceRequest(int serviceId) async {
    errorToken = false;
    statusCode = -1;

    await getToken();

    return await http.patch(
      Uri.https(url, '/api/v1/user_request/cancel_request/$serviceId'),
      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) {

        return APIResponse(statusCode: statusCode,);
      }
      return APIResponse(
        statusCode: statusCode,
        errorMessage: 'Please check your info',
      );
    }).catchError(
      (_) => APIResponse(
          statusCode: statusCode, errorMessage: 'no internet connection'),
    );
  }

  Future<APIResponse<Service>> fetchService(int id) async {
    errorToken = false;
    statusCode = -1;
    await getToken();
    return await http.get(
      Uri.https(url, '/api/v1/user_service/get_by/$id'),
      headers: <String, String>{
        'Authorization': 'Bearer $token',
        'Content-type': 'application/json',
        'Accept': 'application/json'
      },
    ).then((data) {
      dev.log(data.body);
      statusCode = data.statusCode;
      if (data.statusCode == 200 || data.statusCode == 201) {
        final codeUnits = data.body.codeUnits;
        var str = const Utf8Decoder().convert(codeUnits);
        final jsonData = json.decode(str);
        final result = Service.fromJson(jsonData);
        return APIResponse<Service>(statusCode: statusCode, data: result);
      }
      return APIResponse<Service>(
          statusCode: statusCode, errorMessage: 'Please check your info');
    }).catchError((_) => APIResponse<Service>(
        statusCode: statusCode, errorMessage: 'no internet connection'));
  }
}