// The main function that kicks off the execution of the Flutter application.
Future<void> main() async {
  // Ensure that the Flutter app's widgets are initialized properly before running the app.
  WidgetsFlutterBinding.ensureInitialized();

  // Load environment variables from a .env file.
  await dotenv.load();

  // Set the Stripe publishable key from the loaded environment variables.
  Stripe.publishableKey = dotenv.env[Keys.stripePublicKey]!;

  // Set the Stripe merchant identifier for the app.
  Stripe.merchantIdentifier = 'merchant.flutter.stripe.appTitle';

  // Set the URL scheme for handling deep links related to Stripe payments.
  Stripe.urlScheme = 'flutterstripe';

  // Apply settings for the Stripe SDK.
  await Stripe.instance.applySettings();

  // Run the Flutter app with the provided App widget.
  runApp(App());
}

// A function to create a customer in the Stripe payment system using the provided email.
Future<void> createCustomer({
    required String email,
  }) async {
    try {
      // Prepare the request body with the customer’s email.
      final body = <String, dynamic>{
        ‘email’: email,
      };

      // Make a POST request to the Stripe API to create a customer.
      final response = await http.post(
        Uri.parse(‘https://api.stripe.com/v1/customers’), // Stripe API endpoint for creating customers.
        headers: {
          ‘Authorization’: ‘Bearer ${dotenv.env[Keys.stripeSecretKey]}’, // Set the API key for authentication.
          ‘Content-Type’: ‘application/x-www-form-urlencoded’ // Set the request body content type.
        },
        body: body, // Include the request body in the POST request.
      );

      // Parse the response JSON and store the created customer data in ‘stripeCustomer’ variable.
      // 'stripeCustomer' is declared earlier.
      stripeCustomer = StripeCustomer.fromJson(
        json: json.decode(response.body),
      );
    } catch (err) {
      // If an error occurs during the process, throw an exception with the error message.
      throw Exception(err.toString());
    }
  }

/// Represents a customer entity in the Stripe payment system.
class StripeCustomer {
  /// Unique identifier for the customer.
  final String id;

  /// Customer's balance, represented in cents.
  final int balance;

  /// Date and time when the customer was created.
  final DateTime created;

  /// Email address associated with the customer.
  final String email;

  /// Constructor to create a [StripeCustomer] object.
  StripeCustomer({
    required this.id,
    required this.balance,
    required this.created,
    required this.email,
  });

  /// Factory method to create a [StripeCustomer] object from JSON data.
  ///
  /// [json] - A Map containing the customer information in JSON format.
  /// Throws an exception if the required fields are missing or invalid in the [json].
  factory StripeCustomer.fromJson({
    required Map<String, dynamic> json,
  }) =>
      StripeCustomer(
        id: json['id'].toString(),                                             
        balance: json['balance'].toString().toInt ~/ 100,                     
        created: DateTime.fromMicrosecondsSinceEpoch(int.parse(json['created'].toString())),
        email: json['email'].toString(),
      );
}

/// Creates a payment intent.
  Future<Map<String, dynamic>> createPaymentIntent({
    required String amount,
  }) async {
    try {
      // Request body
      final body = <String, dynamic>{
        // The amount should be in cents
        'amount': (int.parse(amount) * 100).toString(),
        'currency': 'THB',

        // The Customer ID, which balance will be toped-up
        'customer': stripeCustomer!.id,
        'receipt_email': stripeCustomer!.email,
      };

      // Make post request to Stripe
      final response = await http.post(
        Uri.parse('https://api.stripe.com/v1/payment_intents'),
        headers: {
          'Authorization': 'Bearer ${dotenv.env[Keys.stripeSecretKey]}',
          'Content-Type': 'application/x-www-form-urlencoded'
        },
        body: body,
      );

      // Return the Map object
      return json.decode(response.body);
    } catch (err) {
      throw Exception(err.toString());
    }
  }

Future<void> initStripePayment({
  required int amount,
}) async {
  // Create a payment intent, the method described above
  final paymentIntent = await createPaymentIntent(
    amount: (amount).toString(),
  );

  try {
    // Initialize Stripe payment sheet
    await Stripe.instance.initPaymentSheet(
      paymentSheetParameters: SetupPaymentSheetParameters(
        customerId: stripeCustomer!.id,
        paymentIntentClientSecret: paymentIntent['client_secret'], // Gotten from payment intent
        merchantDisplayName: 'MyCoolApp',
      ),
    );

  } on Exception catch (e) {
    log('initStripePayment() exception in PaymentStore: $e');
    topUpError = e.toString();
    paymentSheetInitialized = false;
  }
}

await Stripe.instance.presentPaymentSheet();

Future<void> topUpBalance({
    required int amount,
  }) async {
    try {
      //Request body
      final body = <String, dynamic>{
        'amount': (amount * 100).toInt().toString(),
        'currency': 'thb',
      };

      //Make post request to Stripe
      final response = await http.post(
        Uri.parse(
          'https://api.stripe.com/v1/customers/${stripeCustomer?.id}/balance_transactions',
        ),
        headers: {
          'Authorization': 'Bearer ${dotenv.env[Keys.stripeSecretKey]}',
          'Content-Type': 'application/x-www-form-urlencoded'
        },
        body: body,
      );

    } catch (err) {
      log('topUpBalance() exception in PaymentStore: $err');
      throw Exception(err.toString());
    }
  }

Future<void> withdrawCustomerBalance({
    required int amount,
  }) async {
    try {
      // Request body
      final body = <String, dynamic>{
        // Before this operation, we hae to be sure
        // that the `amount` is less or equal to `stripeCustomer!.balance`
        'balance': ((stripeCustomer!.balance - amount) * 100).toInt().toString(),
      };

      // Make post request to Stripe
      final response = await http.post(
        Uri.parse(
          'https://api.stripe.com/v1/customers/${stripeCustomer?.id}',
        ),
        headers: {
          'Authorization': 'Bearer ${dotenv.env[Keys.stripeSecretKey]}',
          'Content-Type': 'application/x-www-form-urlencoded'
        },
        body: body,
      );

      if (response.statusCode == 402) {
        withdrawError = json.decode(response.body)['error']['decline_code'].toString();
      }

      // Refresh the Stripe customer data
      await getStripeCustomer(
        email: stripeCustomer!.email,
      );
    } catch (err) {
      log('withdrawCustomerBalance() exception in PaymentStore: $err');
      throw Exception(err.toString());
    }
  }