QueueITWaitingRoomProvider.m

#import "QueueITWaitingRoomProvider.h"
#import "IOSUtils.h"
#import "QueueITApiClient.h"
#import "QueueTryPassResult.h"
#import "QueueITReachability.h"

// TODO: Include all the method calls here 
@interface QueueITWaitingRoomProvider()
@property (nonatomic) QueueITReachability *internetReachability;
@property NSString* customerId;
@property NSString* eventOrAliasId;
@property NSString* layoutName;
@property NSString* language;
@property BOOL requestInProgress;
@property int deltaSec;


@end

@implementation QueueITWaitingRoomProvider

static int MAX_RETRY_SEC = 10;
static int INITIAL_WAIT_RETRY_SEC = 1;

-(instancetype _Nonnull)initWithCustomerId:(NSString* _Nonnull)customerId
                       eventOrAliasId:(NSString* _Nonnull)eventOrAliasId
                           layoutName:(NSString* _Nullable)layoutName
                    language:(NSString* _Nullable)language {
    
    if(self = [super init]) {
        self.customerId = customerId;
        self.eventOrAliasId = eventOrAliasId;
        self.layoutName = layoutName;
        self.language = language;
        self.deltaSec = INITIAL_WAIT_RETRY_SEC;
        self.internetReachability = [QueueITReachability reachabilityForInternetConnection];
    }
    
    return self;
}
 
-(BOOL) TryPass: (NSError**)error {
    return [self tryEnqueue:nil enqueueKey:nil error:error];
}

-(BOOL) TryPassWithEnqueueToken: (NSString*)enqueueToken error:(NSError *__autoreleasing *)error {
    return [self tryEnqueue:enqueueToken enqueueKey:nil error:error];
}

-(BOOL) TryPassWithEnqueueKey: (NSString*)enqueueKey error:(NSError *__autoreleasing *)error {
   return [self tryEnqueue:nil enqueueKey:enqueueKey error:error];
}


-(BOOL)tryEnqueue:(NSString*)enqueueToken
       enqueueKey:(NSString*)enqueueKey
            error:(NSError**)error
{
    if(![self checkConnection:error]) {
        return NO;
    }
    
    if(self.requestInProgress) {
        *error = [NSError errorWithDomain:@"QueueITRuntimeException" code:RequestAlreadyInProgress userInfo:nil];
        return NO;
    }
    
    [IOSUtils getUserAgent:^(NSString * userAgent) {
        [self tryEnqueueWithUserAgent:userAgent enqueueToken:enqueueToken enqueueKey:enqueueKey error:error];
    }];
    
    return YES;
}

-(void)tryEnqueueWithUserAgent:(NSString*)secretAgent
                  enqueueToken:(NSString*)enqueueToken
                    enqueueKey:(NSString*)enqueueKey
                    error:(NSError**)error
{
    NSString* userId = [IOSUtils getUserId];
    NSString* userAgent = [NSString stringWithFormat:@"%@;%@", secretAgent, [IOSUtils getLibraryVersion]];
    NSString* sdkVersion = [IOSUtils getSdkVersion];
    
    QueueITApiClient* apiClient = [QueueITApiClient getInstance];
    [apiClient enqueue:self.customerId
               eventOrAliasId:self.eventOrAliasId
               userId:userId
               userAgent:userAgent
               sdkVersion:sdkVersion
               layoutName:self.layoutName
               language:self.language
               enqueueToken:enqueueToken
               enqueueKey:enqueueKey
               success:^(QueueStatus *queueStatus)
{
        if (queueStatus == NULL) {
            [self enqueueRetryMonitor:enqueueToken enqueueKey:enqueueKey error:error];
            return;
        }
        
        [self handleAppEnqueueResponse: queueStatus.queueId
                              queueURL:queueStatus.queueUrlString
                        eventTargetURL:queueStatus.eventTargetUrl
                          queueItToken:queueStatus.queueitToken];
        
        self.requestInProgress = NO;
    }
        failure:^(NSError *error, NSString* errorMessage)
     {
        if (error.code >= 400 && error.code < 500)
        {
            [self.delegate waitingRoomProvider:self notifyProviderFailure:errorMessage errorCode:error.code];
        }
        else
        {
            [self enqueueRetryMonitor:enqueueToken enqueueKey:enqueueKey error:&error];
        }
    }];
}

-(void)handleAppEnqueueResponse:(NSString*) queueId
                       queueURL:(NSString*) queueURL
                 eventTargetURL:(NSString*) targetURL
                   queueItToken:(NSString*) token {

    bool isPassedThrough = ![self isNullOrEmpty:token];
    
    NSString* redirectType = [self getRedirectTypeFromToken:token];
    
    QueueTryPassResult* queueTryPassResult =  [[QueueTryPassResult alloc]
                                              initWithQueueUrl:queueURL
                                              targetUrl:targetURL
                                              redirectType:redirectType
                                              isPassedThrough:isPassedThrough
                                              queueToken:token];
    
    [self.delegate waitingRoomProvider:self notifyProviderSuccess:queueTryPassResult];
}

-(void)enqueueRetryMonitor:(NSString*)enqueueToken
                enqueueKey:(NSString*)enqueueKey
                error:(NSError**)error
{
    if (self.deltaSec < MAX_RETRY_SEC)
    {
        [self tryEnqueue:enqueueToken enqueueKey:enqueueKey error:error];
        
        [NSThread sleepForTimeInterval:self.deltaSec];
        self.deltaSec = self.deltaSec * 2;
    }
    else
    {
        self.deltaSec = INITIAL_WAIT_RETRY_SEC;
        self.requestInProgress = NO;
        [self.delegate waitingRoomProvider:self notifyProviderFailure:@"Error! Queue is unavailable." errorCode:3];
    }
}

-(BOOL)checkConnection:(NSError **)error
{
    int count = 0;
    while (count < 5)
    {
        NetworkStatus netStatus = [self.internetReachability currentReachabilityStatus];
        if (netStatus == NotReachable)
        {
            [NSThread sleepForTimeInterval:1.0f];
            count++;
        }
        else
        {
            return YES;
        }
    }
    *error = [NSError errorWithDomain:@"QueueITRuntimeException" code:NetworkUnavailable userInfo:nil];
    return NO;
}

-(BOOL)IsRequestInProgress {
    return self.requestInProgress;
}

-(BOOL)isNullOrEmpty:(NSString*)queueToken {
    bool isNull = queueToken == nil || queueToken == (id)[NSNull null];
    bool isEmpty = isNull || [queueToken length] == 0;
    
    return isNull && isEmpty;
}

-(NSString*) getRedirectTypeFromToken: (NSString*) queueToken {
    
    if([self isNullOrEmpty:queueToken])
    {
        return @"queue";
    }
    
    NSString *searchedString = queueToken;
    NSRange   searchedRange = NSMakeRange(0, [searchedString length]);
    NSString *pattern = @"\\~rt_(.*?)\\~";
    NSError  *error = nil;

    NSRegularExpression* regex = [NSRegularExpression regularExpressionWithPattern:pattern options:0 error:&error];
    NSTextCheckingResult *match = [regex firstMatchInString:searchedString options:0 range: searchedRange];
    return [searchedString substringWithRange:[match rangeAtIndex:1]];
}

@end