func updateCachedScopesForUser(userId: String, appId: String, scopes: Set<String>) {
    let cacheKey = getCacheKey(for: userId, appId: appId)
    guard let currentScopes = getCachedScopesForUser(userId: userId, appId: appId) else {
        defaults.set(Array(newScopes), forKey: cacheKey)
        return
    }
    let updatedScopes = currentScopes.union(newScopes)
    defaults.set(Array(updatedScopes), forKey: cacheKey)
}

private func getCacheKey(for userId: String, appId: String) -> String {
    return "MPS_scope_\(userId)_\(appId)"
}

override func getAuthCode(clientId: String, 
                          scopes: Set<String>, 
                          type: IAPWalletOAuthCodeFlowType, 
                          extendedInfo: [String: String],
                          in context: IAPWalletAPIContext?,
                          callback: @escaping (IAPWalletOAuthResult) -> Void) {
    // 1. execute auth process
    
    // 2. return results for different cases
    if (userConsentNeeded) {
        let result = IAPWalletOAuthResult(authCode: "", authState: "", authErrorScopes: [:], authSuccessScopes: [], authRedirectUrl: "")
        result.error.code = "2001"
        result.error.localizedDescription = "pending user consent"
        callback(oauthResult)
    }
    
    // If Oauth is successful
    if (oAuthSuccessful) {
        callback(IAPWalletOAuthResult(authCode: "${server-issued-authCode}",
                                      authState: "${server-issued-authState}",
                                      authErrorScopes: ["USER_INFO": "${failed reasons}"],
                                      authSuccessScopes: ["BASE_USER_INFO"]))
    }
    
    // If Oauth is unsuccessful due to other reasons i.e., server error
    if (oAuthUnsuccessful) {
        let result = IAPWalletOAuthResult(authCode: "", authState: "", authErrorScopes: [:], authSuccessScopes: [], authRedirectUrl: "")
        result.error.code = "1000"
        result.error.localizedDescription = "Unkown error"
        callback(oauthResult)
    }
}

override func showAuthPage(clientId: String,
                               name: String,
                               logo: String,
                               scopes: Set<String>,
                               extendedInfo: [String : String]? = nil,
                               in context: IAPWalletAPIContext?,
                               callback: @escaping (IAPWalletAuthPageConfirmResult) -> Void) {
        // override the method to provide a authpage confirmation popover
        var scopeInfo = ""
        for scope in scopes {
            if (scope == OAuthService.SCOPE_BASE_USER_INFO) {
                scopeInfo += "- Access basic user information\n"
            } else if (scope == OAuthService.SCOPE_AGREEMENT_PAY) {
                scopeInfo += "- Conduct aggreement pay automatically\n"
            } else if (scope == OAuthService.SCOPE_USER_NAME) {
                scopeInfo += "- Acess to user's real name\n"
            } else if (scope == OAuthService.SCOPE_USER_LOGIN_ID) {
                scopeInfo += "- Retrieve user login id in the app.\n"
            } // ... iterate through all possible scopes
        }
        
        let authPage = UIAlertController(title: "Authorisation Confirmation",
                                         message: "\(name) wants to access for the following information: \n\(scopeInfo)" ,
                                         preferredStyle: .alert)
        
        authPage.addAction(UIAlertAction(title: NSLocalizedString("OK", comment: "Default action"),
                                         style: .default,
                                         handler: { _ in
                                            // 1. synchronize with wallet server regarding aggreement check
                                            // ----> async remote call: {
                                                ----- case 1 -----
                                                // 2.1 Option 1: when confirmation is purely checked offline
                                                // then inform the SDK that agreement has ben confirmed
                                                let result = IAPWalletAuthPageConfirmResult()
                                                callback(result)
                                                
                                                ----- case 2 ----- 
                                                // 2.2 Option 2: when confirmation is passed to server for ack
                                                // then inform the SDK with the agreementId from server
                                                let result = IAPWalletAuthPageConfirmResult("${agreementReferenceId}")
                                                callback(result)
                                            // ----> }
        }))
        
        authPage.addAction(UIAlertAction(title: NSLocalizedString("Cancel", comment: "User reject"),
                                         style: .cancel,
                                         handler: { _ in
                                            
                                            // 1. if error is presented, the SDK will assume user abort the operation.
                                            let result = IAPWalletAuthPageConfirmResult()
                                            result.error = NSError(domain: "${Wallet-wallet-domain}",
                                                                   code: IAPWalletBaseServiceResult.ERROR_CODE_USER_CANCEL, // or any ${psp-wallet-domain-code}
                                                                   userInfo: [NSLocalizedDescriptionKey: "user canceled"])
                                            callback(result)
                                            
        }))
    }

 public func getAuthorisedScopes(userId: String,
                             clientId: String,
                             appId: String,
                             extendedInfo: [String: String],
                             callback: @escaping (IAPWalletOAuthScopeQueryResult) -> Void) -> Void {
     // implement get authorised scopes logic
     let scopes = getCachedScopesForUser(userId: userId, appId: appId);
     let scopeQueryResult = IAPWalletOAuthScopeQueryResult(authorizedScopes: Array(scopes ?? []));
     callback(scopeQueryResult);
 }

func getCachedScopesForUser(userId: String, appId: String) -> Set<String>? {
    let cacheKey = getCacheKey(for: userId, appId: appId);
    guard let storedScopes = defaults.stringArray(forKey: cacheKey) else {
        return nil;
    }
    let scopes: Set<String> = Set(storedScopes);
    return scopes;
}

final class DeeplinkService: IAPWalletDeeplinkServiceSignature {
    
    // Mark: this API is currently used by Miniprogram combined with AC 2.0 case.
    override func open(scheme: URL,
                       in context: IAPWalletAPIContext?) -> Bool {
        // the wallet app can choose to process the scheme as deeplink,
        // or ordinary url open in webview
        if UIApplication.shared.canOpenURL(scheme) {
            if #available(iOS 10.0, *) {
                UIApplication.shared.open(scheme, options: [:], completionHandler: nil)
                return true
            } else {
                UIApplication.shared.openURL(scheme)
                return true
            }
        } else {
            return false
        }
    }
}

final class DeeplinkService: IAPWalletDeeplinkServiceSignature {
    
    public static let SCENE_WEB_PAGE = "WEB_PAGE" // scene for opening a webpage
    public static let SCENE_SCAN = "SCAN" // scene for open the in app scanner
    public static let SCENE_QR_PAY = "QR_PAY" // scene for conduct qr payment
    public static let SCENE_BIND_CARD = "BIND_CARD" // scene for trigger in app card bind flow
    public static let SCENE_DEEPLINK_SCHEME = "SCHEME" // scene for invoke in app deeplink routing
    public static let SCENE_TOP_UP = "TOP_UP" // scene for trigger in app topup flow
    
    override func open(bizSceneCode: String, with params: [String:String], in context: IAPWalletAPIContext? = nil, callback: @escaping (IAPWalletBaseServiceResult) -> Void) {
        
        let result = IAPWalletBaseServiceResult()
        if (bizSceneCode == IAPWalletDeeplinkServiceSignature.SCENE_WEB_PAGE) {
            // handle opening web page
            result.extendedInfo = ["${result-param-1-key}" : "${result-param-1-value}"]
            callback(result)
        } else if (bizSceneCode == IAPWalletDeeplinkServiceSignature.SCENE_SCAN) {
            // handle opening scan page
            result.extendedInfo = ["${result-param-1-key}" : "${result-param-1-value}"]
            callback(result)
        } else if (bizSceneCode == IAPWalletDeeplinkServiceSignature.SCENE_TOP_UP) {
            // handle opening top up page
            result.extendedInfo = ["${result-param-1-key}" : "${result-param-1-value}"]
            callback(result)
        }
        
        // implement all the relevant scene codes here.
    }