import Iaphub

class AppDelegate: UIResponder, UIApplicationDelegate {
   func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey : Any]? = nil) -> Bool {
      Iaphub.delegate = self
      Iaphub.start(
        // The app id is available on the settings page of your app
        appId: "5e4890f6c61fc971cf46db4d",
        
        // The (client) api key is available on the settings page of your app
        apiKey: "SDp7aY220RtzZrsvRpp4BGFm6qZqNkNf",
        
        // The user id, if you do not specify one an anonymous id will be generated (id prefixed with 'a:')
        // You can provide it if the user is already logged in on app start
        userId: "42",

        // If you want to allow purchases when the user has an anonymous user id
        // If you're listenning to IAPHUB webhooks your implementation must support users with anonymous user ids
        // This option is disabled by default, when disabled the buy method will return an error when the user isn't logged in
        allowAnonymousPurchase: true
      )
      return true
  }
}

extension AppDelegate: IaphubDelegate {
    
  func didReceiveUserUpdate() {
    // Called when the user has already been fetch and is updated
    // It means the products for sale or active products are different from the one you previously loaded using getProductsForSale/getActiveProducts
    // You should refresh your view with the new state of your products

    // When using the login/logout method, the user is reset, meaning this event won't be called until the user has been loaded first using the getProductsForSale/getActiveProducts methods
  }

  func didReceiveDeferredPurchase(transaction: IHReceiptTransaction) {
    // Called when a deferred purchase has been processed
    // A deferred purchase is a purchase processed 'outside' of the buy method 
  }

  func didReceiveError(err: IHError) {
    // Called when IAPHUB has detected an error
    // It can be interesting to log unexpected errors
    if (err.code == "unexpected") {
      print("Unexpected error: \(err.localizedDescription)")
    }
  }

  func didReceiveBuyRequest(sku: String) {
    // Called when a purchase intent is made from outside the app (from a promoted In-App purchase for example), IAPHUB is allowing all of them by default
    // If you want to allow/disallow a purchase intent (to wait until the user is logged in for example) you can implement this method
    // You'll have to call the buy method whenever you're ready
    // Also note you'll have a callback to know when the transaction is done (you woudn't otherwise)
    Iaphub.buy(sku: sku, { (err, transaction) in
        
    })
  }

  func didProcessReceipt(_ err: IHError?, _ receipt: IHReceipt?) {
    // Called after a receipt has been processed
  }

}

Iaphub.login(userId: "3e4890f6c72fc971cf46db5d", { (err: IHError?) in
  // On a success the err should be nil
});

let userId = Iaphub.getUserId()

Iaphub.logout();

// To set a tag
Iaphub.setUserTags(tags: ["gender": "male"], { (err: IHError?) in
  // On a success err should be nil
});

// To remove a tag pass a empty string
Iaphub.setUserTags(tags: ["gender": ""], { (err: IHError?) in
  // On a success err should be nil
});

// For instance you can provide the app version on app launch
// Useful to return a product only supported in a new version
Iaphub.setDeviceParams(params: ["appVersion": "2.0.0"])
// To clear the device params
Iaphub.setDeviceParams(params: [:])

Iaphub.getProductsForSale({ (err: IHError?, products: [IHProduct]?) in
  // On a success err should be nil
})

  Iaphub.getActiveProducts(includeSubscriptionStates: ["retry_period", "paused"], { (err: IHError?, products: [IHActiveProduct]?) in
    // On a success err should be nil
  })

  Iaphub.getProducts({ (err: IHError?, products: IHProducts?) in
    // On a success err should be nil
  })

  let status = Iaphub.getBillingStatus()

  // You should display an appropriate message if the billing is unavailable
  if (status.error?.code == "billing_unavailable") {
    // Display a message saying that the in-app billing isn't available on the device
  }
  // Check the products that were filtered from the products for sale
  if (!status.filteredProductIds.isEmpty) {
    // The product ids in the array were not returned by Google Play
  }

Iaphub.buy(sku: sku, { (err: IHError?, transaction: IHReceiptTransaction?) in
  // Check error
  if let err = err {
    // Do not do anything if purchase cancelled or product already purchased
    if (err.code == "user_cancelled" || err.code == "product_already_purchased") {
      return
    }
    // The billing is unavailable (An iPhone can be restricted from accessing the Apple App Store)
    else if (err.code == "billing_unavailable") {
        return self.openAlert("In-app purchase not allowed")
    }
    // The product has already been bought but it's owned by a different user, restore needed to transfer it to this user
    else if (err.code == "product_owned_different_user") {
      return self.openAlert("You already purchased this product but it is currently used by a different account, restore your purchases to transfer it to this account")
    }
    // The user tried to purchase a product that is already going to be active on next renewal
    else if (err.code == "product_change_next_renewal") {
      return self.openAlert("The product will be changed on the next renewal date")
    }
    // The payment has been deferred (transaction pending, its final status is pending external action)
    else if (err.code == "deferred_payment") {
        return self.openAlert("Purchase awaiting approval, your purchase has been processed but is awaiting approval")
    }
    /*
     * The remote server couldn't be reached properly
     * The user will have to restore its purchases in order to validate the transaction
     * An automatic restore should be triggered on every relaunch of your app since the transaction hasn't been 'finished'
     */
    else if (err.code == "network_error") {
        return self.openAlert("Please try to restore your purchases later (Button in the settings) or contact the support ([email protected])")
    }
    /*
     * The receipt has been processed on IAPHUB but something went wrong
     * It is probably because of an issue with the configuration of your app or a call to the Itunes/GooglePlay API that failed
     * IAPHUB will automatically retry to process the receipt if possible (depends on the error)
     */
    else if (err.code == "receipt_failed") {
        return self.openAlert("We're having trouble validating your transaction, give us some time we'll retry to validate your transaction ASAP!")
    }
    /*
     * The user has already an active subscription on a different platform (android or ios)
     * This security has been implemented to prevent a user from ending up with two subscriptions of different platforms
     * You can disable the security by providing the 'crossPlatformConflict' parameter to the buy method (Iaphub.buy(sku: sku, crossPlatformConflict: false))
    */
    else if (err.code == "cross_platform_conflict") {
      Alert.alert(
        `Seems like you already have a subscription on a different platform`,
        `You have to use the same platform to change your subscription or wait for your current subscription to expire`
      );
    }
    // Any other error
    return self.openAlert("We were not able to process your purchase, please try again later or contact the support ([email protected])")
  }
  /*
  * The purchase has been successful but we need to check that the webhook to our server was successful as well (if you implemented webhooks)
  * If the webhook request failed, IAPHUB will send you an alert and retry again in 1 minute, 10 minutes, 1 hour and 24 hours.
  * You can retry the webhook directly from the dashboard as well
  */
  if (transaction?.webhookStatus == "failed") {
    self.openAlert("Your purchase was successful but we need some more time to validate it, should arrive soon! Otherwise contact the support ([email protected])")
  }
  // Everything was successful! Yay!
  else {
    self.openAlert("Your purchase has been processed successfully!")
  }
})

Iaphub.restore({ (err: IHError?, response: IHRestoreResponse?) in
  if (err != nil) {
    self.openAlert("Restore failed")
  }
  else {
    self.openAlert("Restore successful")
  }
})

Iaphub.showManageSubscriptions({ (err: IHError?) in
  if (err != nil) {
    self.openAlert("Couldn't redirect to the app store, please check your subscriptions directly from the App Store App")
  }
})