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

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

import '../models/auth/add_missing_social_request.dart';
import '../models/auth/current_user_response.dart';
import '../models/auth/login_request_model.dart';
import '../models/auth/login_response.dart';
import '../models/auth/refresh_token_request_model.dart';
import '../models/utils/api_response.dart';
import '../utils/utils_singleton.dart';

const url = 'server.muaawana.com';

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

  /// Fetching Jwt Token From SharedPrefs Function
  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);
    return token.toString();
  }

  Future<APIResponse<SocialDataUser>> socialLoginMissingData(
      String deviceId, String deviceType, String ip) async {
    errorToken = false;
    statusCode = -1;
    final prefs = await SharedPreferences.getInstance();
    await getToken();
    String? fcmToken;
    await PushNotificationService().getFCMToken();
    fcmToken = prefs.getString("FCM token");
    log(fcmToken ?? "NoToken");
    var request = http.MultipartRequest(
        "POST", Uri.https(url, 'api/v1/add_missing_social_data'));
    Map<String, String> headers = {
      'Authorization': 'Bearer $token',
      'Accept': 'application/json',
      "Content-type": "multipart/form-data",
    };
    request.headers.addAll(headers);
    request.fields['deviceId'] = deviceId;
    request.fields['deviceType'] = deviceType;
    request.fields['ip'] = ip;
    request.fields['tokendevice'] = fcmToken ?? "";
    http.Response response =
        await http.Response.fromStream(await request.send());
    statusCode = response.statusCode;
    if (response.statusCode == 200 || response.statusCode == 201) {
      final jsonData = json.decode(response.body);
      SocialDataUser data = SocialDataUser.fromJson(jsonData);
      return APIResponse(statusCode: statusCode, data: data);
    } else {
      return APIResponse(statusCode: statusCode, errorMessage: response.body);
    }
  }

  Future<APIResponse> deleteAccount() async {
    errorToken = false;
    statusCode = -1;
    await getToken();
    return await http.delete(
      Uri.https(url, 'api/v1/delete_user'),
      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((_) {
      return APIResponse(
          statusCode: statusCode, errorMessage: 'no internet connection');
    });
  }

  ///    ****************** Auth Controllers ***************
  //
  /// Sing in service function
  Future<APIResponse<LoginResponse>> signIn(String email, String password,
      String? deviceId, String? deviceType, String? ip) async {
    errorToken = false;
    statusCode = -1;
    final prefs = await SharedPreferences.getInstance();
    String? FCMToken = prefs.getString("FCM token");
    await PushNotificationService().getFCMToken();
    FCMToken = prefs.getString("FCM token");
    log("FCM Token : $FCMToken");
    LoginRequestModel userLogin = LoginRequestModel(
        email: email,
        password: password,
        deviceId: deviceId,
        deviceType: deviceType,
        ip: ip,
        tokendevice: FCMToken ?? "");

    log("email : ${userLogin.email}");
    log("password : ${userLogin.password}");
    log("Token Device :  ${userLogin.tokendevice}");
    log("Device Type : ${userLogin.deviceType}");
    log("Device Id : ${userLogin.deviceId}");
    log("Ip Address : ${userLogin.ip}");
    return await http
        .post(Uri.https(url, 'api/v1/auth/signin'),
            headers: <String, String>{
              'Content-type': 'application/json',
              'Accept': 'application/json'
            },
            body: jsonEncode(userLogin.toJson()))
        .then((data) async {
      statusCode = data.statusCode;
      log("-------> Sign In Status Code : ");
      log(statusCode.toString());
      log(data.body.toString());
      if (data.statusCode == 200 || data.statusCode == 201) {
        final jsonData = json.decode(data.body);
        log(" -------> Sign In response Body :");
        log("$jsonData");
        LoginResponse response = LoginResponse.fromJson(jsonData);
        prefs.setString('token', response.token!);
        log("Acquired user token: ${response.token}");
        prefs.setString('refreshToken', response.refreshtoken!);
        prefs.setString('Email', email);
        prefs.setString('Password', password);
        prefs.setString('Role', response.roles!);
        prefs.setBool("isLoggedIn", true);
        prefs.setInt("expireIn", response.tokenExpirydate!);
        prefs.setInt("userId", response.userId!);
        util.userId = response.userId!;
        log("--------> expires in : ${response.tokenExpirydate}");
        return APIResponse<LoginResponse>(
            statusCode: statusCode, data: response);
      }
      return APIResponse<LoginResponse>(
          statusCode: statusCode, errorMessage: 'Please check your info');
    }).catchError((err) {
      log("-------> Sign In Error :");
      log(err);
      return APIResponse<LoginResponse>(
          statusCode: statusCode, errorMessage: 'no internet connection');
    });
  }

  /// Sing up service function
  Future<APIResponse<LoginResponse>> singUp(
    String email,
    String password,
    String fullName,
    String phoneNumber,
  ) async {
    errorToken = false;
    statusCode = -1;
    var request = http.MultipartRequest(
        "POST", Uri.https(url, 'api/v1/auth/signup_user'));
    Map<String, String> headers = {
      'Accept': 'application/json',
      "Content-type": "multipart/form-data",
    };
    request.headers.addAll(headers);
    request.fields['email'] = email;
    request.fields['password'] = password;
    request.fields['name'] = fullName;
    request.fields['phonenumber'] = phoneNumber;

    http.Response response =
        await http.Response.fromStream(await request.send());
    statusCode = response.statusCode;
    if (response.statusCode == 200 || response.statusCode == 201) {
      final jsonData = json.decode(response.body);
      LoginResponse result = LoginResponse.fromJson(jsonData);
      return APIResponse(statusCode: statusCode, data: result);
    } else {
      return APIResponse(statusCode: statusCode, errorMessage: response.body);
    }
  }

  /// Change / Update user password service function
  updatePassword(String newPassword, String oldPassword) async {
    errorToken = false;
    statusCode = -1;

    final prefs = await SharedPreferences.getInstance();

    // final oldPassword = prefs.getString("Password");

    await getToken();

    var request = http.MultipartRequest(
        "PATCH", Uri.https(url, 'api/v1/auth/update_password'));
    Map<String, String> headers = {
      'Authorization': 'Bearer $token',
      'Accept': 'application/json',
      "Content-type": "multipart/form-data",
    };
    request.headers.addAll(headers);
    request.fields['oldpassword'] = oldPassword;
    request.fields['password'] = newPassword;
    http.Response response =
        await http.Response.fromStream(await request.send());
    statusCode = response.statusCode;

    if (response.statusCode == 200 || response.statusCode == 201) {
      prefs.setString('Password', newPassword);
      return APIResponse(statusCode: statusCode);
    } else {
      return APIResponse(statusCode: statusCode, errorMessage: response.body);
    }
  }

  /// Fetching Current User Data Service Function
  Future<APIResponse<CurrentUser>> getCurrentUser() async {
    errorToken = false;
    statusCode = -1;
    await getToken();
    return await http.get(
      Uri.https(url, 'api/v1/auth/current_user'),
      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("-------> User Data \n $jsonData");
        log("-------> User Data --- Bearer $token");
        CurrentUser profile = CurrentUser.fromJson(jsonData);
        return APIResponse<CurrentUser>(statusCode: statusCode, data: profile);
      }
      return APIResponse<CurrentUser>(
          statusCode: statusCode, errorMessage: 'Please check your info');
    }).catchError((_) => APIResponse<CurrentUser>(
        statusCode: statusCode, errorMessage: 'no internet connection'));
  }

  /// Update Current User Data Service Function
  Future<APIResponse<CurrentUser>> updateUserData(
      String? name, String? phonenumber, String? country) async {
    errorToken = false;
    statusCode = -1;
    await getToken();
    final query = {
      'name': name,
      'phonenumber': phonenumber,
      'country': country,
    };
    return await http.patch(
      Uri.https(url, 'api/v1/update_user', query),
      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("-------> User Data \n $jsonData");
        CurrentUser profile = CurrentUser.fromJson(jsonData);
        return APIResponse<CurrentUser>(statusCode: statusCode, data: profile);
      }
      return APIResponse<CurrentUser>(
          statusCode: statusCode, errorMessage: 'Please check your info');
    }).catchError((_) => APIResponse<CurrentUser>(
        statusCode: statusCode, errorMessage: 'no internet connection'));
  }

  /// Refresh Token Service Function
  refreshToken() async {
    final prefs = await SharedPreferences.getInstance();
    String? FCMToken = prefs.getString("FCM token");
    // await PushNotificationService().getFCMToken();
    FCMToken = prefs.getString("FCM token");
    String? token = prefs.getString("token");
    String? refreshToken = prefs.getString('refreshToken');

    RefreshTokenRequest refreshRequest = RefreshTokenRequest(
        deviceId: 'test',
        deviceType: 'test',
        ip: 'test',
        refreshToken: refreshToken!,
        token: token!,
        tokendevice: FCMToken!);
    return await http
        .post(Uri.https(url, 'api/v1/auth/refreshtoken'),
            headers: <String, String>{
              'Content-type': 'application/json',
              'Accept': 'application/json'
            },
            body: jsonEncode(refreshRequest.toJson()))
        .then((data) async {
      statusCode = data.statusCode;
      log("-------> Refresh Token Status Code : ");
      log(statusCode.toString());
      if (data.statusCode == 200 || data.statusCode == 201) {
        log("-------> Refresh Token response Data : ");
        log(data.body);
        final jsonData = json.decode(data.body);
        log("-------> Refresh Token response Data Decoded : ");
        log(jsonData);
        LoginResponse response = LoginResponse.fromJson(jsonData);
        prefs.setString('token', response.token!);
        prefs.setString('refreshToken', response.refreshtoken!);
        prefs.setString('Role', response.roles!);
        prefs.setBool("isLoggedIn", true);
        prefs.setInt("expireIn", response.tokenExpirydate!);
        log("--------> expires in : ${response.tokenExpirydate}");
        return APIResponse<LoginResponse>(
            statusCode: statusCode, data: response);
      }
      return APIResponse<LoginResponse>(
          statusCode: statusCode, errorMessage: 'Please check your info');
    }).catchError((err) {
      log("-------> Refresh Token response Error Caught : ");
      log(err);
      return APIResponse<LoginResponse>(
          statusCode: statusCode, errorMessage: 'no internet connection');
    });
  }

  /// Reset Password ---> First Step / Service Function
  resetPassword(String email) async {
    statusCode = -1;
    var request = http.MultipartRequest(
        "POST", Uri.https(url, 'api/v1/auth/reset_password_first_step'));
    Map<String, String> headers = {
      'Accept': 'application/json',
      "Content-type": "multipart/form-data",
    };
    request.headers.addAll(headers);
    request.fields['email'] = email;

    http.Response response =
        await http.Response.fromStream(await request.send());
    if (response.statusCode == 200 || response.statusCode == 201) {
      return APIResponse(statusCode: response.statusCode);
    }
    return APIResponse(
        statusCode: response.statusCode,
        errorMessage: 'Please check your info');
  }

  /// Validate Reset Code ---> Second Step / Service Function
  validateResetCode(String email, String resetCode) async {
    statusCode = -1;
    var request = http.MultipartRequest(
        "POST", Uri.https(url, 'api/v1/auth/validate_reset_code_second_step'));
    Map<String, String> headers = {
      'Accept': 'application/json',
      "Content-type": "multipart/form-data",
    };
    request.headers.addAll(headers);
    request.fields['email'] = email;
    request.fields['reset_code'] = resetCode;

    http.Response response =
        await http.Response.fromStream(await request.send());
    statusCode = response.statusCode;
    if (response.statusCode == 200 || response.statusCode == 201) {
      return APIResponse(statusCode: statusCode);
    }
    return APIResponse(
        statusCode: statusCode, errorMessage: 'Please check your info');
  }

  /// Change Password Final Step ---> Final Step / Service Function
  changePasswordFinal(String email, String password, String resetCode) async {
    statusCode = -1;
    var request = http.MultipartRequest(
        "POST", Uri.https(url, 'api/v1/auth/change_password_final_step'));
    Map<String, String> headers = {
      'Accept': 'application/json',
      "Content-type": "multipart/form-data",
    };
    request.headers.addAll(headers);
    request.fields['email'] = email;
    request.fields['password'] = password;
    request.fields['reset_code'] = resetCode;
    http.Response response =
        await http.Response.fromStream(await request.send());
    statusCode = response.statusCode;
    if (response.statusCode == 200 || response.statusCode == 201) {
      return APIResponse(statusCode: statusCode);
    }
    return APIResponse(
        statusCode: statusCode, errorMessage: 'Please check your info');
  }

  /// Logout Service Function
  Future<APIResponse> logout(String deviceId, String deviceType, String ip) async {
    log(token);
    errorToken = false;
    statusCode = -1;

    await getToken();
    log("-----> logout Service API Response Status Code: ");
    return await http.put(Uri.https(url, '/api/v1/auth/logout'),
            headers: <String, String>{
              'Authorization': 'Bearer $token',
              'Content-type': 'application/json',
              'Accept': 'application/json'
            },
            body: jsonEncode({
              "deviceInfo": {
                "deviceId": deviceId,
                "deviceType": deviceType,
              },
              "token": token
            })).then((data) async {
      log("-----> logout Service API Response Status Code: ${data.statusCode}");
      log("-----> logout Service API Response Status Code: ${data.body}");
      statusCode = data.statusCode;
      if (data.statusCode == 200 || data.statusCode == 201) {
        return APIResponse(statusCode: statusCode);
      }
      return APIResponse(
          statusCode: statusCode, errorMessage: 'Please check your info');
    }).catchError((err, stack) {
      //print(stack);
      return APIResponse(
          statusCode: statusCode, errorMessage: 'no internet connection');
    });
  }

  ///    ****************** Users Controllers ***************
  //
  ///    Add Missing User Data Service Function -- Invoked to fill user data
  ///    after login using social login since not all user data are given.
  // addMissingUserDataSocial() async {
  //   final prefs = await SharedPreferences.getInstance();
  //   String? FCMToken = prefs.getString("FCM token");
  //
  //   // await PushNotificationService().getFCMToken();
  //   FCMToken = prefs.getString("FCM token");
  //   String? token = prefs.getString("token");
  //
  //   MissingSocialDataRequest addMissingDataRequest = MissingSocialDataRequest(
  //       deviceId: 'test',
  //       deviceType: 'test',
  //       ip: 'test',
  //       tokendevice: FCMToken!);
  //   return await http
  //       .post(Uri.https(url, '/api/v1/add_missing_social_data'),
  //           headers: <String, String>{
  //             'Authorization': 'Bearer $token',
  //             'Content-type': 'application/json',
  //             'Accept': 'application/json'
  //           },
  //           body: jsonEncode(addMissingDataRequest.toJson()))
  //       .then((data) async {
  //     statusCode = data.statusCode;
  //     log("-------> Add Missing User Data Status Code : ");
  //     log(statusCode.toString());
  //     if (data.statusCode == 200 || data.statusCode == 201) {
  //       log("-------> Add Missing User Data response Data : ");
  //       log(data.body);
  //       final codeUnits = data.body.codeUnits;
  //       var str = const Utf8Decoder().convert(codeUnits);
  //       final jsonData = json.decode(str);        log("-------> Add Missing User Data response Data Decoded : ");
  //       log(jsonData);
  //       // LoginResponse response = LoginResponse.fromJson(jsonData);
  //       // prefs.setString('token', response.token!);
  //       // prefs.setString('Role', response.roles!);
  //       // prefs.setBool("isLoggedIn", true);
  //       // prefs.setInt("expireIn", response.tokenExpirydate!);
  //       // log("--------> expires in : ${response.tokenExpirydate}");
  //       return APIResponse(
  //         statusCode: statusCode,
  //       );
  //     }
  //     return APIResponse(
  //         statusCode: statusCode, errorMessage: 'Please check your info');
  //   }).catchError((err) {
  //     log("-------> Refresh Token response Error Caught : ");
  //     log(err);
  //     return APIResponse(
  //         statusCode: statusCode, errorMessage: 'no internet connection');
  //   });
  // }

  /// Get User Data -Social Login- Service Function
  /// NOT BEING USED !!!
  currentUser() async {
    errorToken = false;
    statusCode = -1;
    await getToken();
    return await http.get(
      Uri.https(url, 'api/v1/current_user'),
      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("-------> User Data \n $jsonData");
        CurrentUser profile = CurrentUser.fromJson(jsonData);
        return APIResponse<CurrentUser>(statusCode: statusCode, data: profile);
      }
      return APIResponse<CurrentUser>(
          statusCode: statusCode, errorMessage: 'Please check your info');
    }).catchError((_) => APIResponse<CurrentUser>(
        statusCode: statusCode, errorMessage: 'no internet connection'));
  }

  /// Logout user -Social Login- Service Function
  logoutSocial(String deviceId, String deviceType, String ip) async {
    errorToken = false;
    statusCode = -1;
    await getToken();
    return await http
        .put(Uri.https(url, 'api/v1/logout'),
            headers: <String, String>{
              'Authorization': 'Bearer $token',
              'Content-type': 'application/json',
              'Accept': 'application/json'
            },
            body: jsonEncode({
              "deviceInfo": {
                "deviceId": deviceId,
                "deviceType": deviceType,
              },
              "token": token
            }))
        .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((err) {
      return APIResponse(
          statusCode: statusCode, errorMessage: 'no internet connection');
    });
  }

  /// Update User Password -Social Login- Service Function
  updatePasswordSocial(String newPassword) async {
    errorToken = false;
    statusCode = -1;

    final prefs = await SharedPreferences.getInstance();

    await getToken();

    var request = http.MultipartRequest(
        "PATCH", Uri.https(url, 'api/v1/update_password'));
    Map<String, String> headers = {
      'Authorization': 'Bearer $token',
      'Accept': 'application/json',
      "Content-type": "multipart/form-data",
    };
    request.headers.addAll(headers);
    request.fields['password'] = newPassword;
    http.Response response =
        await http.Response.fromStream(await request.send());
    statusCode = response.statusCode;

    if (response.statusCode == 200 || response.statusCode == 201) {
      prefs.setString('Password', newPassword);
      return APIResponse(statusCode: statusCode);
    } else {
      return APIResponse(statusCode: statusCode, errorMessage: response.body);
    }
  }

  /// Add Address Service Function
  addAddress(String newAddress) async {
    errorToken = false;
    statusCode = -1;

    // final prefs = await SharedPreferences.getInstance();

    await getToken();

    var request =
        http.MultipartRequest("PATCH", Uri.https(url, 'api/v1/add_address'));
    Map<String, String> headers = {
      'Authorization': 'Bearer $token',
      'Accept': 'application/json',
      "Content-type": "multipart/form-data",
    };
    request.headers.addAll(headers);
    request.fields['address'] = newAddress;
    http.Response response =
        await http.Response.fromStream(await request.send());
    statusCode = response.statusCode;

    if (response.statusCode == 200 || response.statusCode == 201) {
      return APIResponse(statusCode: statusCode);
    } else {
      return APIResponse(statusCode: statusCode, errorMessage: response.body);
    }
  }

  Future<APIResponse> addProfilePicture(
    File image,
  ) async {
    errorToken = false;
    statusCode = -1;
    await getToken();
    final request =
        http.MultipartRequest('PATCH', Uri.https(url, 'api/v1/update_user'));
    Map<String, String> headers = {
      'Authorization': 'Bearer $token',
      'Accept': 'application/json',
      "Content-type": "multipart/form-data",
    };
    request.headers.addAll(headers);
    final multipartFile = await http.MultipartFile(
      'file',
      image.readAsBytes().asStream(),
      image.lengthSync(),
      filename: image.path.split("/").last,
      contentType: MediaType("image", image.path.split(".").last),
    );
    request.files.add(multipartFile);
    http.Response response =
        await http.Response.fromStream(await request.send());
    if (response.statusCode == 200 || response.statusCode == 201) {

      final jsonData = json.decode(response.body);
      return APIResponse(
        statusCode: response.statusCode,
        data: jsonData
      );
    } else {
      //print(response.statusCode);
      //print(response.body);
      //print("please Check");
      return APIResponse(
        statusCode: response.statusCode,
        errorMessage: 'Please check your info',
      );
    }
  }
}