react-native-firebase/ios/RNFirebase/auth/RNFirebaseAuth.m

#import "RNFirebaseAuth.h"
#import "RNFirebaseEvents.h"
#import "RNFirebaseUtil.h"
#import "RCTDefines.h"


#if __has_include(<FirebaseAuth/FIRAuth.h>)

@implementation RNFirebaseAuth
RCT_EXPORT_MODULE();

- (id)init {
    self = [super init];
    if (self != nil) {
        _authStateHandlers = [[NSMutableDictionary alloc] init];
        _idTokenHandlers = [[NSMutableDictionary alloc] init];
    }
    return self;
}

/**
 addAuthStateListener

 */
RCT_EXPORT_METHOD(addAuthStateListener:
    (NSString *) appDisplayName) {
    FIRApp *firApp = [RNFirebaseUtil getApp:appDisplayName];

    if (![_authStateHandlers valueForKey:firApp.name]) {
        FIRAuthStateDidChangeListenerHandle newListenerHandle = [[FIRAuth authWithApp:firApp] addAuthStateDidChangeListener:^(FIRAuth *_Nonnull auth, FIRUser *_Nullable user) {
            if (user != nil) {
                [RNFirebaseUtil sendJSEventWithAppName:self app:firApp name:AUTH_STATE_CHANGED_EVENT body:@{@"user": [self firebaseUserToDict:user]}];
            } else {
                [RNFirebaseUtil sendJSEventWithAppName:self app:firApp name:AUTH_STATE_CHANGED_EVENT body:@{}];
            }
        }];

        _authStateHandlers[firApp.name] = [NSValue valueWithNonretainedObject:newListenerHandle];
    }
}

/**
 removeAuthStateListener

 */
RCT_EXPORT_METHOD(removeAuthStateListener:
    (NSString *) appDisplayName) {
    FIRApp *firApp = [RNFirebaseUtil getApp:appDisplayName];

    if ([_authStateHandlers valueForKey:firApp.name]) {
        [[FIRAuth authWithApp:firApp] removeAuthStateDidChangeListener:[_authStateHandlers valueForKey:firApp.name]];
        [_authStateHandlers removeObjectForKey:firApp.name];
    }
}

/**
 addIdTokenListener

 */
RCT_EXPORT_METHOD(addIdTokenListener:
                  (NSString *) appDisplayName) {
    FIRApp *firApp = [RNFirebaseUtil getApp:appDisplayName];

    if (![_idTokenHandlers valueForKey:firApp.name]) {
        FIRIDTokenDidChangeListenerHandle newListenerHandle = [[FIRAuth authWithApp:firApp] addIDTokenDidChangeListener:^(FIRAuth * _Nonnull auth, FIRUser * _Nullable user) {
            if (user != nil) {
                [RNFirebaseUtil sendJSEventWithAppName:self app:firApp name:AUTH_ID_TOKEN_CHANGED_EVENT body:@{@"user": [self firebaseUserToDict:user]}];
            } else {
                [RNFirebaseUtil sendJSEventWithAppName:self app:firApp name:AUTH_ID_TOKEN_CHANGED_EVENT body:@{}];
            }
        }];

        _idTokenHandlers[firApp.name] = [NSValue valueWithNonretainedObject:newListenerHandle];
    }
}

/**
 removeAuthStateListener

 */
RCT_EXPORT_METHOD(removeIdTokenListener:
                  (NSString *) appDisplayName) {
    FIRApp *firApp = [RNFirebaseUtil getApp:appDisplayName];

    if ([_idTokenHandlers valueForKey:firApp.name]) {
        [[FIRAuth authWithApp:firApp] removeIDTokenDidChangeListener:[_idTokenHandlers valueForKey:firApp.name]];
        [_idTokenHandlers removeObjectForKey:firApp.name];
    }
}



/**
 signOut

 @param RCTPromiseResolveBlock resolve
 @param RCTPromiseRejectBlock reject
 @return
 */
RCT_EXPORT_METHOD(signOut:
    (NSString *) appDisplayName
            resolver:
            (RCTPromiseResolveBlock) resolve
            rejecter:
            (RCTPromiseRejectBlock) reject) {
    FIRApp *firApp = [RNFirebaseUtil getApp:appDisplayName];

    FIRUser *user = [FIRAuth authWithApp:firApp].currentUser;

    if (user) {
        NSError *error;
        [[FIRAuth authWithApp:firApp] signOut:&error];
        if (!error) [self promiseNoUser:resolve rejecter:reject isError:NO];
        else [self promiseRejectAuthException:reject error:error];
    } else {
        [self promiseNoUser:resolve rejecter:reject isError:YES];
    }
}


/**
 signInAnonymously

 @param RCTPromiseResolveBlock resolve
 @param RCTPromiseRejectBlock reject
 @return
 */
RCT_EXPORT_METHOD(signInAnonymously:(NSString *) appDisplayName
                  resolver:(RCTPromiseResolveBlock) resolve
                  rejecter:(RCTPromiseRejectBlock) reject) {
    FIRApp *firApp = [RNFirebaseUtil getApp:appDisplayName];

    [[FIRAuth authWithApp:firApp] signInAnonymouslyWithCompletion:^(FIRUser *user, NSError *error) {
        if (error) {
            [self promiseRejectAuthException:reject error:error];
        } else {
            [self promiseWithUser:resolve rejecter:reject user:user];
        }
    }];
}

/**
 signInAnonymouslyAndRetrieveData
 
 @param RCTPromiseResolveBlock resolve
 @param RCTPromiseRejectBlock reject
 @return
 */
RCT_EXPORT_METHOD(signInAnonymouslyAndRetrieveData:(NSString *) appDisplayName
                  resolver:(RCTPromiseResolveBlock) resolve
                  rejecter:(RCTPromiseRejectBlock) reject) {
    FIRApp *firApp = [RNFirebaseUtil getApp:appDisplayName];
    
    [[FIRAuth authWithApp:firApp] signInAnonymouslyAndRetrieveDataWithCompletion:^(FIRAuthDataResult *authResult, NSError *error) {
        if (error) {
            [self promiseRejectAuthException:reject error:error];
        } else {
            [self promiseWithAuthResult:resolve rejecter:reject authResult:authResult];
        }
    }];
}

/**
 signInWithEmailAndPassword

 @param NSString NSString email
 @param NSString NSString password
 @param RCTPromiseResolveBlock resolve
 @param RCTPromiseRejectBlock reject
 @return return
 */
RCT_EXPORT_METHOD(signInWithEmailAndPassword:(NSString *) appDisplayName
                  email:(NSString *) email
                  pass:(NSString *) password
                  resolver:(RCTPromiseResolveBlock) resolve
                  rejecter:(RCTPromiseRejectBlock) reject) {
    FIRApp *firApp = [RNFirebaseUtil getApp:appDisplayName];

    [[FIRAuth authWithApp:firApp] signInWithEmail:email password:password completion:^(FIRUser *user, NSError *error) {
        if (error) {
            [self promiseRejectAuthException:reject error:error];
        } else {
            [self promiseWithUser:resolve rejecter:reject user:user];
        }
    }];
}

/**
 signInAndRetrieveDataWithEmailAndPassword
 
 @param NSString NSString email
 @param NSString NSString password
 @param RCTPromiseResolveBlock resolve
 @param RCTPromiseRejectBlock reject
 @return return
 */
RCT_EXPORT_METHOD(signInAndRetrieveDataWithEmailAndPassword:(NSString *) appDisplayName
                  email:(NSString *) email
                  pass:(NSString *) password
                  resolver:(RCTPromiseResolveBlock) resolve
                  rejecter:(RCTPromiseRejectBlock) reject) {
    FIRApp *firApp = [RNFirebaseUtil getApp:appDisplayName];
    
    [[FIRAuth authWithApp:firApp] signInAndRetrieveDataWithEmail:email password:password completion:^(FIRAuthDataResult *authResult, NSError *error) {
        if (error) {
            [self promiseRejectAuthException:reject error:error];
        } else {
            [self promiseWithAuthResult:resolve rejecter:reject authResult:authResult];
        }
    }];
}

/**
 createUserWithEmailAndPassword

 @param NSString NSString email
 @param NSString NSString password
 @param RCTPromiseResolveBlock resolve
 @param RCTPromiseRejectBlock reject
 @return return
 */
RCT_EXPORT_METHOD(createUserWithEmailAndPassword:(NSString *) appDisplayName
                  email:(NSString *) email
                  pass:(NSString *) password
                  resolver:(RCTPromiseResolveBlock) resolve
                  rejecter:(RCTPromiseRejectBlock) reject) {
    FIRApp *firApp = [RNFirebaseUtil getApp:appDisplayName];

    [[FIRAuth authWithApp:firApp] createUserWithEmail:email password:password completion:^(FIRUser *user, NSError *error) {
        if (error) {
            [self promiseRejectAuthException:reject error:error];
        } else {
            [self promiseWithUser:resolve rejecter:reject user:user];
        }
    }];
}

/**
 createUserAndRetrieveDataWithEmailAndPassword
 
 @param NSString NSString email
 @param NSString NSString password
 @param RCTPromiseResolveBlock resolve
 @param RCTPromiseRejectBlock reject
 @return return
 */
RCT_EXPORT_METHOD(createUserAndRetrieveDataWithEmailAndPassword:(NSString *) appDisplayName
                  email:(NSString *) email
                  pass:(NSString *) password
                  resolver:(RCTPromiseResolveBlock) resolve
                  rejecter:(RCTPromiseRejectBlock) reject) {
    FIRApp *firApp = [RNFirebaseUtil getApp:appDisplayName];
    
    [[FIRAuth authWithApp:firApp] createUserAndRetrieveDataWithEmail:email password:password
                                                          completion:^(FIRAuthDataResult * _Nullable authResult, NSError * _Nullable error) {
          if (error) {
              [self promiseRejectAuthException:reject error:error];
          } else {
              [self promiseWithAuthResult:resolve rejecter:reject authResult:authResult];
          }
    }];
}

/**
 deleteUser

 @param RCTPromiseResolveBlock resolve
 @param RCTPromiseRejectBlock reject
 @return return
 */
RCT_EXPORT_METHOD(delete:
    (NSString *) appDisplayName
            resolver:
            (RCTPromiseResolveBlock) resolve
            rejecter:
            (RCTPromiseRejectBlock) reject) {
    FIRApp *firApp = [RNFirebaseUtil getApp:appDisplayName];
    FIRUser *user = [FIRAuth authWithApp:firApp].currentUser;

    if (user) {
        [user deleteWithCompletion:^(NSError *_Nullable error) {
            if (error) {
                [self promiseRejectAuthException:reject error:error];
            } else {
                [self promiseNoUser:resolve rejecter:reject isError:NO];
            }
        }];
    } else {
        [self promiseNoUser:resolve rejecter:reject isError:YES];
    }
}

/**
 reload

 @param RCTPromiseResolveBlock resolve
 @param RCTPromiseRejectBlock reject
 @return return
 */
RCT_EXPORT_METHOD(reload:
    (NSString *) appDisplayName
            resolver:
            (RCTPromiseResolveBlock) resolve
            rejecter:
            (RCTPromiseRejectBlock) reject) {
    FIRApp *firApp = [RNFirebaseUtil getApp:appDisplayName];

    FIRUser *user = [FIRAuth authWithApp:firApp].currentUser;

    if (user) {
        [self reloadAndReturnUser:user resolver:resolve rejecter: reject];
    } else {
        [self promiseNoUser:resolve rejecter:reject isError:YES];
    }
}

/**
 sendEmailVerification

 @param RCTPromiseResolveBlock resolve
 @param RCTPromiseRejectBlock reject
 @return return
 */
RCT_EXPORT_METHOD(sendEmailVerification:(NSString *) appDisplayName
                     actionCodeSettings:(NSDictionary *) actionCodeSettings
                               resolver:(RCTPromiseResolveBlock) resolve
                               rejecter:(RCTPromiseRejectBlock) reject) {
    FIRApp *firApp = [RNFirebaseUtil getApp:appDisplayName];

    FIRUser *user = [FIRAuth authWithApp:firApp].currentUser;
    if (user) {
        id handler = ^(NSError *_Nullable error) {
            if (error) {
                [self promiseRejectAuthException:reject error:error];
            } else {
                FIRUser *userAfterUpdate = [FIRAuth authWithApp:firApp].currentUser;
                [self promiseWithUser:resolve rejecter:reject user:userAfterUpdate];
            }
        };
        if (actionCodeSettings) {
            FIRActionCodeSettings *settings = [self buildActionCodeSettings:actionCodeSettings];
            [user sendEmailVerificationWithActionCodeSettings:settings completion:handler];
        } else {
            [user sendEmailVerificationWithCompletion:handler];
        }
    } else {
        [self promiseNoUser:resolve rejecter:reject isError:YES];
    }
}

/**
 updateEmail

 @param NSString email
 @param RCTPromiseResolveBlock resolve
 @param RCTPromiseRejectBlock reject
 @return return
 */
RCT_EXPORT_METHOD(updateEmail:
    (NSString *) appDisplayName
            email:
            (NSString *) email
            resolver:
            (RCTPromiseResolveBlock) resolve
            rejecter:
            (RCTPromiseRejectBlock) reject) {
    FIRApp *firApp = [RNFirebaseUtil getApp:appDisplayName];
    FIRUser *user = [FIRAuth authWithApp:firApp].currentUser;

    if (user) {
        [user updateEmail:email completion:^(NSError *_Nullable error) {
            if (error) {
                [self promiseRejectAuthException:reject error:error];
            } else {
                [self reloadAndReturnUser:user resolver:resolve rejecter: reject];
            }
        }];
    } else {
        [self promiseNoUser:resolve rejecter:reject isError:YES];
    }
}

/**
 updatePassword

 @param NSString password
 @param RCTPromiseResolveBlock resolve
 @param RCTPromiseRejectBlock reject
 @return return
 */
RCT_EXPORT_METHOD(updatePassword:
    (NSString *) appDisplayName
            password:
            (NSString *) password
            resolver:
            (RCTPromiseResolveBlock) resolve
            rejecter:
            (RCTPromiseRejectBlock) reject) {
    FIRApp *firApp = [RNFirebaseUtil getApp:appDisplayName];

    FIRUser *user = [FIRAuth authWithApp:firApp].currentUser;

    if (user) {
        [user updatePassword:password completion:^(NSError *_Nullable error) {
            if (error) {
                [self promiseRejectAuthException:reject error:error];
            } else {
                FIRUser *userAfterUpdate = [FIRAuth authWithApp:firApp].currentUser;
                [self promiseWithUser:resolve rejecter:reject user:userAfterUpdate];
            }
        }];
    } else {
        [self promiseNoUser:resolve rejecter:reject isError:YES];
    }
}

/**
 updateProfile

 @param NSDictionary props
 @param RCTPromiseResolveBlock resolve
 @param RCTPromiseRejectBlock reject
 @return return
 */
RCT_EXPORT_METHOD(updateProfile:
    (NSString *) appDisplayName
            props:
            (NSDictionary *) props
            resolver:
            (RCTPromiseResolveBlock) resolve
            rejecter:
            (RCTPromiseRejectBlock) reject) {
    FIRApp *firApp = [RNFirebaseUtil getApp:appDisplayName];

    FIRUser *user = [FIRAuth authWithApp:firApp].currentUser;

    if (user) {
        FIRUserProfileChangeRequest *changeRequest = [user profileChangeRequest];
        NSMutableArray *allKeys = [[props allKeys] mutableCopy];

        for (NSString *key in allKeys) {
            @try {
                if ([key isEqualToString:@"photoURL"]) {
                    NSURL *url = [NSURL URLWithString:[props valueForKey:key]];
                    [changeRequest setValue:url forKey:key];
                } else {
                    [changeRequest setValue:props[key] forKey:key];
                }
            } @catch (NSException *exception) {
                NSLog(@"Exception occurred while configuring: %@", exception);
            }
        }

        [changeRequest commitChangesWithCompletion:^(NSError *_Nullable error) {
            if (error) {
                [self promiseRejectAuthException:reject error:error];
            } else {
                [self reloadAndReturnUser:user resolver:resolve rejecter: reject];
            }
        }];
    } else {
        [self promiseNoUser:resolve rejecter:reject isError:YES];
    }
}

/**
 getToken

 @param RCTPromiseResolveBlock resolve
 @param RCTPromiseRejectBlock reject
 @return
 */
RCT_EXPORT_METHOD(getToken:
    (NSString *) appDisplayName
            forceRefresh:
            (BOOL) forceRefresh
            resolver:
            (RCTPromiseResolveBlock) resolve
            rejecter:
            (RCTPromiseRejectBlock) reject) {
    FIRApp *firApp = [RNFirebaseUtil getApp:appDisplayName];

    FIRUser *user = [FIRAuth authWithApp:firApp].currentUser;

    if (user) {
        [user getIDTokenForcingRefresh:(BOOL) forceRefresh completion:^(NSString *token, NSError *_Nullable error) {
            if (error) {
                [self promiseRejectAuthException:reject error:error];
            } else {
                resolve(token);
            }
        }];
    } else {
        [self promiseNoUser:resolve rejecter:reject isError:YES];
    }
}

/**
 signInWithCredential

 @param NSString provider
 @param NSString authToken
 @param NSString authSecret
 @param RCTPromiseResolveBlock resolve
 @param RCTPromiseRejectBlock reject
 @return
 */
RCT_EXPORT_METHOD(signInWithCredential:(NSString *) appDisplayName
                  provider:(NSString *) provider
                  token:(NSString *) authToken
                  secret:(NSString *) authSecret
                  resolver:(RCTPromiseResolveBlock) resolve
                  rejecter:(RCTPromiseRejectBlock) reject) {
    FIRApp *firApp = [RNFirebaseUtil getApp:appDisplayName];

    FIRAuthCredential *credential = [self getCredentialForProvider:provider token:authToken secret:authSecret];

    if (credential == nil) {
        return reject(@"auth/invalid-credential", @"The supplied auth credential is malformed, has expired or is not currently supported.", nil);
    }

    [[FIRAuth authWithApp:firApp] signInWithCredential:credential completion:^(FIRUser *user, NSError *error) {
        if (error) {
            [self promiseRejectAuthException:reject error:error];
        } else {
            [self promiseWithUser:resolve rejecter:reject user:user];
        }
    }];
}

/**
 signInAndRetrieveDataWithCredential
 
 @param NSString provider
 @param NSString authToken
 @param NSString authSecret
 @param RCTPromiseResolveBlock resolve
 @param RCTPromiseRejectBlock reject
 @return
 */
RCT_EXPORT_METHOD(signInAndRetrieveDataWithCredential:(NSString *) appDisplayName
                  provider:(NSString *) provider
                  token:(NSString *) authToken
                  secret:(NSString *) authSecret
                  resolver:(RCTPromiseResolveBlock) resolve
                  rejecter:(RCTPromiseRejectBlock) reject) {
    FIRApp *firApp = [RNFirebaseUtil getApp:appDisplayName];
    
    FIRAuthCredential *credential = [self getCredentialForProvider:provider token:authToken secret:authSecret];
    
    if (credential == nil) {
        return reject(@"auth/invalid-credential", @"The supplied auth credential is malformed, has expired or is not currently supported.", nil);
    }
    
    [[FIRAuth authWithApp:firApp] signInAndRetrieveDataWithCredential:credential completion:^(FIRAuthDataResult *authResult, NSError *error) {
        if (error) {
            [self promiseRejectAuthException:reject error:error];
        } else {
            [self promiseWithAuthResult:resolve rejecter:reject authResult:authResult];
        }
    }];
}

/**
 confirmPasswordReset

 @param NSString code
 @param NSString newPassword
 @param RCTPromiseResolveBlock resolve
 @param RCTPromiseRejectBlock reject
 @return
 */
RCT_EXPORT_METHOD(confirmPasswordReset:
        (NSString *) appDisplayName
            code:
            (NSString *) code
            newPassword:
            (NSString *) newPassword
            resolver:
            (RCTPromiseResolveBlock) resolve
            rejecter:
            (RCTPromiseRejectBlock) reject) {
    FIRApp *firApp = [RNFirebaseUtil getApp:appDisplayName];

    [[FIRAuth authWithApp:firApp] confirmPasswordResetWithCode:code newPassword:newPassword completion:^(NSError *_Nullable error) {
        if (error) {
            [self promiseRejectAuthException:reject error:error];
        } else {
            [self promiseNoUser:resolve rejecter:reject isError:NO];
        }
    }];
}


/**
 * applyActionCode
 *
 * @param NSString code
 * @param RCTPromiseResolveBlock resolve
 * @param RCTPromiseRejectBlock reject
 * @return
 */
RCT_EXPORT_METHOD(applyActionCode:
        (NSString *) appDisplayName
            code:
            (NSString *) code
            resolver:
            (RCTPromiseResolveBlock) resolve
            rejecter:
            (RCTPromiseRejectBlock) reject) {
    FIRApp *firApp = [RNFirebaseUtil getApp:appDisplayName];

    [[FIRAuth authWithApp:firApp] applyActionCode:code completion:^(NSError *_Nullable error) {
        if (error) {
            [self promiseRejectAuthException:reject error:error];
        } else {
            [self promiseNoUser:resolve rejecter:reject isError:NO];
        }
    }];
}

/**
 * checkActionCode
 *
 * @param NSString code
 * @param RCTPromiseResolveBlock resolve
 * @param RCTPromiseRejectBlock reject
 * @return
 */
RCT_EXPORT_METHOD(checkActionCode:
        (NSString *) appDisplayName
            code:
            (NSString *) code
            resolver:
            (RCTPromiseResolveBlock) resolve
            rejecter:
            (RCTPromiseRejectBlock) reject) {
    FIRApp *firApp = [RNFirebaseUtil getApp:appDisplayName];

    [[FIRAuth authWithApp:firApp] checkActionCode:code completion:^(FIRActionCodeInfo *_Nullable info, NSError *_Nullable error) {
        if (error) {
            [self promiseRejectAuthException:reject error:error];
        } else {
            NSString *actionType = @"ERROR";
            switch (info.operation) {
                case FIRActionCodeOperationPasswordReset:
                    actionType = @"PASSWORD_RESET";
                    break;
                case FIRActionCodeOperationVerifyEmail:
                    actionType = @"VERIFY_EMAIL";
                    break;
                case FIRActionCodeOperationUnknown:
                    actionType = @"UNKNOWN";
                    break;
                case FIRActionCodeOperationRecoverEmail:
                    actionType = @"RECOVER_EMAIL";
                    break;
            }

            NSDictionary *result = @{@"data": @{@"email": [info dataForKey:FIRActionCodeEmailKey], @"fromEmail": [info dataForKey:FIRActionCodeFromEmailKey],}, @"actionType": actionType,};

            resolve(result);
        }
    }];
}

/**
 sendPasswordResetEmail

 @param NSString email
 @param RCTPromiseResolveBlock resolve
 @param RCTPromiseRejectBlock reject
 @return
 */
RCT_EXPORT_METHOD(sendPasswordResetEmail:(NSString *) appDisplayName
                                   email:(NSString *) email
                      actionCodeSettings:(NSDictionary *) actionCodeSettings
                                resolver:(RCTPromiseResolveBlock) resolve
                                rejecter:(RCTPromiseRejectBlock) reject) {
    FIRApp *firApp = [RNFirebaseUtil getApp:appDisplayName];

    id handler = ^(NSError *_Nullable error) {
        if (error) {
            [self promiseRejectAuthException:reject error:error];
        } else {
            [self promiseNoUser:resolve rejecter:reject isError:NO];
        }
    };

    if (actionCodeSettings) {
        FIRActionCodeSettings *settings = [self buildActionCodeSettings:actionCodeSettings];
        [[FIRAuth authWithApp:firApp] sendPasswordResetWithEmail:email actionCodeSettings:settings completion:handler];
    } else {
        [[FIRAuth authWithApp:firApp] sendPasswordResetWithEmail:email completion:handler];
    }
}


/**
 signInAndRetrieveDataWithCustomToken

 @param RCTPromiseResolveBlock resolve
 @param RCTPromiseRejectBlock reject
 @return
 */
RCT_EXPORT_METHOD(signInAndRetrieveDataWithCustomToken:(NSString *) appDisplayName
                  customToken:(NSString *) customToken
                  resolver:(RCTPromiseResolveBlock) resolve
                  rejecter:(RCTPromiseRejectBlock) reject) {
    FIRApp *firApp = [RNFirebaseUtil getApp:appDisplayName];

    [[FIRAuth authWithApp:firApp] signInAndRetrieveDataWithCustomToken:customToken completion:^(FIRAuthDataResult *authResult, NSError *error) {
        if (error) {
            [self promiseRejectAuthException:reject error:error];
        } else {
            [self promiseWithAuthResult:resolve rejecter:reject authResult:authResult];
        }
    }];
}

/**
 signInWithCustomToken
 
 @param RCTPromiseResolveBlock resolve
 @param RCTPromiseRejectBlock reject
 @return
 */
RCT_EXPORT_METHOD(signInWithCustomToken:(NSString *) appDisplayName
                  customToken:(NSString *) customToken
                  resolver:(RCTPromiseResolveBlock) resolve
                  rejecter:(RCTPromiseRejectBlock) reject) {
    FIRApp *firApp = [RNFirebaseUtil getApp:appDisplayName];
    
    [[FIRAuth authWithApp:firApp] signInWithCustomToken:customToken completion:^(FIRUser *user, NSError *error) {
        if (error) {
            [self promiseRejectAuthException:reject error:error];
        } else {
            [self promiseWithUser:resolve rejecter:reject user:user];
        }
    }];
}

/**
 signInWithPhoneNumber

 @param string phoneNumber
 @param RCTPromiseResolveBlock resolve
 @param RCTPromiseRejectBlock reject
 @return
 */
RCT_EXPORT_METHOD(signInWithPhoneNumber:(NSString *) appDisplayName
            phoneNumber:(NSString *) phoneNumber
            resolver:(RCTPromiseResolveBlock) resolve
            rejecter:(RCTPromiseRejectBlock) reject) {
    FIRApp *firApp = [RNFirebaseUtil getApp:appDisplayName];

    [[FIRPhoneAuthProvider providerWithAuth:[FIRAuth authWithApp:firApp]] verifyPhoneNumber:phoneNumber UIDelegate:nil completion:^(NSString * _Nullable verificationID, NSError * _Nullable error) {
        if (error) {
            [self promiseRejectAuthException:reject error:error];
        } else {
            NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];
            [defaults setObject:verificationID forKey:@"authVerificationID"];
            resolve(@{
                    @"verificationId": verificationID
            });
        }
    }];
}

/**
 verifyPhoneNumber

 @param string phoneNumber
 @param RCTPromiseResolveBlock resolve
 @param RCTPromiseRejectBlock reject
 @return
 */
RCT_EXPORT_METHOD(verifyPhoneNumber:(NSString *) appDisplayName
                  phoneNumber:(NSString *) phoneNumber
                  requestKey:(NSString *) requestKey) {
    FIRApp *firApp = [RNFirebaseUtil getApp:appDisplayName];

    [[FIRPhoneAuthProvider providerWithAuth:[FIRAuth authWithApp:firApp]] verifyPhoneNumber:phoneNumber UIDelegate:nil completion:^(NSString * _Nullable verificationID, NSError * _Nullable error) {
        if (error) {
            NSDictionary * jsError = [self getJSError:(error)];
            NSDictionary *body = @{
                                   @"type": @"onVerificationFailed",
                                   @"requestKey":requestKey,
                                   @"state": @{@"error": jsError},
                                  };
            [RNFirebaseUtil sendJSEventWithAppName:self app:firApp name:PHONE_AUTH_STATE_CHANGED_EVENT body:body];
        } else {
            NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];
            [defaults setObject:verificationID forKey:@"authVerificationID"];
            NSDictionary *body = @{
                                   @"type": @"onCodeSent",
                                   @"requestKey":requestKey,
                                   @"state": @{@"verificationId": verificationID},
                                  };
            [RNFirebaseUtil sendJSEventWithAppName:self app:firApp name:PHONE_AUTH_STATE_CHANGED_EVENT body:body];
        }
    }];
}

RCT_EXPORT_METHOD(_confirmVerificationCode:(NSString *) appDisplayName
            verificationCode:(NSString *) verificationCode
            resolver:(RCTPromiseResolveBlock) resolve
            rejecter:(RCTPromiseRejectBlock) reject) {
    FIRApp *firApp = [RNFirebaseUtil getApp:appDisplayName];
    NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];
    NSString *verificationId = [defaults stringForKey:@"authVerificationID"];
    FIRAuthCredential *credential = [[FIRPhoneAuthProvider provider] credentialWithVerificationID:verificationId verificationCode:verificationCode];

    [[FIRAuth authWithApp:firApp] signInWithCredential:credential completion:^(FIRUser *user, NSError *error) {
        if (error) {
            [self promiseRejectAuthException:reject error:error];
        } else {
            [self promiseWithUser:resolve rejecter:reject user:user];
        }
    }];
}

/**
 linkWithCredential

 @param NSString provider
 @param NSString authToken
 @param NSString authSecret
 @param RCTPromiseResolveBlock resolve
 @param RCTPromiseRejectBlock reject
 @return
 */
RCT_EXPORT_METHOD(linkWithCredential:(NSString *) appDisplayName
                            provider:(NSString *) provider
                           authToken:(NSString *) authToken
                          authSecret:(NSString *) authSecret
                            resolver:(RCTPromiseResolveBlock) resolve
                            rejecter:(RCTPromiseRejectBlock) reject) {
    FIRApp *firApp = [RNFirebaseUtil getApp:appDisplayName];
    FIRAuthCredential *credential = [self getCredentialForProvider:provider token:authToken secret:authSecret];

    if (credential == nil) {
        return reject(@"auth/invalid-credential", @"The supplied auth credential is malformed, has expired or is not currently supported.", nil);
    }

    FIRUser *user = [FIRAuth authWithApp:firApp].currentUser;

    if (user) {
        [user linkWithCredential:credential completion:^(FIRUser *_Nullable _user, NSError *_Nullable error) {
            if (error) {
                [self promiseRejectAuthException:reject error:error];
            } else {
                [self promiseWithUser:resolve rejecter:reject user:_user];
            }
        }];
    } else {
        [self promiseNoUser:resolve rejecter:reject isError:YES];
    }
}

/**
 linkAndRetrieveDataWithCredential

 @param NSString provider
 @param NSString authToken
 @param NSString authSecret
 @param RCTPromiseResolveBlock resolve
 @param RCTPromiseRejectBlock reject
 @return
 */
RCT_EXPORT_METHOD(linkAndRetrieveDataWithCredential:(NSString *) appDisplayName
                                           provider:(NSString *) provider
                                          authToken:(NSString *) authToken
                                         authSecret:(NSString *) authSecret
                                           resolver:(RCTPromiseResolveBlock) resolve
                                           rejecter:(RCTPromiseRejectBlock) reject) {
    FIRApp *firApp = [RNFirebaseUtil getApp:appDisplayName];
    FIRAuthCredential *credential = [self getCredentialForProvider:provider token:authToken secret:authSecret];

    if (credential == nil) {
        return reject(@"auth/invalid-credential", @"The supplied auth credential is malformed, has expired or is not currently supported.", nil);
    }

    FIRUser *user = [FIRAuth authWithApp:firApp].currentUser;
    if (user) {
        [user linkAndRetrieveDataWithCredential:credential
                                     completion:^(FIRAuthDataResult * _Nullable authResult, NSError * _Nullable error) {
            if (error) {
                [self promiseRejectAuthException:reject error:error];
            } else {
                [self promiseWithAuthResult:resolve rejecter:reject authResult:authResult];
            }
        }];
    } else {
        [self promiseNoUser:resolve rejecter:reject isError:YES];
    }
}

/**
 unlink

 @param NSString provider
 @param NSString authToken
 @param NSString authSecret
 @param RCTPromiseResolveBlock resolve
 @param RCTPromiseRejectBlock reject
 @return
 */
RCT_EXPORT_METHOD(unlink:
    (NSString *) appDisplayName
            providerId:
            (NSString *) providerId
            resolver:
            (RCTPromiseResolveBlock) resolve
            rejecter:
            (RCTPromiseRejectBlock) reject) {
    FIRApp *firApp = [RNFirebaseUtil getApp:appDisplayName];
    FIRUser *user = [FIRAuth authWithApp:firApp].currentUser;

    if (user) {
        [user unlinkFromProvider:providerId completion:^(FIRUser *_Nullable _user, NSError *_Nullable error) {
            if (error) {
                [self promiseRejectAuthException:reject error:error];
            } else {
                [self reloadAndReturnUser:user resolver:resolve rejecter: reject];
            }
        }];
    } else {
        [self promiseNoUser:resolve rejecter:reject isError:YES];
    }
}

/**
 reauthenticateWithCredential

 @param NSString provider
 @param NSString authToken
 @param NSString authSecret
 @param RCTPromiseResolveBlock resolve
 @param RCTPromiseRejectBlock reject
 @return
 */
RCT_EXPORT_METHOD(reauthenticateWithCredential:(NSString *) appDisplayName
                                      provider:(NSString *) provider
                                     authToken:(NSString *) authToken
                                    authSecret:(NSString *) authSecret
                                      resolver:(RCTPromiseResolveBlock) resolve
                                      rejecter:(RCTPromiseRejectBlock) reject) {
    FIRApp *firApp = [RNFirebaseUtil getApp:appDisplayName];

    FIRAuthCredential *credential = [self getCredentialForProvider:provider token:authToken secret:authSecret];

    if (credential == nil) {
        return reject(@"auth/invalid-credential", @"The supplied auth credential is malformed, has expired or is not currently supported.", nil);
    }

    FIRUser *user = [FIRAuth authWithApp:firApp].currentUser;

    if (user) {
        [user reauthenticateWithCredential:credential completion:^(NSError *_Nullable error) {
            if (error) {
                [self promiseRejectAuthException:reject error:error];
            } else {
                FIRUser *userAfterAuth = [FIRAuth authWithApp:firApp].currentUser;
                [self promiseWithUser:resolve rejecter:reject user:userAfterAuth];
            }
        }];
    } else {
        [self promiseNoUser:resolve rejecter:reject isError:YES];
    }
}

/**
 reauthenticateAndRetrieveDataWithCredential
 
 @param NSString provider
 @param NSString authToken
 @param NSString authSecret
 @param RCTPromiseResolveBlock resolve
 @param RCTPromiseRejectBlock reject
 @return
 */
RCT_EXPORT_METHOD(reauthenticateAndRetrieveDataWithCredential:(NSString *) appDisplayName
                                                     provider:(NSString *) provider
                                                    authToken:(NSString *) authToken
                                                   authSecret:(NSString *) authSecret
                                                     resolver:(RCTPromiseResolveBlock) resolve
                                                     rejecter:(RCTPromiseRejectBlock) reject) {
    FIRApp *firApp = [RNFirebaseUtil getApp:appDisplayName];
    
    FIRAuthCredential *credential = [self getCredentialForProvider:provider token:authToken secret:authSecret];
    
    if (credential == nil) {
        return reject(@"auth/invalid-credential", @"The supplied auth credential is malformed, has expired or is not currently supported.", nil);
    }
    
    FIRUser *user = [FIRAuth authWithApp:firApp].currentUser;
    
    if (user) {
        [user reauthenticateAndRetrieveDataWithCredential:credential completion:^(FIRAuthDataResult * _Nullable authResult, NSError * _Nullable error) {
            if (error) {
                [self promiseRejectAuthException:reject error:error];
            } else {
                [self promiseWithAuthResult:resolve rejecter:reject authResult:authResult];
            }
        }];
    } else {
        [self promiseNoUser:resolve rejecter:reject isError:YES];
    }
}

/**
 fetchProvidersForEmail

 @param NSString email
 @param RCTPromiseResolveBlock resolve
 @param RCTPromiseRejectBlock reject
 @return
 */
RCT_EXPORT_METHOD(fetchProvidersForEmail:
    (NSString *) appDisplayName
            email:
            (NSString *) email
            resolver:
            (RCTPromiseResolveBlock) resolve
            rejecter:
            (RCTPromiseRejectBlock) reject) {
    FIRApp *firApp = [RNFirebaseUtil getApp:appDisplayName];

    [[FIRAuth authWithApp:firApp] fetchProvidersForEmail:email completion:^(NSArray<NSString *> *_Nullable providers, NSError *_Nullable error) {
        if (error) {
            [self promiseRejectAuthException:reject error:error];
        } else if (!providers) {
            NSMutableArray *emptyResponse = [[NSMutableArray alloc] init];
            resolve(emptyResponse);
        } else {
            resolve(providers);
        }
    }];
}

/**
 getCredentialForProvider

 @param provider string
 @param authToken string
 @param authTokenSecret string
 @return FIRAuthCredential
 */
- (FIRAuthCredential *)getCredentialForProvider:(NSString *)provider token:(NSString *)authToken secret:(NSString *)authTokenSecret {
    FIRAuthCredential *credential;

    if ([provider compare:@"twitter.com" options:NSCaseInsensitiveSearch] == NSOrderedSame) {
        credential = [FIRTwitterAuthProvider credentialWithToken:authToken secret:authTokenSecret];
    } else if ([provider compare:@"facebook.com" options:NSCaseInsensitiveSearch] == NSOrderedSame) {
        credential = [FIRFacebookAuthProvider credentialWithAccessToken:authToken];
    } else if ([provider compare:@"google.com" options:NSCaseInsensitiveSearch] == NSOrderedSame) {
        credential = [FIRGoogleAuthProvider credentialWithIDToken:authToken accessToken:authTokenSecret];
    } else if ([provider compare:@"password" options:NSCaseInsensitiveSearch] == NSOrderedSame) {
        credential = [FIREmailAuthProvider credentialWithEmail:authToken password:authTokenSecret];
    } else if ([provider compare:@"github.com" options:NSCaseInsensitiveSearch] == NSOrderedSame) {
        credential = [FIRGitHubAuthProvider credentialWithToken:authToken];
    } else if ([provider compare:@"phone" options:NSCaseInsensitiveSearch] == NSOrderedSame) {
        credential = [[FIRPhoneAuthProvider provider] credentialWithVerificationID:authToken verificationCode:authTokenSecret];
    } else if ([provider compare:@"oauth" options:NSCaseInsensitiveSearch] == NSOrderedSame) {
        credential = [FIROAuthProvider credentialWithProviderID:@"oauth" IDToken:authToken accessToken:authTokenSecret];
    } else {
        NSLog(@"Provider not yet handled: %@", provider);
    }

    return credential;
}

/**
 setLanguageCode

 @param NSString code
 @return
 */
RCT_EXPORT_METHOD(setLanguageCode:
    (NSString *) appDisplayName
            code:
            (NSString *) code) {
    FIRApp *firApp = [RNFirebaseUtil getApp:appDisplayName];

    [FIRAuth authWithApp:firApp].languageCode = code;
}

/**
 useDeviceLanguage

 @param NSString code
 @return
 */
RCT_EXPORT_METHOD(useDeviceLanguage:(NSString *) appDisplayName) {
    FIRApp *firApp = [RNFirebaseUtil getApp:appDisplayName];

    [[FIRAuth authWithApp:firApp] useAppLanguage];
}

RCT_EXPORT_METHOD(verifyPasswordResetCode:(NSString *) appDisplayName
                  code:(NSString *)code
                  resolver:(RCTPromiseResolveBlock)resolve
                  rejecter:(RCTPromiseRejectBlock)reject) {
    FIRApp *firApp = [RNFirebaseUtil getApp:appDisplayName];
    [[FIRAuth authWithApp:firApp] verifyPasswordResetCode:code completion:^(NSString * _Nullable email, NSError * _Nullable error) {
        if (error) {
            [self promiseRejectAuthException:reject error:error];
        } else {
            resolve(email);
        }
    }];
}

// This is here to protect against bugs in the iOS SDK which don't
// correctly refresh the user object when performing certain operations
- (void)reloadAndReturnUser:(FIRUser *)user
                   resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject {
    [user reloadWithCompletion:^(NSError * _Nullable error) {
        if (error) {
            [self promiseRejectAuthException:reject error:error];
        } else {
            [self promiseWithUser:resolve rejecter:reject user:user];
        }
    }];
}

/**
 Resolve or reject a promise based on isError value

 @param resolve RCTPromiseResolveBlock
 @param reject RCTPromiseRejectBlock
 @param isError BOOL
 */
- (void)promiseNoUser:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject isError:(BOOL)isError {
    if (isError) {
        reject(@"auth/no-current-user", @"No user currently signed in.", nil);
    } else {
        resolve([NSNull null]);
    }
}

/**
 Reject a promise with an auth exception

 @param reject RCTPromiseRejectBlock
 @param error NSError
 */
- (void)promiseRejectAuthException:(RCTPromiseRejectBlock)reject error:(NSError *)error {
    NSDictionary * jsError = [self getJSError:(error)];
    reject([jsError valueForKey:@"code"], [jsError valueForKey:@"message"], error);
}

/**
 Reject a promise with an auth exception

 @param error NSError
 */
- (NSDictionary *)getJSError:(NSError *)error {
    NSString *code = @"auth/unknown";
    NSString *message = [error localizedDescription];
    NSString *nativeErrorMessage = [error localizedDescription];

    switch (error.code) {
        case FIRAuthErrorCodeInvalidCustomToken:
            code = @"auth/invalid-custom-token";
            message = @"The custom token format is incorrect. Please check the documentation.";
            break;
        case FIRAuthErrorCodeCustomTokenMismatch:
            code = @"auth/custom-token-mismatch";
            message = @"The custom token corresponds to a different audience.";
            break;
        case FIRAuthErrorCodeInvalidCredential:
            code = @"auth/invalid-credential";
            message = @"The supplied auth credential is malformed or has expired.";
            break;
        case FIRAuthErrorCodeInvalidEmail:
            code = @"auth/invalid-email";
            message = @"The email address is badly formatted.";
            break;
        case FIRAuthErrorCodeWrongPassword:
            code = @"auth/wrong-password";
            message = @"The password is invalid or the user does not have a password.";
            break;
        case FIRAuthErrorCodeUserMismatch:
            code = @"auth/user-mismatch";
            message = @"The supplied credentials do not correspond to the previously signed in user.";
            break;
        case FIRAuthErrorCodeRequiresRecentLogin:
            code = @"auth/requires-recent-login";
            message = @"This operation is sensitive and requires recent authentication. Log in again before retrying this request.";
            break;
        case FIRAuthErrorCodeAccountExistsWithDifferentCredential:
            code = @"auth/account-exists-with-different-credential";
            message = @"An account already exists with the same email address but different sign-in credentials. Sign in using a provider associated with this email address.";
            break;
        case FIRAuthErrorCodeEmailAlreadyInUse:
            code = @"auth/email-already-in-use";
            message = @"The email address is already in use by another account.";
            break;
        case FIRAuthErrorCodeCredentialAlreadyInUse:
            code = @"auth/credential-already-in-use";
            message = @"This credential is already associated with a different user account.";
            break;
        case FIRAuthErrorCodeUserDisabled:
            code = @"auth/user-disabled";
            message = @"The user account has been disabled by an administrator.";
            break;
        case FIRAuthErrorCodeUserTokenExpired:
            code = @"auth/user-token-expired";
            message = @"The user's credential is no longer valid. The user must sign in again.";
            break;
        case FIRAuthErrorCodeUserNotFound:
            code = @"auth/user-not-found";
            message = @"There is no user record corresponding to this identifier. The user may have been deleted.";
            break;
        case FIRAuthErrorCodeInvalidUserToken:
            code = @"auth/invalid-user-token";
            message = @"The user's credential is no longer valid. The user must sign in again.";
            break;
        case FIRAuthErrorCodeWeakPassword:
            code = @"auth/weak-password";
            message = @"The given password is invalid.";
            break;
        case FIRAuthErrorCodeOperationNotAllowed:
            code = @"auth/operation-not-allowed";
            message = @"This operation is not allowed. You must enable this service in the console.";
            break;
        case FIRAuthErrorCodeNetworkError:
            code = @"auth/network-error";
            message = @"A network error has occurred, please try again.";
            break;
        case FIRAuthErrorCodeInternalError:
            code = @"auth/internal-error";
            message = @"An internal error has occurred, please try again.";
            break;

            // unsure of the below codes so leaving them as the default error message
        case FIRAuthErrorCodeTooManyRequests:
            code = @"auth/too-many-requests";
            break;
        case FIRAuthErrorCodeProviderAlreadyLinked:
            code = @"auth/provider-already-linked";
            break;
        case FIRAuthErrorCodeNoSuchProvider:
            code = @"auth/no-such-provider";
            break;
        case FIRAuthErrorCodeInvalidAPIKey:
            code = @"auth/invalid-api-key";
            break;
        case FIRAuthErrorCodeAppNotAuthorized:
            code = @"auth/app-not-authorised";
            break;
        case FIRAuthErrorCodeExpiredActionCode:
            code = @"auth/expired-action-code";
            break;
        case FIRAuthErrorCodeInvalidMessagePayload:
            code = @"auth/invalid-message-payload";
            break;
        case FIRAuthErrorCodeInvalidSender:
            code = @"auth/invalid-sender";
            break;
        case FIRAuthErrorCodeInvalidRecipientEmail:
            code = @"auth/invalid-recipient-email";
            break;
        case FIRAuthErrorCodeKeychainError:
            code = @"auth/keychain-error";
            break;
        default:
            break;
    }

    return @{
             @"code": code,
             @"message": message,
             @"nativeErrorMessage": nativeErrorMessage,
           };
}


/**
 Resolve or reject a promise based on FIRUser value existance

 @param resolve RCTPromiseResolveBlock
 @param reject RCTPromiseRejectBlock
 @param user FIRUser
 */
- (void)promiseWithUser:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject user:(FIRUser *)user {
    if (user) {
        NSDictionary *userDict = [self firebaseUserToDict:user];
        resolve(userDict);
    } else {
        [self promiseNoUser:resolve rejecter:reject isError:YES];
    }

}

/**
 Resolve or reject a promise based on FIRAuthResult value existance

 @param resolve RCTPromiseResolveBlock
 @param reject RCTPromiseRejectBlock
 @param authResult FIRAuthDataResult
 */
- (void)promiseWithAuthResult:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject authResult:(FIRAuthDataResult *)authResult {
    if (authResult && authResult.user) {
        NSDictionary *userDict = [self firebaseUserToDict:authResult.user];
        NSDictionary *authResultDict = @{
                                         @"additionalUserInfo": authResult.additionalUserInfo ? @{
                                                 @"isNewUser": @(authResult.additionalUserInfo.isNewUser),
                                                 @"profile": authResult.additionalUserInfo.profile ? authResult.additionalUserInfo.profile : [NSNull null],
                                                 @"providerId": authResult.additionalUserInfo.providerID ? authResult.additionalUserInfo.providerID : [NSNull null],
                                                 @"username": authResult.additionalUserInfo.username ? authResult.additionalUserInfo.username : [NSNull null]
                                         } : [NSNull null],
                                         @"user": userDict
                                       };
        resolve(authResultDict);
    } else {
        [self promiseNoUser:resolve rejecter:reject isError:YES];
    }

}

/**
 Converts an array of FIRUserInfo instances into the correct format to match the web sdk

 @param providerData FIRUser.providerData
 @return NSArray
 */
- (NSArray <NSObject *> *)convertProviderData:(NSArray <id <FIRUserInfo>> *)providerData {
    NSMutableArray *output = [NSMutableArray array];

    for (id <FIRUserInfo> userInfo in providerData) {
        NSMutableDictionary *pData = [NSMutableDictionary dictionary];

        if (userInfo.providerID != nil) {
            [pData setValue:userInfo.providerID forKey:@"providerId"];
        }

        if (userInfo.uid != nil) {
            [pData setValue:userInfo.uid forKey:@"uid"];
        }

        if (userInfo.displayName != nil) {
            [pData setValue:userInfo.displayName forKey:@"displayName"];
        }

        if (userInfo.photoURL != nil) {
            [pData setValue:[userInfo.photoURL absoluteString] forKey:@"photoURL"];
        }

        if (userInfo.email != nil) {
            [pData setValue:userInfo.email forKey:@"email"];
        }

        if (userInfo.phoneNumber != nil) {
            [pData setValue:userInfo.phoneNumber forKey:@"phoneNumber"];
        }

        [output addObject:pData];
    }

    return output;
}

/**
 * React native constant exports - exports native firebase apps mainly
 * @return NSDictionary
 */
- (NSDictionary *)constantsToExport {
    NSMutableDictionary *constants = [NSMutableDictionary new];
    NSDictionary *firApps = [FIRApp allApps];
    NSMutableDictionary *appLanguage = [NSMutableDictionary new];

    for (id key in firApps) {
        FIRApp *firApp = firApps[key];

        appLanguage[firApp.name] = [FIRAuth authWithApp:firApp].languageCode;
    }

    constants[@"APP_LANGUAGE"] = appLanguage;
    return constants;
}

/**
 Converts a FIRUser instance into a dictionary to send via RNBridge

 @param user FIRUser
 @return NSDictionary
 */
- (NSDictionary *)firebaseUserToDict:(FIRUser *)user {
    return @{
             @"displayName": user.displayName ? user.displayName : [NSNull null],
             @"email": user.email ? user.email : [NSNull null],
             @"emailVerified": @(user.emailVerified),
             @"isAnonymous": @(user.anonymous),
             @"metadata": @{
                     @"creationTime": user.metadata.creationDate ? @(round([user.metadata.creationDate timeIntervalSince1970] * 1000.0)): [NSNull null],
                     @"lastSignInTime": user.metadata.lastSignInDate ? @(round([user.metadata.lastSignInDate timeIntervalSince1970] * 1000.0)) : [NSNull null],
             },
             @"phoneNumber": user.phoneNumber ? user.phoneNumber : [NSNull null],
             @"photoURL": user.photoURL ? [user.photoURL absoluteString] : [NSNull null],
             @"providerData": [self convertProviderData:user.providerData],
             @"providerId": [user.providerID lowercaseString],
             @"refreshToken": user.refreshToken,
             @"uid": user.uid
            };
}

- (FIRActionCodeSettings *)buildActionCodeSettings:(NSDictionary *)actionCodeSettings {
    FIRActionCodeSettings *settings = [[FIRActionCodeSettings alloc] init];
    NSDictionary *android = actionCodeSettings[@"android"];
    BOOL handleCodeInApp = actionCodeSettings[@"handleCodeInApp"];
    NSDictionary *ios = actionCodeSettings[@"iOS"];
    NSString *url = actionCodeSettings[@"url"];
    if (android) {
        BOOL installApp = android[@"installApp"];
        NSString *minimumVersion = android[@"minimumVersion"];
        NSString *packageName = android[@"packageName"];
        [settings setAndroidPackageName:packageName installIfNotAvailable:installApp minimumVersion:minimumVersion];
    }
    if (handleCodeInApp) {
        [settings setHandleCodeInApp:handleCodeInApp];
    }
    if (ios && ios[@"bundleId"]) {
        [settings setIOSBundleID:ios[@"bundleId"]];
    }
    if (url) {
        [settings setURL:[NSURL URLWithString:url]];
    }
    return settings;
}

- (NSArray<NSString *> *)supportedEvents {
    return @[AUTH_STATE_CHANGED_EVENT, AUTH_ID_TOKEN_CHANGED_EVENT, PHONE_AUTH_STATE_CHANGED_EVENT];
}

+ (BOOL)requiresMainQueueSetup
{
    return YES;
}

@end

#else
@implementation RNFirebaseAuth
@end
#endif