#import "NOEKabaModule.h"
#import "AppParameters.h"
#import "LegicIDConnectManager.h"
#import "LegicIDConnectFactory.h"
#import "Legic_profile_ids.h"
#import "Legic_property.h"
#import "Legic_property_keys.h"
#import "LegicConnector.h"
#import "Legic_wallet_application.h"
#import "LegicBlePluginTypes.h"
#import "FileSelectionModes.h"
#import "NOEBluetoothManager.h"
#import "NOERegisterDelegate.h"
#import "BleDataHandler.h"
#import <asl.h>


@implementation NOEKabaModule

RCT_EXPORT_MODULE(Kaba);

- (NSArray<NSString *> *)supportedEvents {
    return @[@"NOTIF_DEBUG", @"SYNC_UPDATE", @"STORE_DATA", @"DOOR_UNLOCKED", @"DOOR_UNLOCK_FAILED"];
}

/**
 * initialise Manager
 */
RCT_REMAP_METHOD(initialiseManager,
                 initialiseManagerResolver:(RCTPromiseResolveBlock)resolve
                 rejecter:(RCTPromiseRejectBlock)reject) {

    /**
     * SDK event listeners
     */
    [[NSNotificationCenter defaultCenter] addObserver:self
                                             selector:@selector(handleDisplayContentNotification:)
                                                 name: NOTIFICATION_DISPLAY_CONTENT
                                               object:nil];
    [[NSNotificationCenter defaultCenter] addObserver:self
                                             selector:@selector(handleInitalSyncCompleteNotification:)
                                                 name:NOTIFICATION_INITIAL_SYNCHRONIZE_COMPLETE
                                               object:nil];
    [[NSNotificationCenter defaultCenter] addObserver:self
                                             selector:@selector(handleFinalSyncCompleteNotification:)
                                                 name:NOTIFICATION_FINAL_SYNCHRONIZE_COMPLETE
                                               object:nil];
    [[NSNotificationCenter defaultCenter] addObserver:self
                                             selector:@selector(handleSyncFailedNotification:)
                                                 name:NOTIFICATION_SYNCHRONIZE_FAILED
                                               object:nil];
    [[NSNotificationCenter defaultCenter] addObserver:self
                                             selector:@selector(handleCardsUpdatedNotification:)
                                                 name:NOTIFICATION_CARDS_UPDATED
                                               object:nil];
    [[NSNotificationCenter defaultCenter] addObserver:self
                                             selector:@selector(handleStoreDataCorruptedNotification:)
                                                 name:NOTIFICATION_STORE_DATA_CORRUPTED
                                               object:nil];
    /**
     * LegicConnector initialise
     */
    long walletId = 46773385;
    LegicProfileIds* bleProfile = [[LegicProfileIds alloc] initWithProfileId:PROFILEID_BLE];
    NSArray* profileIds = [NSArray arrayWithObjects:
                           bleProfile,
                           nil];
    @try {
        dispatch_async(dispatch_get_main_queue(), ^{
            self.manager = [[LegicConnector instance] initialise: walletId profileIds:profileIds];

            [self.manager setServerURL:@"https://api.legicconnect.com/connect"];
            [self.manager setUsername:@"MobNoetic LabTechUser"];
            [self.manager setPassword:@"QwIvT7bJgZltlL0YajqVw5Uh/78lad5tmZlEvqF+vio="];

            [self.manager setLoggingMode:ASL_LEVEL_NOTICE]; // Set to INFO or DEBUG for release so user cannot view SDK logs.
            [self.manager setConfigParam:FILE_SELECTION_MODE_PARAM_NAME Value:FILE_SELECTION_MODE_VALUE_PRESELECTED_FILE];

            NOEBluetoothManager *bluetoothManager = [[NOEBluetoothManager alloc]init];
            self.bluetoothManager = bluetoothManager;

            resolve([self.manager getSDKVersion]);
        });
    }
    @catch (NSException *exception) {
        NSLog(@"##KABALOG initialiseManager error %@",exception.reason);
        reject(exception.reason, exception.reason, nil);
    }

};

/**
 * Check bluetooth status
 * Not used !!!
 */
RCT_REMAP_METHOD(isBluetoothEnabled,
                 isBluetoothEnabledResolver:(RCTPromiseResolveBlock)resolve
                 rejecter:(RCTPromiseRejectBlock)reject) {

    BOOL isBluetoothEnabled = [[_bluetoothManager getState]isEqualToString:@"on"];
    resolve(@(isBluetoothEnabled));
};


/**
 * Check user registration
 */
RCT_REMAP_METHOD(isUserRegistered,
                 isUserRegisteredResolver:(RCTPromiseResolveBlock)resolve
                 rejecter:(RCTPromiseRejectBlock)reject) {

    BOOL isRegistered = [_manager isUserRegistered];
    resolve(@(isRegistered));
};

- (void)sendDebug:(NSString *)message {
    [self sendEventWithName:@"NOTIF_DEBUG" body:@"Hello"];
}

/**
 *  Registration
 */
RCT_REMAP_METHOD(register,
                 userID:(NSString *)userID
                 token:(NSString *)token
                 registerResolver:(RCTPromiseResolveBlock)resolve
                 rejecter:(RCTPromiseRejectBlock)reject) {

    @try {
        _resolver = resolve;
        _rejecter = reject;
        _token = token;
        dispatch_async(dispatch_get_main_queue(), ^{
            NSArray *info = nil;
            LegicConfirmationMethods* confirmationMethod = [[LegicConfirmationMethods alloc] initWithMethod:NONE];
            [self.manager registerWallet:self Info:info PublicSEID:userID ConfirmationMethod:confirmationMethod];
            NSLog(@"##KABALOG registerWallet done");
        });
    }
    @catch (NSException *exception) {
        NSLog(@"##KABALOG dispatch_async error");
        reject(exception.reason, exception.reason, nil);
    }
}

/**
 *  Complete Registration
 */
RCT_REMAP_METHOD(completeRegister,
                 token:(NSString *)token
                 completeRegisterResolver:(RCTPromiseResolveBlock)resolve
                 rejecter:(RCTPromiseRejectBlock)reject)
{
    _resolver = resolve;
    _rejecter = reject;
    _token = token;
    @try {
        [[self.manager getPersistentStore]saveUserRegistered:true];
        [_manager completeRegistration:self WalletToken:token];
    }
    @catch (NSException *exception) {
        reject(exception.reason, exception.reason, nil);
    }
}

/**
 *  Unregister
 */
RCT_REMAP_METHOD(unregister,
                 completeRegisterResolver:(RCTPromiseResolveBlock)resolve
                 rejecter:(RCTPromiseRejectBlock)reject)
{
    _resolver = resolve;
    _rejecter = reject;
    @try {
        [_manager unregisterWallet:self];
    }
    @catch (NSException *exception) {
        reject(exception.reason, exception.reason, nil);
    }
}

/**
 *  Synchronise
 */
RCT_REMAP_METHOD(synchronise,
                 synchroniseResolver:(RCTPromiseResolveBlock)resolve
                 rejecter:(RCTPromiseRejectBlock)reject) {
    @try {
        [_manager synchronize];
        resolve(@"Starting to sync.");
        /**
         * Dispatch sync started event
         * @ToDo: check legic sdk event and replace this ??
         */
        [self handleSyncStartedNotification];
    }
    @catch (NSException *exception) {
        reject(exception.reason, exception.reason, nil);
    }
}

/**
 * Sync Device
 */
RCT_REMAP_METHOD(syncDevice,
                 syncDeviceResolver:(RCTPromiseResolveBlock)resolve
                 rejecter:(RCTPromiseRejectBlock)reject) {
    @try {
        [_manager syncDevice];
        resolve(@"Starting to sync device.");
        NSLog(@"##KABALOG syncDevice");;
    }
    @catch (NSException *exception) {
        reject(exception.reason, exception.reason, nil);
    }
}

/**
 *  Get all Key Card/Wallet Applications
 */
RCT_REMAP_METHOD(getKeyCards,
                 getKeyCardsResolver:(RCTPromiseResolveBlock)resolve
                 rejecter:(RCTPromiseRejectBlock)reject)
{
    @try {
        NSError *error = nil;
        NSArray *keyCardsData = [self getAllWalletApplications];

        // JSON conversion
        NSData *jsonData = [NSJSONSerialization dataWithJSONObject:keyCardsData options:NSJSONWritingPrettyPrinted error:&error];
        NSString *jsonString = [[NSString alloc] initWithData:jsonData encoding:NSUTF8StringEncoding];
        resolve(jsonString);
    }
    @catch (NSException *exception) {
        reject(exception.reason, exception.reason, nil);
    }
}

/**
 *  Activate single Key Card / Wallet Application
 */
RCT_REMAP_METHOD(activateCard,
                 cardIndex:(nonnull NSNumber *)cardIndex
                 activateCardResolver:(RCTPromiseResolveBlock)resolver
                 rejecter:(RCTPromiseRejectBlock)reject)
{
    @try {
        [self cardActivation:cardIndex action:@"activate" activationResolver:resolver rejecter:reject];
    }
    @catch (NSException *exception) {
        reject(@"oh error", @"oh error", nil);
    }
}

/**
 *  Deactivate single Key Card / Wallet Application
 */
RCT_REMAP_METHOD(deactivateCard,
                 cardIndex:(nonnull NSNumber *)cardIndex
                 deactivateCardResolver:(RCTPromiseResolveBlock)resolver
                 rejecter:(RCTPromiseRejectBlock)reject)
{
    [self cardActivation:cardIndex action:@"deactivate" activationResolver:resolver rejecter:reject];
}

/**
 *  Deactivate all Key Cards / Wallet Applications
 */
RCT_REMAP_METHOD(deactivateAllCards,
                 deactivateAllCardsResolver:(RCTPromiseResolveBlock)resolver
                 rejecter:(RCTPromiseRejectBlock)reject)
{
    NSError *error = [_manager deactivateAllCards];
    if(error == nil)
    {
        resolver(@"All card deactivated");
    }
    else
    {
        reject([error localizedDescription], [error localizedDescription], nil);
    }
}

/**
 *  Close wallet / Finalise / Finish
 */
RCT_REMAP_METHOD(finaliseManager,
                 closeWalletResolver:(RCTPromiseResolveBlock)resolver
                 rejecter:(RCTPromiseRejectBlock)reject)
{
    [[LegicConnector instance] finish:resolver rejecter:reject];
}

/**
 *  Activate or deactivate single single Key Card / Wallet Application
 */
-(void)cardActivation:(NSNumber *)cardIndex
               action:(NSString *)action
   activationResolver:(RCTPromiseResolveBlock)resolver
             rejecter:(RCTPromiseRejectBlock)reject
{
    NSArray *allWallets = [self getAllWalletApplications];
    if([cardIndex integerValue] < [allWallets count])
    {
        id keyCardData = [allWallets objectAtIndex:[cardIndex integerValue]];
        NSString *status = keyCardData[@"appStatus"];
        if([status  isEqual: @"deployed"]){
            NSString *walletAppId = keyCardData[@"walletAppId"];
            NSNumber *qualifier = keyCardData[@"qualifier"];
            NSError *outcomeError;
            if([action isEqual:@"activate"]){
                outcomeError = [self.manager activateCard:walletAppId Qualifier:qualifier];
            }
            else
            {
               outcomeError = [self.manager deactivateCard:walletAppId Qualifier:qualifier];
            }
            if(outcomeError == nil)
            {
                resolver(([action isEqual:@"activate"]) ? @"Card activated" : @"Card deactivated");
            }
            else{
                reject([outcomeError localizedDescription], [outcomeError localizedDescription], nil);
            }
        }
        else{
            reject(@"Cannot activate/deactivate card that is not in state deployed.", @"Cannot activate/deactivate card that is not in state deployed.", nil);
        }
    }
    else
    {
        reject(@"Cannot activate/deactivate non-existant card index.", @"Cannot activate/deactivate non-existant card index.", nil);
    }
}

/**
 *  Get wallet applications form legic manager
 */
-(NSArray *)getAllWalletApplications
{
    // Mutable data holders
    NSArray *keyCards = [self.manager getAllCards];
    NSMutableArray *keyCardsData = [NSMutableArray array];

    for(LegicWalletApplication* application in keyCards)
    {
        /**
         * @ToDo: rewrite this section with proper json object generator
         */
        NSString* appStatus = [[application getAppStatus] getStatusString];
        NSString* walletAppId = [application getWalletAppId];
        NSNumber* qualifier = [application getQualifier];
        NSArray* images = [[application getMetadata] getImages];
        NSString* parentId = [application getParentId];
        NSString* metadataVersion = [application getMetadataVersion];
        NSString* techName = [[application getTechnologyName] getTechnologyNameString];
        NSString* SEType = [[application getSEType] getSETypeString];

        NSMutableDictionary *keyCardData = [NSMutableDictionary dictionary];
        [keyCardData setObject:(appStatus) ? appStatus : @"" forKey: @"appStatus"];
        [keyCardData setObject:(walletAppId) ? walletAppId : @"" forKey: @"walletAppId"];
        [keyCardData setObject:(qualifier) ? qualifier : @"" forKey: @"qualifier"];
        [keyCardData setObject:(images) ? images : @"" forKey: @"images"]; // replace with empty array
        [keyCardData setObject:(metadataVersion) ? metadataVersion : @"" forKey: @"metadataVersion"];
        [keyCardData setObject:(techName) ? techName : @"" forKey: @"techName"];
        [keyCardData setObject:(SEType) ? SEType : @"" forKey: @"SEType"];
        [keyCardData setObject:(parentId) ? parentId : @"" forKey: @"parentId"];

        // Metadata
        LegicWalletMetadata *metadata = [application getMetadata];
        if(metadata){
            NSString* name              = [metadata getName];
            NSString* companyName       = [metadata getCompanyName];
            // NSData* iconData            = [metadata getIconData]; // for now we don't need this & NSData conversion not possible with this method
            NSString* validFromDate     = [metadata getValidFromDate];
            NSString* validToDate       = [metadata getValidToDate];
            NSString* category          = [metadata getCategory];
            NSArray* metaImages         = [metadata getImages];
            NSString* remarks           = [metadata getRemarks];
            NSString* creatorUserName   = [metadata getCreatorUserName];
            NSNumber* creatorTimestamp  = [metadata getCreatorTimestamp];
            NSString* modifierUserName  = [metadata getModifierUserName];
            NSNumber* modifierTimestamp = [metadata getModifierTimestamp];

            NSMutableDictionary *keyCardMetaData = [NSMutableDictionary dictionary];
            [keyCardMetaData setObject:(name) ? name : @"" forKey: @"name"];
            [keyCardMetaData setObject:(companyName) ? companyName : @"" forKey: @"companyName"];
            //[keyCardMetaData setObject:(iconData) ? iconData : @"" forKey: @"iconData"];
            [keyCardMetaData setObject:(validFromDate) ? validFromDate : @"" forKey: @"validFromDate"];
            [keyCardMetaData setObject:(validToDate) ? validToDate : @"" forKey: @"validToDate"];
            [keyCardMetaData setObject:(category) ? category : @"" forKey: @"category"];
            [keyCardMetaData setObject:(metaImages) ? metaImages : @"" forKey: @"images"]; // replace with empty array
            [keyCardMetaData setObject:(remarks) ? remarks : @"" forKey: @"remarks"];
            [keyCardMetaData setObject:(creatorUserName) ? creatorUserName : @"" forKey: @"creatorUserName"];
            [keyCardMetaData setObject:(creatorTimestamp) ? creatorTimestamp : @"" forKey: @"creatorTimestamp"];
            [keyCardMetaData setObject:(modifierUserName) ? modifierUserName : @"" forKey: @"modifierUserName"];
            [keyCardMetaData setObject:(modifierTimestamp) ? modifierTimestamp : @"" forKey: @"modifierTimestamp"];

            NSDictionary *customParams = [metadata getCustomParameters];
            NSMutableDictionary *keyCardMetaDataCustomParams = [NSMutableDictionary dictionary];

            for(NSString *key in [customParams allKeys])
            {
                [keyCardMetaDataCustomParams setObject:[[customParams objectForKey:key]objectAtIndex:1] forKey:[key lowercaseString]];
            }
            // Set custom params to meta NSdic.
            [keyCardMetaData setObject:keyCardMetaDataCustomParams forKey: @"customParameters"];

            // Set meta data to main NSdic.
            [keyCardData setObject:keyCardMetaData forKey: @"metadata"];

            // Push to main keysData NSArray
            [keyCardsData addObject:keyCardData];
        }
    }
    return keyCardsData;
}

/**
 * SDK delegate callbacks
 */
-(void)success:(BOOL)alreadyRegistered
{
    NSString* registered = @"Not Already Registered.";
    if(alreadyRegistered)
    {
        NSLog(@"##KABALOG Already Registered");
        registered = @"Already Registered.";
    }
    else {
        NSLog(@"##KABALOG Not Already Registered");
    }
    self.resolver(self.token);
}

-(void)fail:(LegicStatus *)status
{
    self.rejecter([status getDescription], [status getDescription], nil);
    NSLog(@"##KABALOG Registere error %@", [status getDescription]);
    //[self checkRegistration];
}

-(void)result:(BOOL)successful status:(LegicStatus *)status
{
    if(!successful)
    {
        NSString* title = NSLocalizedString(@"connection_error_title", @"Connection error title");
        NSString* message = [NSString stringWithFormat:@"%ld, %@", (long)[status getCode], [status getDescription]];
        self.rejecter(title, message, nil);
    }
    else
    {
        self.resolver(@"Success");
    }
}

-(void)token:(NSString *)token
{
    if(token != nil)
    {
    }
}

/**
 * SDK Listener callbacks
 */
-(void)handleDisplayContentNotification:(NSNotification*)notification
{

    NSDictionary *userInfo = [notification userInfo];
    NSData* returnedData = [userInfo objectForKey:BLE_MESSAGE];
    NSNumber *objecCode = [userInfo objectForKey:BLE_CODE];

    NSLog(@"##KABALOG BLE Data from BLE: %@, Code: %@ intValue: %d", returnedData, objecCode, objecCode.intValue);

    switch(objecCode.intValue)
    {
        case PluginMessageTypeIdcMessage:
        {
            // This is a message returned by lock once it has evaluated the digital key credential.
            // It allows UI to get information about the process from Lock for example unlock success or deny,
            // error code if deny, first access information, battery status and voltage and others as defines by lock.
            BleDataHandler *handler = [[BleDataHandler alloc] initWithCode:objecCode.intValue Message:returnedData];

            if([handler isAccessGranted])
            {
                NSLog(@"##KABALOG BLE Access Granted!\n");
                [self handleDoorUnlockedNotification];
            }
            else
            {
                // When access not granted can also get a handle of the door lock error code through getAccessError of BleDataHandler
                NSLog(@"##KABALOG BLE Access Not Granted!\n");
                [self handleDoorUnlockFailedNotification];
            }

            NSLog(@"##KABALOG BLE Access %@", [handler getMessageString]);

            break;
        }
        case PluginMessageTypeBluetoothState:
        {
            // Bluetooth state change
            E_LegicBlePluginBLEState stateCode = (E_LegicBlePluginBLEState)*(const unsigned char*)[returnedData bytes];
            if(stateCode == PluginBLEStateErrorBleNotActivated || stateCode == PluginBLEStateErrorGeneral)
            {
                // Display something to the user to tell him that BLE has been deactivated or theres a general BLE error
                NSLog(@"##KABALOG BLE has been deactivated or theres a general BLE error");
            }
            break;
        }
        case PluginMessageTypeProjectState:
        {
            // Do not need to handle this yet.
            break;
        }
        case PluginMessageTypeIdcPolling:
        {
            // Do not need to handle this yet.
            break;
        }
        case PluginMessageTypeIdcFileWasRead:
        {
            // Digital Key was read by lock but not yet evaluated. At this point lock is
            // asking for UI to grant permission to evaluate the credential and unlock if successful.
            unsigned char value[3] = { 0, 1, 1 };
            NSData* dataToSend = [NSData dataWithBytes:value length:3];
            //[[SDKManager instance] sendMessageToBLEReader:0 data:dataToSend];
            [self.manager sendMessageToBLEReader:0 Message:dataToSend];
            break;
        }
    }

}


-(void)handleSyncStartedNotification
{
    NSLog(@"##KABALOG handleSyncStartedNotification notification");
    [self sendEventWithName:@"SYNC_UPDATE" body:@{@"status": @"SYNC_STARTED"}];
}

-(void)handleInitalSyncCompleteNotification:(NSNotification*)notification

{
    NSLog(@"##KABALOG handleInitalSyncCompleteNotification notification");
    [self sendEventWithName:@"SYNC_UPDATE" body:@{@"status": @"INITIAL_SYNC_COMPLETED"}];
}

-(void)handleFinalSyncCompleteNotification:(NSNotification*)notification

{
    NSLog(@"##KABALOG handleFinalSyncCompleteNotification notification");
    [self sendEventWithName:@"SYNC_UPDATE" body:@{@"status": @"SYNC_COMPLETED"}];
}

-(void)handleSyncFailedNotification:(NSNotification*)notification
{
    NSLog(@"##KABALOG handleSyncFailedNotification notification");
    [self sendEventWithName:@"SYNC_UPDATE" body:@{@"status": @"SYNC_FAILED"}];
}

-(void)handleCardsUpdatedNotification:(NSNotification*)notification
{
    NSLog(@"##KABALOG handleCardsUpdatedNotification notification");
    [self sendEventWithName:@"SYNC_UPDATE" body:@{@"status": @"SYNC_CARDS_UPDATED"}];
}

-(void)handleStoreDataCorruptedNotification:(NSNotification*)notification
{
    NSLog(@"##KABALOG handleStoreDataCorruptedNotification notification");
    [self sendEventWithName:@"STORE_DATA" body:@{@"status": @"STORE_DATA_CORRUPTED"}];
}

-(void)handleDoorUnlockedNotification
{
    NSLog(@"##KABALOG handleStoreDataCorruptedNotification notification");
    [self sendEventWithName:@"DOOR_UNLOCKED" body:@{@"status": @"Access granted"}];
}

-(void)handleDoorUnlockFailedNotification
{
    NSLog(@"##KABALOG handleDoorUnlockFailedNotification notification");
    [self sendEventWithName:@"DOOR_UNLOCK_FAILED" body:@{@"status": @"Access denied"}];
}

@end