#import <TDMobRisk/TDMobRisk.h>

import TDMobRisk

void (*initWithOptions)(NSDictionary *options);

- (void)initTrustDecisionSDK {
  // Get riskManager
  TDMobRiskManager_t *riskManager = [TDMobRiskManager sharedManager];
  // Initialization Configuration
  NSMutableDictionary *options = [NSMutableDictionary dictionary];

/*************************** Mandatory Parameter ***************************/
  //Partner code, Refer to `Required Configuration`
  [options setValue:@"[Your partner]" forKey:@"partner"];
  //App key, Refer to `Required Configuration`
  [options setValue:@"[Your appKey]" forKey:@"appKey"];
  //App name, Refer to `Required Configuration`
  [options setValue:@"[Your partnerKey]" forKey:@"partnerKey"];
  //Country code, Refer to `Required Configuration`
  [options setValue:@"[Your country code]" forKey:@"country"];

  /*************************** Optional Parameter ***************************/
#ifdef DEBUG
  // !!! If not set this parameter in DEBUG mode, the app will terminate
  [options setValue:@(YES) forKey:@"allowed"];
#endif
  // !!!The callback method has been removed, and now a getBlackBoxAsync method has been added to asynchronously obtain blackbox
  riskManager->initWithOptions(options);
}

func initTrustDecisionSDK() {
  let riskManager = TDMobRiskManager.sharedManager()
  var options = [String : NSObject]()
  /*************************** Mandatory Parameter ***************************/
  // Partner code, Refer to `Required Configuration`
  options.updateValue("[Your partner]" as NSObject, forKey: "partner")
  // App key, Refer to `Required Configuration`
  options.updateValue("[Your appKey]" as NSObject, forKey: "appKey")
  // App name, Refer to `Required Configuration`
  options.updateValue("[Your partnerKey]" as NSObject, forKey: "partnerKey")
  // Country code, Refer to `Required Configuration`
  options.updateValue("[Your country]" as NSObject, forKey: "country")

   /*************************** Optional Parameter ***************************/
#if DEBUG
  // !!! If not set this parameter in DEBUG mode, the app will terminate
  options.updateValue(true, forKey: "allowed")
#endif
  // !!!The callback method has been removed, and now a getBlackBoxAsync method has been added to asynchronously obtain blackbox
 riskManager?.pointee.initWithOptions(options)
}

   /* Get blackBox asynchronously
    */
   void (*getBlackBoxAsync)(TDGetBlackBoxAsyncBlock block);

     TDMobRiskManager_t *riskManager = [TDMobRiskManager sharedManager];
     riskManager->getBlackBoxAsync(^(NSString* blackBox){
         NSLog(@"blackBox:%@", blackBox);
     });

    let riskManager = TDMobRiskManager.sharedManager()
    riskManager?.pointee.getBlackBoxAsync(){(blackBoxString : String!)->Void in
            print("blackBox:" + blackBoxString)                               
    }

   /* Get blackBox synchronously
    * @return After the SDK is initialized, the blackBox obtained synchronously
    */
   NSString (*getBlackBox)(void);

   TDMobRiskManager_t *riskManager = [TDMobRiskManager sharedManager];
   NSString *blackBox = riskManager->getBlackBox();

  let riskManager = TDMobRiskManager.sharedManager()
  let blackBox = riskManager?.pointee.getBlackBox()

/**
 * Display Liveness window
 * @usage: manager->showLiveness(self,^(TDLivenessResultStruct resultStruct) {
 * });
 * @param targetVC The parent view where the popup is displayed, UIViewController type
 * @param block result callback block
*/
void (*showLiveness)(id targetVC,TDShowLivenessBlock block);

typedef enum {
    
    // The Liveness is verified successfully;
    TDLivenessResultTypeSuccess,
    // If the Liveness fails, you can get the error code errorCode and errorMsg, and check the cause according to the `Error code` in the document;
    TDLivenessResultTypeFailed,
    // The Liveness window pop-up is successful, waiting to be verified;
    TDLivenessResultTypeReady,
    
} TDLivenessResultType;

typedef struct _TDLivenessResultStruct{
    // return result type
    const TDLivenessResultType resultType;
    // the seqId of the Liveness returned
    char* const seqId;
    // After the return fails, the returned error code can be checked according to the document
    const NSInteger errorCode;
    // Return error message after failure
    char* const errorMsg;
    // liveness score when success
    double score;
    // best image string
    char* const bestImageString;
    
}TDLivenessResultStruct;

- (void)showLiveness {
     [TDMobRiskManager sharedManager]->showLiveness(self,^(TDLivenessResultStruct resultStruct) {
         if(resultStruct.resultType == TDLivenessResultTypeSuccess){
             // If there is a best photo
             if(resultStruct.bestImageString.length > 0){
                 NSData* data = [[NSData alloc]initWithBase64EncodedString:resultStruct.bestImageString options:NSDataBase64DecodingIgnoreUnknownCharacters];
                 UIImage * image = [UIImage imageWithData:data];
                 UIImageWriteToSavedPhotosAlbum(image, nil, nil, nil);
             }
            
             NSString*successMsg = [NSString stringWithUTF8String:resultStruct.errorMsg];
             NSLog(@"successMsg-::%@,score:%f",successMsg,resultStruct.score);
         }else{
             NSString*errorMsg = [NSString stringWithUTF8String:resultStruct.errorMsg];
             NSString*errorMsgInfo = [NSString stringWithFormat:@"Face detection failed, error code: %ld, error message: %@", resultStruct.errorCode,errorMsg];
             NSLog(@"errorMsgInfo-::%@",errorMsgInfo);
         }
     });
}

     func showLiveness() {
         let targetVC = self
         let riskManager = TDMobRiskManager.sharedManager()
         riskManager?.pointee.showLiveness(targetVC) { (resultStruct : TDLivenessResultStruct!)->Void in
             switch resultStruct.resultType {
             case TDLivenessResultTypeSuccess:
                 let bestImageString : String? = String(utf8String: resultStruct.bestImageString)
                 if(bestImageString != nil && bestImageString!.count > 0){
                     let data : Data? = Data(base64Encoded: bestImageString!)
                     if(data != nil){
                         let image : UIImage? = UIImage(data: data!)
                         if(image != nil){
                             UIImageWriteToSavedPhotosAlbum(image!, nil, nil, nil);
                         }
                     }
                 }
                 let successMsg = String(cString:resultStruct.errorMsg)
                 let seqId = String(cString:resultStruct.seqId)
                 print("Liveness successful!!!,seqId:\(seqId),successMsg:\(successMsg),score:\(resultStruct.score)")
             case TDLivenessResultTypeFailed:
                 let errorMsg = String(cString:resultStruct.errorMsg)
                 print("Liveness failed, errorCode:\(resultStruct.errorCode), errorMsg:\(errorMsg)")
             default:
                 break
             }
         }
     }

// Get SDK Version
TDMobRiskManager_t *riskManager = [TDMobRiskManager sharedManager];
NSString *sdkVersion = riskManager->getSDKVersion();

// Get SDK Version
let riskManager = TDMobRiskManager.sharedManager()
let sdkVersion = riskManager?.pointee.getSDKVersion()

[options setValue:@(YES) forKey:@"allowed"];

options.updateValue(true, forKey: "allowed")