stripe_native_card_field/lib/stripe_native_card_field.dart

library stripe_native_card_field;

import 'dart:async';
import 'dart:convert';
import 'dart:io';

import 'package:flutter/foundation.dart';
import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
import 'package:http/http.dart' as http;
import 'package:stripe_native_card_field/card_text_field_error.dart';

import 'card_details.dart';
import 'card_provider_icon.dart';

/// Enum to track each step of the card detail
/// entry process.
enum CardEntryStep { number, exp, cvc, postal }

enum LoadingLocation { above, below }

/// A uniform text field for entering card details, based
/// on the behavior of Stripe's various html elements.
///
/// Required `width`.
///
/// To get the card data or stripe token, provide callbacks
/// for either `onValidCardDetails`, which will return a
/// `CardDetails` object, or `onStripeResponse`, which will
/// return a Map<String, dynamic> response from the Stripe Api.
///
/// If stripe integration is desired, you must provide both
/// `stripePublishableKey` and `onStripeResponse`, otherwise
/// `CardTextField` will `assert(false)` in debug mode or
/// throw a `CardTextFieldError` in profile or release mode
///
/// If the provided `width < 450.0`, the `CardTextField`
/// will scroll its content horizontally with the cursor
/// to compensate.
class CardTextField extends StatefulWidget {
  CardTextField({
    Key? key,
    required this.width,
    this.onStripeResponse,
    this.onCallToStripe,
    this.onValidCardDetails,
    this.onSubmitted,
    this.stripePublishableKey,
    this.height,
    this.textStyle,
    this.hintTextStyle,
    this.errorTextStyle,
    this.cursorColor,
    this.boxDecoration,
    this.errorBoxDecoration,
    this.loadingWidget,
    this.loadingWidgetLocation = LoadingLocation.below,
    this.autoFetchStripektoken = true,
    this.showInternalLoadingWidget = true,
    this.delayToShowLoading = const Duration(milliseconds: 0),
    this.overrideValidState,
    this.errorText,
    this.cardFieldWidth,
    this.expFieldWidth,
    this.securityFieldWidth,
    this.postalFieldWidth,
    this.iconSize,
    this.cardIconColor,
    this.cardIconErrorColor,
  }) : super(key: key) {
    // Setup logic for the CardTextField
    // Will assert in debug mode, otherwise will throw `CardTextFieldError` in profile or release
    if (stripePublishableKey != null) {
      if (!stripePublishableKey!.startsWith('pk_')) {
        const msg = 'Invalid stripe key, doesn\'t start with "pk_"';
        if (kDebugMode) assert(false, msg);
        if (kReleaseMode || kProfileMode) {
          throw CardTextFieldError(CardTextFieldErrorType.stripeImplementation,
              details: msg);
        }
      }
    }
  }

  /// Width of the entire CardTextField
  final double width;

  /// Height of the entire CardTextField, defaults to 60.0
  final double? height;

  /// Width of card number field, only override if changing the default `textStyle.fontSize`, defaults to 180.0
  final double? cardFieldWidth;

  /// Width of expiration date field, only override if changing the default `textStyle.fontSize`, defaults to 70.0
  final double? expFieldWidth;

  /// Width of security number field, only override if changing the default `textStyle.fontSize`, defaults to 40.0
  final double? securityFieldWidth;

  /// Width of postal code field, only override if changing the default `textStyle.fontSize`, defaults to 95.0
  final double? postalFieldWidth;

  /// Overrides the default box decoration of the text field
  final BoxDecoration? boxDecoration;

  /// Overrides the default box decoration of the text field when there is a validation error
  final BoxDecoration? errorBoxDecoration;

  /// Shown and overrides `LinearProgressIndicator` if the request to stripe takes longer than `delayToShowLoading`
  /// Recommended to only override with a `LinearProgressIndicator` or similar widget, or spacing will be messed up
  final Widget? loadingWidget;

  /// Overrides default icon size of the card provider, defaults to `Size(30.0, 20.0)`
  final Size? iconSize;

  /// CSS string name of color or hex code for the card SVG icon to render
  final String? cardIconColor;

  /// CSS string name of color or hex code for the error card SVG icon to render
  final String? cardIconErrorColor;

  /// Determines where the loading indicator appears when contacting stripe
  final LoadingLocation loadingWidgetLocation;

  /// Default TextStyle
  final TextStyle? textStyle;

  /// Default TextStyle for the hint text in each TextFormField.
  /// If null, inherits from the `textStyle`.
  final TextStyle? hintTextStyle;

  /// TextStyle used when any TextFormField's have a validation error
  /// If null, inherits from the `textStyle`.
  final TextStyle? errorTextStyle;

  /// Color used for the cursor, if null, inherits the primary color of the Theme
  final Color? cursorColor;

  /// Time to wait until showing the loading indicator when retrieving Stripe token, defaults to 0 milliseconds.
  final Duration delayToShowLoading;

  /// Whether to show the internal loading widget on calls to Stripe
  final bool showInternalLoadingWidget;

  /// Whether to automatically call `getStripeResponse` when the `_cardDetails` are valid.
  final bool autoFetchStripektoken;

  /// Stripe publishable key, starts with 'pk_'
  final String? stripePublishableKey;

  /// Callback when the http request is made to Stripe
  final void Function()? onCallToStripe;

  /// Callback that returns the stripe token for the card
  final void Function(Map<String, dynamic>?)? onStripeResponse;

  /// Callback that returns the completed CardDetails object
  final void Function(CardDetails)? onValidCardDetails;

  /// Callback when the user hits enter or done in the postal code field
  /// Optionally returns the `CardDetails` object if it is valid
  final void Function(CardDetails?)? onSubmitted;

  /// Can manually override the ValidState to surface errors returned from Stripe
  final CardDetailsValidState? overrideValidState;

  /// Can manually override the errorText displayed to surface errors returned from Stripe
  final String? errorText;

  /// GlobalKey used for calling `getStripeToken` in the `CardTextFieldState`
  // final GlobalKey<CardTextFieldState> _key = GlobalKey<CardTextFieldState>();

  // CardTextFieldState? get state => _key.currentState;

  @override
  State<CardTextField> createState() => CardTextFieldState();
}

/// State Widget for CardTextField
/// Should not be used directly, except to
/// create a GlobalKey for directly accessing
/// the `getStripeResponse` function
class CardTextFieldState extends State<CardTextField> {
  late final TextEditingController _cardNumberController;
  late final TextEditingController _expirationController;
  late final TextEditingController _securityCodeController;
  late final TextEditingController _postalCodeController;
  final List<TextEditingController> _controllers = [];

  // Not made private for access in widget tests
  late final FocusNode cardNumberFocusNode;
  late final FocusNode expirationFocusNode;
  late final FocusNode securityCodeFocusNode;
  late final FocusNode postalCodeFocusNode;

  // Not made private for access in widget tests
  late bool isWideFormat;

  // Widget configurable styles
  late BoxDecoration _normalBoxDecoration;
  late BoxDecoration _errorBoxDecoration;
  late TextStyle _errorTextStyle;
  late TextStyle _normalTextStyle;
  late TextStyle _hintTextSyle;
  late Color _cursorColor;

  /// Width of the card number text field
  late double _cardFieldWidth;

  /// Width of the expiration text field
  late double _expirationFieldWidth;

  /// Width of the security code text field
  late double _securityFieldWidth;

  /// Width of the postal code text field
  late double _postalFieldWidth;

  /// Width of the internal scrollable field, is potentially larger than the provided `widget.width`
  late double _internalFieldWidth;

  /// Width of the gap between card number and expiration text fields when expanded
  late double _expanderWidthExpanded;

  /// Width of the gap between card number and expiration text fields when collapsed
  late double _expanderWidthCollapsed;

  String? _validationErrorText;
  bool _showBorderError = false;
  late bool _isMobile;

  /// If a request to Stripe is being made
  bool _loading = false;
  final CardDetails _cardDetails = CardDetails.blank();
  int _prevErrorOverrideHash = 0;

  final _currentCardEntryStepController = StreamController<CardEntryStep>();
  final _horizontalScrollController = ScrollController();
  CardEntryStep _currentStep = CardEntryStep.number;

  final _formFieldKey = GlobalKey<FormState>();

  @override
  void initState() {
    _calculateProperties();

    // No way to get backspace events on soft keyboards, so add invisible character to detect delete
    _cardNumberController = TextEditingController();
    _expirationController =
        TextEditingController(text: _isMobile ? '\u200b' : '');
    _securityCodeController =
        TextEditingController(text: _isMobile ? '\u200b' : '');
    _postalCodeController =
        TextEditingController(text: _isMobile ? '\u200b' : '');

    _controllers.addAll([
      _cardNumberController,
      _expirationController,
      _securityCodeController,
      _postalCodeController,
    ]);

    cardNumberFocusNode = FocusNode();
    expirationFocusNode = FocusNode();
    securityCodeFocusNode = FocusNode();
    postalCodeFocusNode = FocusNode();

    // Add backspace transition listener for non mobile clients
    if (!_isMobile) {
      RawKeyboard.instance.addListener(_backspaceTransitionListener);
    }

    // Add listener to change focus and whatnot between fields
    _currentCardEntryStepController.stream.listen(
      _onStepChange,
    );

    // Add listeners to know when card details are completed
    _cardDetails.onCompleteController.stream.listen((card) async {
      if (widget.stripePublishableKey != null &&
          widget.onStripeResponse != null &&
          widget.autoFetchStripektoken) {
        final res = await getStripeResponse();
        widget.onStripeResponse!(res);
      }
      if (widget.onValidCardDetails != null) widget.onValidCardDetails!(card);
    });

    super.initState();
  }

  @override
  void dispose() {
    _cardNumberController.dispose();
    _expirationController.dispose();
    _securityCodeController.dispose();
    _postalCodeController.dispose();

    cardNumberFocusNode.dispose();
    expirationFocusNode.dispose();
    securityCodeFocusNode.dispose();
    postalCodeFocusNode.dispose();

    if (!_isMobile) {
      RawKeyboard.instance.removeListener(_backspaceTransitionListener);
    }

    super.dispose();
  }

  @override
  Widget build(BuildContext context) {
    _calculateProperties();
    _initStyles();
    _checkErrorOverride();

    return Column(
      mainAxisAlignment: MainAxisAlignment.center,
      crossAxisAlignment: CrossAxisAlignment.start,
      children: [
        Form(
          key: _formFieldKey,
          child: GestureDetector(
            onTap: () {
              // Focuses to the current field
              _currentCardEntryStepController.add(_currentStep);
            },
            // Enable scrolling on mobile and if its narrow (not all fields visible)
            onHorizontalDragUpdate: (details) {
              const minOffset = 0.0;
              final maxOffset =
                  _horizontalScrollController.position.maxScrollExtent;
              if (!_isMobile || isWideFormat) return;
              final newOffset =
                  _horizontalScrollController.offset - details.delta.dx;

              if (newOffset < minOffset) {
                _horizontalScrollController.jumpTo(minOffset);
              } else if (newOffset > maxOffset) {
                _horizontalScrollController.jumpTo(maxOffset);
              } else {
                _horizontalScrollController.jumpTo(newOffset);
              }
            },
            onHorizontalDragEnd: (details) {
              if (!_isMobile ||
                  isWideFormat ||
                  details.primaryVelocity == null) {
                return;
              }

              const dur = Duration(milliseconds: 300);
              const cur = Curves.ease;

              // final max = _horizontalScrollController.position.maxScrollExtent;
              final newOffset = _horizontalScrollController.offset -
                  details.primaryVelocity! * 0.15;
              _horizontalScrollController.animateTo(newOffset,
                  curve: cur, duration: dur);
            },
            child: Container(
              width: widget.width,
              height: widget.height ?? 60.0,
              decoration:
                  _showBorderError ? _errorBoxDecoration : _normalBoxDecoration,
              child: ClipRect(
                child: IgnorePointer(
                  child: SingleChildScrollView(
                    controller: _horizontalScrollController,
                    scrollDirection: Axis.horizontal,
                    child: SizedBox(
                      width: _internalFieldWidth,
                      height: widget.height ?? 60.0,
                      child: Column(
                        children: [
                          if (widget.loadingWidgetLocation ==
                              LoadingLocation.above)
                            AnimatedOpacity(
                              duration: const Duration(milliseconds: 300),
                              opacity:
                                  _loading && widget.showInternalLoadingWidget
                                      ? 1.0
                                      : 0.0,
                              child: widget.loadingWidget ??
                                  const LinearProgressIndicator(),
                            ),
                          Padding(
                            padding: switch (widget.loadingWidgetLocation) {
                              LoadingLocation.above =>
                                const EdgeInsets.only(top: 0, bottom: 4.0),
                              LoadingLocation.below =>
                                const EdgeInsets.only(top: 4.0, bottom: 0),
                            },
                            child: Row(
                              crossAxisAlignment: CrossAxisAlignment.center,
                              mainAxisAlignment: MainAxisAlignment.start,
                              children: [
                                Padding(
                                  padding: const EdgeInsets.symmetric(
                                      horizontal: 6.0),
                                  child: CardProviderIcon(
                                    cardDetails: _cardDetails,
                                    size: widget.iconSize,
                                    defaultCardColor: widget.cardIconColor,
                                    errorCardColor: widget.cardIconErrorColor,
                                  ),
                                ),
                                SizedBox(
                                  width: _cardFieldWidth,
                                  child: TextFormField(
                                    key: const Key('card_field'),
                                    focusNode: cardNumberFocusNode,
                                    controller: _cardNumberController,
                                    keyboardType: TextInputType.number,
                                    style: _isRedText([
                                      CardDetailsValidState.invalidCard,
                                      CardDetailsValidState.missingCard,
                                      CardDetailsValidState.blank
                                    ])
                                        ? _errorTextStyle
                                        : _normalTextStyle,
                                    validator: (content) {
                                      if (content == null || content.isEmpty) {
                                        return null;
                                      }
                                      // setState(() => _cardDetails.cardNumber = content);

                                      if (_cardDetails.validState ==
                                          CardDetailsValidState.invalidCard) {
                                        _setValidationState(
                                            'Your card number is invalid.');
                                      } else if (_cardDetails.validState ==
                                          CardDetailsValidState.missingCard) {
                                        _setValidationState(
                                            'Your card number is incomplete.');
                                      }
                                      return null;
                                    },
                                    onChanged: (str) {
                                      _onTextFieldChanged(
                                          str, CardEntryStep.number);
                                      final numbers = str.replaceAll(' ', '');
                                      if (str.length <=
                                          _cardDetails.maxINNLength) {
                                        _cardDetails.detectCardProvider();
                                      }
                                      if (numbers.length == 16) {
                                        _currentCardEntryStepController
                                            .add(CardEntryStep.exp);
                                      }
                                    },
                                    onFieldSubmitted: (_) =>
                                        _currentCardEntryStepController
                                            .add(CardEntryStep.exp),
                                    inputFormatters: [
                                      LengthLimitingTextInputFormatter(19),
                                      FilteringTextInputFormatter.allow(
                                          RegExp('[0-9 ]')),
                                      CardNumberInputFormatter(),
                                    ],
                                    cursorColor: _cursorColor,
                                    decoration: InputDecoration(
                                      hintText: 'Card number',
                                      contentPadding: EdgeInsets.zero,
                                      hintStyle: _hintTextSyle,
                                      fillColor: Colors.transparent,
                                      border: InputBorder.none,
                                    ),
                                  ),
                                ),
                                if (isWideFormat)
                                  Flexible(
                                    fit: FlexFit.loose,
                                    // fit: _currentStep == CardEntryStep.number ? FlexFit.loose : FlexFit.tight,
                                    child: AnimatedContainer(
                                      curve: Curves.easeInOut,
                                      duration:
                                          const Duration(milliseconds: 400),
                                      constraints: _currentStep ==
                                              CardEntryStep.number
                                          ? BoxConstraints.loose(
                                              Size(_expanderWidthExpanded, 0.0),
                                            )
                                          : BoxConstraints.tight(
                                              Size(
                                                  _expanderWidthCollapsed, 0.0),
                                            ),
                                    ),
                                  ),

                                // Spacer(flex: _currentStep == CardEntryStep.number ? 100 : 1),
                                SizedBox(
                                  width: _expirationFieldWidth,
                                  child: Stack(
                                    alignment: Alignment.centerLeft,
                                    children: [
                                      // Must manually add hint label because they wont show on mobile with backspace hack
                                      if (_isMobile &&
                                          _expirationController.text ==
                                              '\u200b')
                                        Text('MM/YY', style: _hintTextSyle),
                                      TextFormField(
                                        key: const Key('expiration_field'),
                                        focusNode: expirationFocusNode,
                                        controller: _expirationController,
                                        keyboardType: TextInputType.number,
                                        style: _isRedText([
                                          CardDetailsValidState.dateTooLate,
                                          CardDetailsValidState.dateTooEarly,
                                          CardDetailsValidState.missingDate,
                                          CardDetailsValidState.invalidMonth
                                        ])
                                            ? _errorTextStyle
                                            : _normalTextStyle,
                                        validator: (content) {
                                          if (content == null ||
                                              content.isEmpty ||
                                              _isMobile &&
                                                  content == '\u200b') {
                                            return null;
                                          }

                                          // if (_isMobile) {
                                          //   setState(
                                          //       () => _cardDetails.expirationString = content.replaceAll('\u200b', ''));
                                          // } else {
                                          //   setState(() => _cardDetails.expirationString = content);
                                          // }

                                          if (_cardDetails.validState ==
                                              CardDetailsValidState
                                                  .dateTooEarly) {
                                            _setValidationState(
                                                'Your card\'s expiration date is in the past.');
                                          } else if (_cardDetails.validState ==
                                              CardDetailsValidState
                                                  .dateTooLate) {
                                            _setValidationState(
                                                'Your card\'s expiration year is invalid.');
                                          } else if (_cardDetails.validState ==
                                              CardDetailsValidState
                                                  .missingDate) {
                                            _setValidationState(
                                                'You must include your card\'s expiration date.');
                                          } else if (_cardDetails.validState ==
                                              CardDetailsValidState
                                                  .invalidMonth) {
                                            _setValidationState(
                                                'Your card\'s expiration month is invalid.');
                                          }
                                          return null;
                                        },
                                        onChanged: (str) {
                                          _onTextFieldChanged(
                                              str, CardEntryStep.exp);
                                          if (str.length == 5) {
                                            _currentCardEntryStepController
                                                .add(CardEntryStep.cvc);
                                          }
                                        },
                                        onFieldSubmitted: (_) =>
                                            _currentCardEntryStepController
                                                .add(CardEntryStep.cvc),
                                        inputFormatters: [
                                          LengthLimitingTextInputFormatter(5),
                                          FilteringTextInputFormatter.allow(
                                              RegExp('[0-9/]')),
                                          CardExpirationFormatter(),
                                        ],
                                        cursorColor: _cursorColor,
                                        decoration: InputDecoration(
                                          contentPadding: EdgeInsets.zero,
                                          hintText: _isMobile ? '' : 'MM/YY',
                                          hintStyle: _hintTextSyle,
                                          fillColor: Colors.transparent,
                                          border: InputBorder.none,
                                        ),
                                      ),
                                    ],
                                  ),
                                ),
                                SizedBox(
                                  width: _securityFieldWidth,
                                  child: Stack(
                                    alignment: Alignment.centerLeft,
                                    children: [
                                      if (_isMobile &&
                                          _securityCodeController.text ==
                                              '\u200b')
                                        Text(
                                          'CVC',
                                          style: _hintTextSyle,
                                        ),
                                      TextFormField(
                                        key: const Key('security_field'),
                                        focusNode: securityCodeFocusNode,
                                        controller: _securityCodeController,
                                        keyboardType: TextInputType.number,
                                        style: _isRedText([
                                          CardDetailsValidState.invalidCVC,
                                          CardDetailsValidState.missingCVC
                                        ])
                                            ? _errorTextStyle
                                            : _normalTextStyle,
                                        validator: (content) {
                                          if (content == null ||
                                              content.isEmpty ||
                                              _isMobile &&
                                                  content == '\u200b') {
                                            return null;
                                          }

                                          // if (_isMobile) {
                                          //   setState(
                                          //       () => _cardDetails.securityCode = content.replaceAll('\u200b', ''));
                                          // } else {
                                          //   setState(() => _cardDetails.securityCode = content);
                                          // }

                                          if (_cardDetails.validState ==
                                              CardDetailsValidState
                                                  .invalidCVC) {
                                            _setValidationState(
                                                'Your card\'s security code is invalid.');
                                          } else if (_cardDetails.validState ==
                                              CardDetailsValidState
                                                  .missingCVC) {
                                            _setValidationState(
                                                'Your card\'s security code is incomplete.');
                                          }
                                          return null;
                                        },
                                        onFieldSubmitted: (_) =>
                                            _currentCardEntryStepController
                                                .add(CardEntryStep.postal),
                                        onChanged: (str) {
                                          _onTextFieldChanged(
                                              str, CardEntryStep.cvc);

                                          if (str.length ==
                                              _cardDetails
                                                  .provider?.cvcLength) {
                                            _currentCardEntryStepController
                                                .add(CardEntryStep.postal);
                                          }
                                        },
                                        inputFormatters: [
                                          LengthLimitingTextInputFormatter(
                                              _cardDetails.provider == null
                                                  ? 4
                                                  : _cardDetails
                                                      .provider!.cvcLength),
                                          FilteringTextInputFormatter.allow(
                                              RegExp('[0-9]')),
                                        ],
                                        cursorColor: _cursorColor,
                                        decoration: InputDecoration(
                                          contentPadding: EdgeInsets.zero,
                                          hintText: _isMobile ? '' : 'CVC',
                                          hintStyle: _hintTextSyle,
                                          fillColor: Colors.transparent,
                                          border: InputBorder.none,
                                        ),
                                      ),
                                    ],
                                  ),
                                ),
                                SizedBox(
                                  width: _postalFieldWidth,
                                  child: Stack(
                                    alignment: Alignment.centerLeft,
                                    children: [
                                      if (_isMobile &&
                                          _postalCodeController.text ==
                                              '\u200b')
                                        Text(
                                          'Postal Code',
                                          style: _hintTextSyle,
                                        ),
                                      TextFormField(
                                        key: const Key('postal_field'),
                                        focusNode: postalCodeFocusNode,
                                        controller: _postalCodeController,
                                        keyboardType: TextInputType.number,
                                        style: _isRedText([
                                          CardDetailsValidState.invalidZip,
                                          CardDetailsValidState.missingZip
                                        ])
                                            ? _errorTextStyle
                                            : _normalTextStyle,
                                        validator: (content) {
                                          if (content == null ||
                                              content.isEmpty ||
                                              _isMobile &&
                                                  content == '\u200b') {
                                            return null;
                                          }

                                          // if (_isMobile) {
                                          //   setState(() => _cardDetails.postalCode = content.replaceAll('\u200b', ''));
                                          // } else {
                                          //   setState(() => _cardDetails.postalCode = content);
                                          // }

                                          if (_cardDetails.validState ==
                                              CardDetailsValidState
                                                  .invalidZip) {
                                            _setValidationState(
                                                'The postal code you entered is not correct.');
                                          } else if (_cardDetails.validState ==
                                              CardDetailsValidState
                                                  .missingZip) {
                                            _setValidationState(
                                                'You must enter your card\'s postal code.');
                                          }
                                          return null;
                                        },
                                        onChanged: (str) {
                                          _onTextFieldChanged(
                                              str, CardEntryStep.postal);
                                        },
                                        textInputAction: TextInputAction.done,
                                        onFieldSubmitted: (_) {
                                          _postalFieldSubmitted();
                                        },
                                        cursorColor: _cursorColor,
                                        decoration: InputDecoration(
                                          contentPadding: EdgeInsets.zero,
                                          hintText:
                                              _isMobile ? '' : 'Postal Code',
                                          hintStyle: _hintTextSyle,
                                          fillColor: Colors.transparent,
                                          border: InputBorder.none,
                                        ),
                                      ),
                                    ],
                                  ),
                                ),
                              ],
                            ),
                          ),
                          if (widget.loadingWidgetLocation ==
                              LoadingLocation.below)
                            AnimatedOpacity(
                              duration: const Duration(milliseconds: 300),
                              opacity:
                                  _loading && widget.showInternalLoadingWidget
                                      ? 1.0
                                      : 0.0,
                              child: widget.loadingWidget ??
                                  const LinearProgressIndicator(),
                            ),
                        ],
                      ),
                    ),
                  ),
                ),
              ),
            ),
          ),
        ),
        AnimatedOpacity(
          duration: const Duration(milliseconds: 525),
          opacity: _validationErrorText == null ? 0.0 : 1.0,
          child: Padding(
            padding: const EdgeInsets.only(top: 8.0, left: 14.0),
            child: Text(
              // Spacing changes by like a pixel if its an empty string, slight jitter when error appears and disappears
              _validationErrorText ?? ' ',
              style: _errorTextStyle,
            ),
          ),
        ),
      ],
    );
  }

  void _onTextFieldChanged(String str, CardEntryStep step) {
    String cleanedStr;
    if (_isMobile) {
      cleanedStr = str.replaceAll('\u200b', '');
    } else {
      cleanedStr = str;
    }

    switch (step) {
      case CardEntryStep.number:
        setState(
            () => _cardDetails.cardNumber = cleanedStr.replaceAll(' ', ''));
        break;
      case CardEntryStep.exp:
        setState(() => _cardDetails.expirationString = cleanedStr);
        break;
      case CardEntryStep.cvc:
        setState(() => _cardDetails.securityCode = cleanedStr);
        break;
      case CardEntryStep.postal:
        setState(() => _cardDetails.postalCode = cleanedStr);
        break;
    }

    if (_isMobile && str.isEmpty) {
      _mobileBackspaceDetected();
    }

    // Check if card is complete and broadcast
    _cardDetails.broadcastStatus();
  }

  /// Called in `initState()` as well as `build()`, determines form factor and target device
  void _calculateProperties() {
    // TODO skip if not needing to recalc
    _cardFieldWidth = widget.cardFieldWidth ?? 180.0;
    _expirationFieldWidth = widget.expFieldWidth ?? 70.0;
    _securityFieldWidth = widget.securityFieldWidth ?? 40.0;
    _postalFieldWidth = widget.postalFieldWidth ?? 95.0;
    isWideFormat = widget.width >=
        _cardFieldWidth +
            _expirationFieldWidth +
            _securityFieldWidth +
            _postalFieldWidth +
            60.0;
    if (isWideFormat) {
      _internalFieldWidth = widget.width + _postalFieldWidth + 35;
      _expanderWidthExpanded = widget.width -
          _cardFieldWidth -
          _expirationFieldWidth -
          _securityFieldWidth -
          35;
      _expanderWidthCollapsed = widget.width -
          _cardFieldWidth -
          _expirationFieldWidth -
          _securityFieldWidth -
          _postalFieldWidth -
          70;
    } else {
      _internalFieldWidth = _cardFieldWidth +
          _expirationFieldWidth +
          _securityFieldWidth +
          _postalFieldWidth +
          80;
    }

    _isMobile = kIsWeb ? !isWideFormat : Platform.isAndroid || Platform.isIOS;

    // int index = 0;
    // for (final controller in _controllers) {
    //   if (controller.text.isNotEmpty || index == 0) continue;
    //   controller.text = '\u200b';
    //   index += 1;
    // }
  }

  /// Called every `build()` invocation, combines passed in styles with the defaults
  void _initStyles() {
    _errorTextStyle =
        const TextStyle(color: Colors.red, fontSize: 14, inherit: true)
            .merge(widget.errorTextStyle ?? widget.textStyle);
    _normalTextStyle =
        const TextStyle(color: Colors.black87, fontSize: 14, inherit: true)
            .merge(widget.textStyle);
    _hintTextSyle =
        const TextStyle(color: Colors.black54, fontSize: 14, inherit: true)
            .merge(widget.hintTextStyle ?? widget.textStyle);

    _normalBoxDecoration = BoxDecoration(
      color: const Color(0xfff6f9fc),
      border: Border.all(
        color: const Color(0xffdde0e3),
        width: 2.0,
      ),
      borderRadius: BorderRadius.circular(8.0),
    ).copyWith(
      backgroundBlendMode: widget.boxDecoration?.backgroundBlendMode,
      border: widget.boxDecoration?.border,
      borderRadius: widget.boxDecoration?.borderRadius,
      boxShadow: widget.boxDecoration?.boxShadow,
      color: widget.boxDecoration?.color,
      gradient: widget.boxDecoration?.gradient,
      image: widget.boxDecoration?.image,
      shape: widget.boxDecoration?.shape,
    );

    _errorBoxDecoration = BoxDecoration(
      color: const Color(0xfff6f9fc),
      border: Border.all(
        color: Colors.red,
        width: 2.0,
      ),
      borderRadius: BorderRadius.circular(8.0),
    ).copyWith(
      backgroundBlendMode: widget.errorBoxDecoration?.backgroundBlendMode,
      border: widget.errorBoxDecoration?.border,
      borderRadius: widget.errorBoxDecoration?.borderRadius,
      boxShadow: widget.errorBoxDecoration?.boxShadow,
      color: widget.errorBoxDecoration?.color,
      gradient: widget.errorBoxDecoration?.gradient,
      image: widget.errorBoxDecoration?.image,
      shape: widget.errorBoxDecoration?.shape,
    );
    _cursorColor = widget.cursorColor ?? Theme.of(context).primaryColor;
  }

  void _checkErrorOverride() {
    if ((widget.errorText != null || widget.overrideValidState != null) &&
        Object.hashAll([widget.errorText, widget.overrideValidState]) !=
            _prevErrorOverrideHash) {
      _prevErrorOverrideHash =
          Object.hashAll([widget.errorText, widget.overrideValidState]);
      _validateFields();
    }
  }

  // Makes an http call to stripe API with provided card credentials and returns the result
  Future<Map<String, dynamic>?> getStripeResponse() async {
    if (widget.stripePublishableKey == null) {
      if (kDebugMode) {
        print(
            '***ERROR tried calling `getStripeResponse()` but no stripe key provided');
      }
      return null;
    }

    _validateFields();

    if (!_cardDetails.isComplete) {
      if (kDebugMode) {
        print(
            '***ERROR Could not get stripe response, card details not complete: ${_cardDetails.validState}');
      }
      return null;
    }

    if (widget.onCallToStripe != null) widget.onCallToStripe!();

    bool returned = false;
    Future.delayed(
      widget.delayToShowLoading,
      () => returned ? null : setState(() => _loading = true),
    );

    const stripeCardUrl = 'https://api.stripe.com/v1/tokens';
    final response = await http.post(
      Uri.parse(stripeCardUrl),
      body: {
        'card[number]': _cardDetails.cardNumber,
        'card[cvc]': _cardDetails.securityCode,
        'card[exp_month]': _cardDetails.expMonth,
        'card[exp_year]': _cardDetails.expYear,
        'card[address_zip]': _cardDetails.postalCode,
        'key': widget.stripePublishableKey,
      },
      headers: {"Content-Type": "application/x-www-form-urlencoded"},
    );

    returned = true;
    final Map<String, dynamic> jsonBody = jsonDecode(response.body);
    if (_loading) setState(() => _loading = false);
    return jsonBody;
  }

  Future<void> _postalFieldSubmitted() async {
    _validateFields();
    if (widget.onSubmitted != null) {
      widget.onSubmitted!(_cardDetails.isComplete ? _cardDetails : null);
    }
    if (_cardDetails.isComplete) {
      if (widget.onValidCardDetails != null) {
        widget.onValidCardDetails!(_cardDetails);
      } else if (widget.onStripeResponse != null &&
          !widget.autoFetchStripektoken) {
        // Callback that stripe call is being made
        if (widget.onCallToStripe != null) widget.onCallToStripe!();
        final jsonBody = await getStripeResponse();

        widget.onStripeResponse!(jsonBody);
      }
    }
  }

  /// Provided a list of `ValidState`, returns whether
  /// make the text field red
  bool _isRedText(List<CardDetailsValidState> args) {
    return _showBorderError && args.contains(_cardDetails.validState);
  }

  /// Helper function to change the `_showBorderError` and
  /// `_validationErrorText`.
  void _setValidationState(String? text) {
    setState(() {
      _validationErrorText = text;
      _showBorderError = text != null;
    });
  }

  /// Calls `validate()` on the form state and resets
  /// the validation state
  void _validateFields() {
    _validationErrorText = null;
    if (widget.overrideValidState != null) {
      _cardDetails.overrideValidState = widget.overrideValidState!;
      _setValidationState(widget.errorText);
    } else {
      _formFieldKey.currentState!.validate();

      // Clear up validation state if everything is valid
      if (_validationErrorText == null) {
        _setValidationState(null);
      }
    }
    return;
  }

  /// Used when `_isWideFormat == false`, scrolls
  /// the `_horizontalScrollController` to a given offset
  void _scrollRow(CardEntryStep step) async {
    await Future.delayed(const Duration(milliseconds: 25));
    const dur = Duration(milliseconds: 150);
    const cur = Curves.easeOut;
    switch (step) {
      case CardEntryStep.number:
        _horizontalScrollController.animateTo(-20.0, duration: dur, curve: cur);
        break;
      case CardEntryStep.exp:
        _horizontalScrollController.animateTo(_cardFieldWidth / 2,
            duration: dur, curve: cur);
        break;
      case CardEntryStep.cvc:
        _horizontalScrollController.animateTo(
            _cardFieldWidth / 2 + _expirationFieldWidth,
            duration: dur,
            curve: cur);
        break;
      case CardEntryStep.postal:
        _horizontalScrollController.animateTo(
            _cardFieldWidth / 2 + _expirationFieldWidth + _securityFieldWidth,
            duration: dur,
            curve: cur);
        break;
    }
  }

  /// Function that is listening to the `_currentCardEntryStepController`
  /// StreamController. Manages validation and tracking of the current step
  /// as well as scrolling the text fields.
  void _onStepChange(CardEntryStep step) {
    // Validated fields only when progressing, not when regressing in step
    if (_currentStep.index < step.index) {
      _validateFields();
    } else if (_currentStep != step) {
      _setValidationState(null);
    }
    // If field tapped, and has focus, dismiss focus
    if (_currentStep == step && _anyHaveFocus()) {
      FocusManager.instance.primaryFocus?.unfocus();
      return;
    }

    setState(() {
      _currentStep = step;
    });
    switch (_currentStep) {
      case CardEntryStep.number:
        cardNumberFocusNode.requestFocus();
        break;
      case CardEntryStep.exp:
        expirationFocusNode.requestFocus();
        break;
      case CardEntryStep.cvc:
        securityCodeFocusNode.requestFocus();
        break;
      case CardEntryStep.postal:
        postalCodeFocusNode.requestFocus();
        break;
    }

    // Make the selection adjustment only on web, other platforms dont select on focus change
    if (kIsWeb) {
      WidgetsBinding.instance.addPostFrameCallback((_) => _adjustSelection());
    }

    if (!isWideFormat) {
      _scrollRow(step);
    }
  }

  /// Returns true if any field in the `CardTextField` has focus.
  bool _anyHaveFocus() {
    return cardNumberFocusNode.hasFocus ||
        expirationFocusNode.hasFocus ||
        securityCodeFocusNode.hasFocus ||
        postalCodeFocusNode.hasFocus;
  }

  /// On web, selection gets screwy when changing focus, workaround for placing cursor at the end of the text content only
  void _adjustSelection() {
    switch (_currentStep) {
      case CardEntryStep.number:
        final len = _cardNumberController.text.length;
        _cardNumberController.value = _cardNumberController.value.copyWith(
            selection: TextSelection(baseOffset: len, extentOffset: len));
        break;
      case CardEntryStep.exp:
        final len = _expirationController.text.length;
        _expirationController.value = _expirationController.value.copyWith(
            selection: TextSelection(baseOffset: len, extentOffset: len));
        break;
      case CardEntryStep.cvc:
        final len = _securityCodeController.text.length;
        _securityCodeController.value = _securityCodeController.value.copyWith(
            selection: TextSelection(baseOffset: len, extentOffset: len));
        break;
      case CardEntryStep.postal:
        final len = _postalCodeController.text.length;
        _postalCodeController.value = _postalCodeController.value.copyWith(
            selection: TextSelection(baseOffset: len, extentOffset: len));
        break;
    }
  }

  /// Function that is listening to the keyboard events.
  ///
  /// This provides the functionality of hitting backspace
  /// and the focus changing between fields when the current
  /// entry step is empty.
  void _backspaceTransitionListener(RawKeyEvent value) {
    if (!value.isKeyPressed(LogicalKeyboardKey.backspace)) {
      return;
    }
    switch (_currentStep) {
      case CardEntryStep.number:
        return;
      case CardEntryStep.exp:
        if (_expirationController.text.isNotEmpty) return;
      case CardEntryStep.cvc:
        if (_securityCodeController.text.isNotEmpty) return;
      case CardEntryStep.postal:
        if (_postalCodeController.text.isNotEmpty) return;
    }
    _transitionStepFocus();
  }

  /// Called whenever a text field is emptied and the mobile flag is set
  void _mobileBackspaceDetected() {
    // Put the empty char back into the controller to detect backspace on mobile
    switch (_currentStep) {
      case CardEntryStep.number:
        break;
      case CardEntryStep.exp:
        _expirationController.text = '\u200b';
      case CardEntryStep.cvc:
        _securityCodeController.text = '\u200b';
      case CardEntryStep.postal:
        _postalCodeController.text = '\u200b';
    }
    _transitionStepFocus();
  }

  void _transitionStepFocus() {
    switch (_currentStep) {
      case CardEntryStep.number:
        break;
      case CardEntryStep.exp:
        _currentCardEntryStepController.add(CardEntryStep.number);

        final String numStr = _cardNumberController.text;
        final endIndex = numStr.isEmpty ? 0 : numStr.length - 1;
        _cardNumberController.text = numStr.substring(0, endIndex);
        break;
      case CardEntryStep.cvc:
        _currentCardEntryStepController.add(CardEntryStep.exp);
        final String expStr = _expirationController.text;
        final endIndex = expStr.isEmpty ? 0 : expStr.length - 1;
        _expirationController.text = expStr.substring(0, endIndex);
        break;
      case CardEntryStep.postal:
        _currentCardEntryStepController.add(CardEntryStep.cvc);
        final String cvcStr = _securityCodeController.text;
        final endIndex = cvcStr.isEmpty ? 0 : cvcStr.length - 1;
        _securityCodeController.text = cvcStr.substring(0, endIndex);
        break;
    }
  }
}

/// Formatter that adds the appropriate space ' ' characters
/// to make the card number display cleanly.
class CardNumberInputFormatter implements TextInputFormatter {
  @override
  TextEditingValue formatEditUpdate(
      TextEditingValue oldValue, TextEditingValue newValue) {
    String cardNum = newValue.text;
    if (cardNum.length <= 4) return newValue;

    cardNum = cardNum.replaceAll(' ', '');
    StringBuffer buffer = StringBuffer();

    for (int i = 0; i < cardNum.length; i++) {
      buffer.write(cardNum[i]);
      int nonZeroIndex = i + 1;
      if (nonZeroIndex % 4 == 0 && nonZeroIndex != cardNum.length) {
        buffer.write(' ');
      }
    }

    return newValue.copyWith(
        text: buffer.toString(),
        selection: TextSelection.collapsed(offset: buffer.length));
  }
}

/// Formatter that adds a backslash '/' character in between
/// the month and the year for the expiration date.
class CardExpirationFormatter implements TextInputFormatter {
  @override
  TextEditingValue formatEditUpdate(
      TextEditingValue oldValue, TextEditingValue newValue) {
    String cardExp = newValue.text;
    if (cardExp.length == 1) {
      if (cardExp[0] == '0' || cardExp[0] == '1') {
        return newValue;
      } else {
        cardExp = '0$cardExp';
      }
    }
    if (cardExp.length == 2 && oldValue.text.length == 3) return newValue;

    cardExp = cardExp.replaceAll('/', '');
    StringBuffer buffer = StringBuffer();

    for (int i = 0; i < cardExp.length; i++) {
      buffer.write(cardExp[i]);
      int nonZeroIndex = i + 1;
      if (nonZeroIndex == 2) {
        buffer.write('/');
      }
    }
    return newValue.copyWith(
        text: buffer.toString(),
        selection: TextSelection.collapsed(offset: buffer.length));
  }
}