import 'dart:convert';
import 'package:Tripz/constant/box_name.dart';
import 'package:Tripz/constant/links.dart';
import 'package:Tripz/controller/auth/login_controller.dart';
import 'package:Tripz/main.dart';
import 'package:get/get.dart';
import 'package:http/http.dart' as http;
import 'package:Tripz/env/env.dart';
import 'package:secure_string_operations/secure_string_operations.dart';

import '../../constant/api_key.dart';

import '../../constant/char_map.dart';
import '../../constant/info.dart';
import '../../print.dart';
import '../../views/widgets/elevated_btn.dart';
import '../../views/widgets/error_snakbar.dart';
import 'add_error.dart';
import 'upload_image.dart';

class CRUD {
  Future<dynamic> get({
    required String link,
    Map<String, dynamic>? payload,
  }) async {
    var url = Uri.parse(
      link,
    );
    var response = await http.post(
      url,
      body: payload,
      headers: {
        "Content-Type": "application/x-www-form-urlencoded",
        'Authorization':
            'Bearer ${X.r(X.r(X.r(box.read(BoxName.jwt), cn), cC), cs).toString().split(AppInformation.addd)[0]}'
      },
    );
    // print('req: ${response.request}');
    // Log.print('response: ${response.body}');
    // Log.print('payload: ${payload}');

    if (response.statusCode == 200) {
      var jsonData = jsonDecode(response.body);
      if (jsonData['status'] == 'success') {
        return response.body;
      }

      return jsonData['status'];
    } else if (response.statusCode == 401) {
      // Specifically handle 401 Unauthorized
      var jsonData = jsonDecode(response.body);

      if (jsonData['error'] == 'Token expired') {
        // Show snackbar prompting to re-login
        await Get.put(LoginController()).getJWT();
        // mySnackbarSuccess('please order now'.tr);
        return 'token_expired'; // Return a specific value for token expiration
      } else {
        // Other 401 errors
        // addError('Unauthorized: ${jsonData['error']}', 'crud().post - 401');
        return 'failure';
      }
    } else {
      addError('Non-200 response code: ${response.statusCode}',
          'crud().post - Other');
      return 'failure';
    }
  }

  Future<dynamic> getWallet({
    required String link,
    Map<String, dynamic>? payload,
  }) async {
    var s = await LoginController().getJwtWallet();
    final hmac = box.read(BoxName.hmac);
    // Log.print('hmac: ${hmac}');
    var url = Uri.parse(
      link,
    );
    var response = await http.post(
      url,
      body: payload,
      headers: {
        "Content-Type": "application/x-www-form-urlencoded",
        'Authorization': 'Bearer $s',
        'X-HMAC-Auth': hmac.toString(),
      },
    );
    // print('req: ${response.request}');
    // Log.print('response: ${response.body}');
    // Log.print('payload: ${payload}');

    if (response.statusCode == 200) {
      var jsonData = jsonDecode(response.body);
      Log.print('jsonData: $jsonData');
      if (jsonData['status'] == 'success') {
        return response.body;
      }

      return jsonData['status'];
    } else if (response.statusCode == 401) {
      // Specifically handle 401 Unauthorized
      var jsonData = jsonDecode(response.body);

      if (jsonData['error'] == 'Token expired') {
        // Show snackbar prompting to re-login
        await Get.put(LoginController()).getJwtWallet();

        return 'token_expired'; // Return a specific value for token expiration
      } else {
        // Other 401 errors
        // addError('Unauthorized: ${jsonData['error']}', 'crud().post - 401');
        return 'failure';
      }
    } else {
      addError('Non-200 response code: ${response.statusCode}',
          'crud().post - Other');
      return 'failure';
    }
  }

  Future<dynamic> post(
      {required String link, Map<String, dynamic>? payload}) async {
    var url = Uri.parse(link);
    try {
      var response = await http.post(
        url,
        body: payload,
        headers: {
          "Content-Type": "application/x-www-form-urlencoded",
          'Authorization':
              'Bearer ${X.r(X.r(X.r(box.read(BoxName.jwt), cn), cC), cs).toString().split(AppInformation.addd)[0]}'
          // 'Authorization': 'Bearer ${box.read(BoxName.jwt)}'
        },
      );
      // Log.print('req: ${response.request}');
      // Log.print('response: ${response.body}');
      // Log.print('payload: ${payload}');

      if (response.statusCode == 200) {
        try {
          var jsonData = jsonDecode(response.body);
          if (jsonData['status'] == 'success') {
            return jsonData;
          } else {
            return jsonData['status'];
          }
        } catch (e) {
          // addError(e.toString(), 'crud().post - JSON decoding');
          return 'failure';
        }
      } else if (response.statusCode == 401) {
        // Specifically handle 401 Unauthorized
        var jsonData = jsonDecode(response.body);

        if (jsonData['error'] == 'Token expired') {
          // Show snackbar prompting to re-login
          await Get.put(LoginController()).getJWT();
          // MyDialog().getDialog(
          //   'Session expired. Please log in again.'.tr,
          //   '',
          //   () {
          //     Get.put(LoginController()).loginUsingCredentials(
          //         box.read(BoxName.passengerID), box.read(BoxName.email));
          //     Get.back();
          //   },
          // );

          return 'token_expired'; // Return a specific value for token expiration
        } else {
          // Other 401 errors
          // addError('Unauthorized: ${jsonData['error']}', 'crud().post - 401');
          return 'failure';
        }
      } else {
        // addError('Non-200 response code: ${response.statusCode}',
        //     'crud().post - Other');
        return 'failure';
      }
    } catch (e) {
      addError('HTTP request error: $e', 'crud().post - HTTP');
      return 'failure';
    }
  }

  Future<dynamic> postWallet(
      {required String link, Map<String, dynamic>? payload}) async {
    var s = await LoginController().getJwtWallet();

    final hmac = box.read(BoxName.hmac);

    var url = Uri.parse(link);
    try {
      var response = await http.post(
        url,
        body: payload,
        headers: {
          "Content-Type": "application/x-www-form-urlencoded",
          'Authorization': 'Bearer $s',
          'X-HMAC-Auth': hmac.toString(),
        },
      );
      // print('req: ${response.request}');
      // Log.print('response: ${response.body}');
      // Log.print('payload: ${payload}');

      if (response.statusCode == 200) {
        try {
          var jsonData = jsonDecode(response.body);
          if (jsonData['status'] == 'success') {
            return jsonData;
          } else {
            return jsonData['status'];
          }
        } catch (e) {
          // addError(e.toString(), 'crud().post - JSON decoding');
          return 'failure';
        }
      } else if (response.statusCode == 401) {
        // Specifically handle 401 Unauthorized
        var jsonData = jsonDecode(response.body);

        if (jsonData['error'] == 'Token expired') {
          return 'token_expired'; // Return a specific value for token expiration
        } else {
          // Other 401 errors
          // addError('Unauthorized: ${jsonData['error']}', 'crud().post - 401');
          return 'failure';
        }
      } else {
        // addError('Non-200 response code: ${response.statusCode}',
        //     'crud().post - Other');
        return 'failure';
      }
    } catch (e) {
      addError('HTTP request error: $e', 'crud().post - HTTP');
      return 'failure';
    }
  }

  Future<dynamic> getTokenParent({
    required String link,
    Map<String, dynamic>? payload,
  }) async {
    var url = Uri.parse(
      link,
    );
    var response = await http.post(
      url,
      body: payload,
      headers: {
        "Content-Type": "application/x-www-form-urlencoded",
        'Authorization':
            'Basic ${base64Encode(utf8.encode(AK.basicAuthCredentials.toString()))}',
      },
    );
    if (response.statusCode == 200) {
      var jsonData = jsonDecode(response.body);
      // if (jsonData['status'] == 'success') {

      return jsonData;
      // }

      // return jsonData['status'];
    }
  }

  Future sendWhatsAppAuth(String to, String token) async {
    var res = await CRUD()
        .get(link: AppLink.getApiKey, payload: {'keyName': 'whatsapp_key'});
    var accesstoken = jsonDecode(res)['message']['whatsapp_key'];
    var headers = {
      'Authorization': 'Bearer $accesstoken',
      'Content-Type': 'application/json'
    };

    var url = 'https://graph.facebook.com/v20.0/${Env.whatappID}/messages';
    var request = http.Request('POST', Uri.parse(url));

    var body = json.encode({
      "messaging_product": "whatsapp",
      "to": to,
      "type": "template",
      "template": {
        "name": "sefer1",
        "language": {"code": "en"},
        "components": [
          {
            "type": "body",
            "parameters": [
              {
                "type": "text",
                "text": token,
              }
            ]
          }
        ]
      }
    });

    request.body = body;
    request.headers.addAll(headers);

    try {
      http.StreamedResponse response = await request.send();

      if (response.statusCode == 200) {
        String responseBody = await response.stream.bytesToString();

        Get.defaultDialog(
          title: 'You will receive a code in WhatsApp Messenger'.tr,
          middleText: 'wait 1 minute to recive message'.tr,
          confirm: MyElevatedButton(
            title: 'OK'.tr,
            onPressed: () {
              Get.back();
            },
          ),
        );
      } else {
        String errorBody = await response.stream.bytesToString();
      }
    } catch (e) {}
  }

  Future<dynamic> getAgoraToken({
    required String channelName,
    required String uid,
  }) async {
    var uid = box.read(BoxName.phone) ?? box.read(BoxName.phoneDriver);
    var res = await http.get(Uri.parse(
            // 'https://repulsive-pig-rugby-shirt.cyclic.app/token?channelName=$channelName'),
            'https://orca-app-b2i85.ondigitalocean.app/token?channelName=$channelName'),
        headers: {'Authorization': 'Bearer ${AK.agoraAppCertificate}'});

    if (res.statusCode == 200) {
      var response = jsonDecode(res.body);
      return response['token'];
    } else {}
  }

  Future<dynamic> getLlama({
    required String link,
    required String payload,
    required String prompt,
  }) async {
    var url = Uri.parse(
      link,
    );
    var headers = {
      'Content-Type': 'application/json',
      'Authorization':
          'Bearer LL-X5lJ0Px9CzKK0HTuVZ3u2u4v3tGWkImLTG7okGRk4t25zrsLqJ0qNoUzZ2x4ciPy'
      // 'Authorization': 'Bearer ${Env.llamaKey}'
    };
    var data = json.encode({
      "model": "Llama-3-70b-Inst-FW",
      // "model": "llama-13b-chat",
      "messages": [
        {
          "role": "user",
          "content":
              "Extract the desired information from the following passage as json decoded like $prompt just in this:\n\n$payload"
        }
      ],
      "temperature": 0.9
    });
    var response = await http.post(
      url,
      body: data,
      headers: headers,
    );

    if (response.statusCode == 200) {
      return response.body;
    }
    return response.statusCode;
  }

  Future allMethodForAI(String prompt, linkPHP, imagePath) async {
    await ImageController().choosImage(linkPHP, imagePath);
    Future.delayed(const Duration(seconds: 2));
    String extracted =
        await arabicTextExtractByVisionAndAI(imagePath: imagePath);
    // await AI().geminiAiExtraction(prompt, extracted);
  }

  Future<dynamic> arabicTextExtractByVisionAndAI({
    required String imagePath,
  }) async {
    var headers = {
      'Content-Type': 'application/json',
      'Ocp-Apim-Subscription-Key': '21010e54b50f41a4904708c526e102df'
    };
    var url = Uri.parse(
      'https://ocrhamza.cognitiveservices.azure.com/vision/v2.1/ocr?language=ar',
    );
    String imagePathFull =
        '${AppLink.server}card_image/$imagePath-${box.read(BoxName.driverID) ?? box.read(BoxName.passengerID)}.jpg';

    var requestBody = {"url": imagePathFull};
    var response = await http.post(
      url,
      body: jsonEncode(requestBody), // Encode the JSON object to a string
      headers: headers,
    );

    if (response.statusCode == 200) {
      var responseBody = jsonDecode(response.body);
      return responseBody.toString();
    }
    return response.statusCode;
  }

  Future<dynamic> getChatGPT({
    required String link,
    required String payload,
  }) async {
    var url = Uri.parse(
      link,
    );
    var headers = {
      'Content-Type': 'application/json',
      'Authorization': 'Bearer ${Env.chatGPTkeySeferNew}'
    };
    var data = json.encode({
      "model": "gpt-3.5-turbo",
      "messages": [
        {
          "role": "user",
          "content":
              "Extract the desired information from the following passage as json decoded like vin,make,made,year,expiration_date,color,owner,registration_date just in this:\n\n$payload"
        }
      ],
      "temperature": 0.9
    });
    var response = await http.post(
      url,
      body: data,
      headers: headers,
    );

    if (response.statusCode == 200) {
      return response.body;
    }
    return response.statusCode;
  }

  Future<dynamic> postStripe({
    required String link,
    Map<String, dynamic>? payload,
  }) async {
    // String? secretKey = await storage.read(key: BoxName.secretKey);
    var url = Uri.parse(
      link,
    );
    var response = await http.post(
      url,
      body: payload,
      headers: {
        "Content-Type": "application/x-www-form-urlencoded",
        'Authorization': 'Bearer ${AK.secretKey}',
      },
    );
    if (response.statusCode == 200) {
      return response.body;
    } else {}
  }

  // Future<dynamic> post({
  //   required String link,
  //   Map<String, dynamic>? payload,
  // }) async {
  //   // String? basicAuthCredentials =
  //   //     await storage.read(key: BoxName.basicAuthCredentials);
  //   var url = Uri.parse(
  //     link,
  //   );
  //   var response = await http.post(
  //     url,
  //     body: payload,
  //     headers: {
  //       "Content-Type": "application/x-www-form-urlencoded",
  //       'Authorization':
  //           'Basic ${base64Encode(utf8.encode(AK.basicAuthCredentials))}',
  //     },
  //   );
  //   var jsonData = jsonDecode(response.body);
  //   if (response.statusCode == 200) {
  //     if (jsonData['status'] == 'success') {
  //       return response.body;
  //     } else {
  //       return (jsonData['status']);
  //     }
  //   } else {
  //     return response.statusCode;
  //   }
  // }

  Future<dynamic> postPayMob({
    required String link,
    Map<String, dynamic>? payload,
  }) async {
    // String? basicAuthCredentials =
    //     await storage.read(key: BoxName.basicAuthCredentials);
    var url = Uri.parse(
      link,
    );
    var response = await http.post(url,
        body: payload, headers: {'Content-Type': 'application/json'});

    var jsonData = jsonDecode(response.body);
    if (response.statusCode == 200) {
      if (jsonData['status'] == 'success') {
        return response.body;
      } else {
        return (jsonData['status']);
      }
    } else {
      return response.statusCode;
    }
  }

  sendEmail(
    String link,
    Map<String, String>? payload,
  ) async {
    var headers = {
      "Content-Type": "application/x-www-form-urlencoded",
      'Authorization':
          'Basic ${base64Encode(utf8.encode(AK.basicAuthCredentials))}',
    };
    var request = http.Request('POST', Uri.parse(link));
    request.bodyFields = payload!;
    request.headers.addAll(headers);

    http.StreamedResponse response = await request.send();
    if (response.statusCode == 200) {
    } else {}
  }

  Future<dynamic> postFromDialogue({
    required String link,
    Map<String, dynamic>? payload,
  }) async {
    // String? basicAuthCredentials =
    //     await storage.read(key: BoxName.basicAuthCredentials);
    var url = Uri.parse(
      link,
    );
    var response = await http.post(
      url,
      body: payload,
      headers: {
        "Content-Type": "application/x-www-form-urlencoded",
        'Authorization':
            'Basic ${base64Encode(utf8.encode(AK.basicAuthCredentials))}',
      },
    );

    if (response.body.isNotEmpty) {
      var jsonData = jsonDecode(response.body);
      if (response.statusCode == 200) {
        if (jsonData['status'] == 'success') {
          Get.back();
          // Get.snackbar(
          //   jsonData['status'],
          //   jsonData['message'],
          // );

          return response.body;
        }
      }
      return (jsonData['status']);
    }
  }

  Future<void> sendVerificationRequest(String phoneNumber) async {
    final accountSid = AK.accountSIDTwillo;
    final authToken = AK.authTokenTwillo;
    final verifySid = AK.twilloRecoveryCode;

    final Uri verificationUri = Uri.parse(
        'https://verify.twilio.com/v2/Services/$verifySid/Verifications');

    // Send the verification request
    final response = await http.post(
      verificationUri,
      headers: {
        'Authorization':
            'Basic ' + base64Encode(utf8.encode('$accountSid:$authToken')),
        'Content-Type': 'application/x-www-form-urlencoded',
      },
      body: {
        'To': phoneNumber,
        'Channel': 'sms',
      },
    );

    if (response.statusCode == 201) {
    } else {}

    // Prompt the user to enter the OTP
    final otpCode = "123456"; // Replace with user input

    // Check the verification code
    final checkUri = Uri.parse(
        'https://verify.twilio.com/v2/Services/$verifySid/VerificationCheck');

    final checkResponse = await http.post(
      checkUri,
      headers: {
        'Authorization':
            'Basic ' + base64Encode(utf8.encode('$accountSid:$authToken')),
        'Content-Type': 'application/x-www-form-urlencoded',
      },
      body: {
        'To': phoneNumber,
        'Code': otpCode,
      },
    );

    if (checkResponse.statusCode == 201) {
    } else {}
  }

  Future<dynamic> getGoogleApi({
    required String link,
    Map<String, dynamic>? payload,
  }) async {
    var url = Uri.parse(
      link,
    );
    var response = await http.post(
      url,
      body: payload,
    );
    // Log.print('req: ${response.request}');
    // Log.print('response: ${response.body}');
    // Log.print('payload: ${payload}');
    var jsonData = jsonDecode(response.body);
    if (jsonData['status'] == 'OK') {
      return jsonData;
    }
    return (jsonData['status']);
  }

  Future<dynamic> getHereMap({
    required String link,
  }) async {
    var url = Uri.parse(link);
    try {
      var response = await http.get(url);

      if (response.statusCode == 200) {
        // Ensure the response body is decoded as UTF-8
        var decodedBody = utf8.decode(response.bodyBytes);
        var data = jsonDecode(decodedBody);
        return data;
      } else {
        return null;
      }
    } catch (e) {
      return null;
    }
  }

  // Future<dynamic> update({
  //   required String endpoint,
  //   required Map<String, dynamic> data,
  //   required String id,
  // }) async {
  //   // String? basicAuthCredentials =
  //   //     await storage.read(key: BoxName.basicAuthCredentials);
  //   var url = Uri.parse('$endpoint/$id');
  //   var response = await http.put(
  //     url,
  //     body: json.encode(data),
  //     headers: {
  //       'Authorization':
  //           'Basic ${base64Encode(utf8.encode(AK.basicAuthCredentials))}',
  //     },
  //   );
  //   return json.decode(response.body);
  // }

  Future<dynamic> delete({
    required String endpoint,
    required String id,
  }) async {
    // String? basicAuthCredentials =
    //     await storage.read(key: BoxName.basicAuthCredentials);
    var url = Uri.parse('$endpoint/$id');
    var response = await http.delete(
      url,
      headers: {
        'Authorization':
            'Basic ${base64Encode(utf8.encode(AK.basicAuthCredentials))}',
      },
    );
    return json.decode(response.body);
  }
}