using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Xml;
using UnityEngine;
using UnityEngine.Purchasing;
using UnityEngine.Purchasing.Security;

namespace UnityEngine.Purchasing
{

    /// <summary>
    /// A period of time expressed in either days, months, or years. Conveys a subscription's duration definition.
    /// Note this reflects the types of subscription durations settable on a subscription on supported app stores.
    /// </summary>
    public class TimeSpanUnits
    {
        /// <summary>
        /// Discrete duration in days, if less than a month, otherwise zero.
        /// </summary>
        public double days;
        /// <summary>
        /// Discrete duration in months, if less than a year, otherwise zero.
        /// </summary>
        public int months;
        /// <summary>
        /// Discrete duration in years, otherwise zero.
        /// </summary>
        public int years;

        /// <summary>
        /// Construct a subscription duration.
        /// </summary>
        /// <param name="d">Discrete duration in days, if less than a month, otherwise zero.</param>
        /// <param name="m">Discrete duration in months, if less than a year, otherwise zero.</param>
        /// <param name="y">Discrete duration in years, otherwise zero.</param>
        public TimeSpanUnits(double d, int m, int y)
        {
            days = d;
            months = m;
            years = y;
        }
    }

    /// <summary>
    /// Use to query in-app purchasing subscription product information, and upgrade subscription products.
    /// Supports the Apple App Store, Google Play store, and Amazon AppStore.
    /// Note Amazon support offers no subscription duration information.
    /// Note expiration dates may become invalid after updating subscriptions between two types of duration.
    /// </summary>
    /// <seealso cref="IAppleExtensions.GetIntroductoryPriceDictionary"/>
    /// <seealso cref="UpdateSubscription"/>
    public class SubscriptionManager
    {

        private readonly string receipt;
        private readonly string productId;
        private readonly string intro_json;

        /// <summary>
        /// Performs subscription updating, migrating a subscription into another as long as they are both members
        /// of the same subscription group on the App Store.
        /// </summary>
        /// <param name="newProduct">Destination subscription product, belonging to the same subscription group as <paramref name="oldProduct"/></param>
        /// <param name="oldProduct">Source subscription product, belonging to the same subscription group as <paramref name="newProduct"/></param>
        /// <param name="developerPayload">Carried-over metadata from prior call to <typeparamref name="SubscriptionManager.UpdateSubscription"/> </param>
        /// <param name="appleStore">Triggered upon completion of the subscription update.</param>
        /// <param name="googleStore">Triggered upon completion of the subscription update.</param>
        public static void UpdateSubscription(Product newProduct, Product oldProduct, string developerPayload, Action<Product, string> appleStore, Action<string, string> googleStore)
        {
            if (oldProduct.receipt == null)
            {
                Debug.LogError("The product has not been purchased, a subscription can only be upgrade/downgrade when has already been purchased");
                return;
            }
            var receipt_wrapper = (Dictionary<string, object>)MiniJson.JsonDecode(oldProduct.receipt);
            if (receipt_wrapper == null || !receipt_wrapper.ContainsKey("Store") || !receipt_wrapper.ContainsKey("Payload"))
            {
                Debug.LogWarning("The product receipt does not contain enough information");
                return;
            }
            var store = (string)receipt_wrapper["Store"];
            var payload = (string)receipt_wrapper["Payload"];

            if (payload != null)
            {
                switch (store)
                {
                    case "GooglePlay":
                    {
                        var oldSubscriptionManager = new SubscriptionManager(oldProduct, null);
                        SubscriptionInfo oldSubscriptionInfo;
                        try
                        {
                            oldSubscriptionInfo = oldSubscriptionManager.getSubscriptionInfo();
                        }
                        catch (Exception e)
                        {
                            Debug.unityLogger.LogError("Error: the product that will be updated does not have a valid receipt", e);
                            return;
                        }
                        var newSubscriptionId = newProduct.definition.storeSpecificId;
                        googleStore(oldSubscriptionInfo.getSubscriptionInfoJsonString(), newSubscriptionId);
                        return;
                    }
                    case "AppleAppStore":
                    case "MacAppStore":
                    {
                        appleStore(newProduct, developerPayload);
                        return;
                    }
                    default:
                    {
                        Debug.LogWarning("This store does not support update subscriptions");
                        return;
                    }
                }
            }
        }

        /// <summary>
        /// Performs subscription updating, migrating a subscription into another as long as they are both members
        /// of the same subscription group on the App Store.
        /// </summary>
        /// <param name="oldProduct">Source subscription product, belonging to the same subscription group as <paramref name="newProduct"/></param>
        /// <param name="newProduct">Destination subscription product, belonging to the same subscription group as <paramref name="oldProduct"/></param>
        /// <param name="googlePlayUpdateCallback">Triggered upon completion of the subscription update.</param>
        public static void UpdateSubscriptionInGooglePlayStore(Product oldProduct, Product newProduct, Action<string, string> googlePlayUpdateCallback)
        {
            var oldSubscriptionManager = new SubscriptionManager(oldProduct, null);
            SubscriptionInfo oldSubscriptionInfo;
            try
            {
                oldSubscriptionInfo = oldSubscriptionManager.getSubscriptionInfo();
            }
            catch (Exception e)
            {
                Debug.unityLogger.LogError("Error: the product that will be updated does not have a valid receipt", e);
                return;
            }
            var newSubscriptionId = newProduct.definition.storeSpecificId;
            googlePlayUpdateCallback(oldSubscriptionInfo.getSubscriptionInfoJsonString(), newSubscriptionId);
        }

        /// <summary>
        /// Performs subscription updating, migrating a subscription into another as long as they are both members
        /// of the same subscription group on the App Store.
        /// </summary>
        /// <param name="newProduct">Destination subscription product, belonging to the same subscription group as <paramref name="oldProduct"/></param>
        /// <param name="developerPayload">Carried-over metadata from prior call to <typeparamref name="SubscriptionManager.UpdateSubscription"/> </param>
        /// <param name="appleStoreUpdateCallback">Triggered upon completion of the subscription update.</param>
        public static void UpdateSubscriptionInAppleStore(Product newProduct, string developerPayload, Action<Product, string> appleStoreUpdateCallback)
        {
            appleStoreUpdateCallback(newProduct, developerPayload);
        }

        /// <summary>
        /// Construct an object that allows inspection of a subscription product.
        /// </summary>
        /// <param name="product">Subscription to be inspected</param>
        /// <param name="intro_json">From <typeparamref name="IAppleExtensions.GetIntroductoryPriceDictionary"/></param>
        public SubscriptionManager(Product product, string intro_json)
        {
            receipt = product.receipt;
            productId = product.definition.storeSpecificId;
            this.intro_json = intro_json;
        }

        /// <summary>
        /// Construct an object that allows inspection of a subscription product.
        /// </summary>
        /// <param name="receipt">A Unity IAP unified receipt from <typeparamref name="Product.receipt"/></param>
        /// <param name="id">A product identifier.</param>
        /// <param name="intro_json">From <typeparamref name="IAppleExtensions.GetIntroductoryPriceDictionary"/></param>
        public SubscriptionManager(string receipt, string id, string intro_json)
        {
            this.receipt = receipt;
            productId = id;
            this.intro_json = intro_json;
        }

        /// <summary>
        /// Convert my Product into a <typeparamref name="SubscriptionInfo"/>.
        /// My Product.receipt must have a "Payload" JSON key containing supported native app store
        /// information, which will be converted here.
        /// </summary>
        /// <returns></returns>
        /// <exception cref="NullProductIdException">My Product must have a non-null product identifier</exception>
        /// <exception cref="StoreSubscriptionInfoNotSupportedException">A supported app store must be used as my product</exception>
        /// <exception cref="NullReceiptException">My product must have</exception>
        public SubscriptionInfo getSubscriptionInfo()
        {

            if (receipt != null)
            {
                var receipt_wrapper = (Dictionary<string, object>)MiniJson.JsonDecode(receipt);

                var validPayload = receipt_wrapper.TryGetValue("Payload", out var payloadAsObject);
                var validStore = receipt_wrapper.TryGetValue("Store", out var storeAsObject);

                if (validPayload && validStore)
                {

                    var payload = payloadAsObject as string;
                    var store = storeAsObject as string;

                    switch (store)
                    {
                        case GooglePlay.Name:
                        {
                            return getGooglePlayStoreSubInfo(payload);
                        }
                        case AppleAppStore.Name:
                        case MacAppStore.Name:
                        {
                            if (productId == null)
                            {
                                throw new NullProductIdException();
                            }
                            return getAppleAppStoreSubInfo(payload, productId);
                        }
                        case AmazonApps.Name:
                        {
                            return getAmazonAppStoreSubInfo(productId);
                        }
                        default:
                        {
                            throw new StoreSubscriptionInfoNotSupportedException("Store not supported: " + store);
                        }
                    }
                }
            }

            throw new NullReceiptException();

        }

        private SubscriptionInfo getAmazonAppStoreSubInfo(string productId)
        {
            return new SubscriptionInfo(productId);
        }
        private SubscriptionInfo getAppleAppStoreSubInfo(string payload, string productId)
        {

            AppleReceipt receipt = null;

            var logger = Debug.unityLogger;

            try
            {
                receipt = new AppleReceiptParser().Parse(Convert.FromBase64String(payload));
            }
            catch (ArgumentException e)
            {
                logger.Log("Unable to parse Apple receipt", e);
            }
            catch (IAPSecurityException e)
            {
                logger.Log("Unable to parse Apple receipt", e);
            }
            catch (NullReferenceException e)
            {
                logger.Log("Unable to parse Apple receipt", e);
            }

            var inAppPurchaseReceipts = new List<AppleInAppPurchaseReceipt>();

            if (receipt != null && receipt.inAppPurchaseReceipts != null && receipt.inAppPurchaseReceipts.Length > 0)
            {
                foreach (var r in receipt.inAppPurchaseReceipts)
                {
                    if (r.productID.Equals(productId))
                    {
                        inAppPurchaseReceipts.Add(r);
                    }
                }
            }
            return inAppPurchaseReceipts.Count == 0 ? null : new SubscriptionInfo(findMostRecentReceipt(inAppPurchaseReceipts), intro_json);
        }

        private AppleInAppPurchaseReceipt findMostRecentReceipt(List<AppleInAppPurchaseReceipt> receipts)
        {
            receipts.Sort((b, a) => a.purchaseDate.CompareTo(b.purchaseDate));
            return receipts[0];
        }

        private SubscriptionInfo getGooglePlayStoreSubInfo(string payload)
        {
            var payload_wrapper = (Dictionary<string, object>)MiniJson.JsonDecode(payload);
            payload_wrapper.TryGetValue("skuDetails", out var skuDetailsObject);

            var skuDetails = (skuDetailsObject as List<object>)?.Select(obj => obj as string);

            var purchaseHistorySupported = false;

            var original_json_payload_wrapper =
                (Dictionary<string, object>)MiniJson.JsonDecode((string)payload_wrapper["json"]);

            var validIsAutoRenewingKey =
                original_json_payload_wrapper.TryGetValue("autoRenewing", out var autoRenewingObject);

            var isAutoRenewing = false;
            if (validIsAutoRenewingKey)
            {
                isAutoRenewing = (bool)autoRenewingObject;
            }

            // Google specifies times in milliseconds since 1970.
            var epoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);

            var validPurchaseTimeKey =
                original_json_payload_wrapper.TryGetValue("purchaseTime", out var purchaseTimeObject);

            long purchaseTime = 0;

            if (validPurchaseTimeKey)
            {
                purchaseTime = (long)purchaseTimeObject;
            }

            var purchaseDate = epoch.AddMilliseconds(purchaseTime);

            var validDeveloperPayloadKey =
                original_json_payload_wrapper.TryGetValue("developerPayload", out var developerPayloadObject);

            var isFreeTrial = false;
            var hasIntroductoryPrice = false;
            string updateMetadata = null;

            if (validDeveloperPayloadKey)
            {
                var developerPayloadJSON = (string)developerPayloadObject;
                var developerPayload_wrapper = (Dictionary<string, object>)MiniJson.JsonDecode(developerPayloadJSON);
                var validIsFreeTrialKey =
                    developerPayload_wrapper.TryGetValue("is_free_trial", out var isFreeTrialObject);
                if (validIsFreeTrialKey)
                {
                    isFreeTrial = (bool)isFreeTrialObject;
                }

                var validHasIntroductoryPriceKey =
                    developerPayload_wrapper.TryGetValue("has_introductory_price_trial",
                        out var hasIntroductoryPriceObject);

                if (validHasIntroductoryPriceKey)
                {
                    hasIntroductoryPrice = (bool)hasIntroductoryPriceObject;
                }

                var validIsUpdatedKey = developerPayload_wrapper.TryGetValue("is_updated", out var isUpdatedObject);

                var isUpdated = false;

                if (validIsUpdatedKey)
                {
                    isUpdated = (bool)isUpdatedObject;
                }

                if (isUpdated)
                {
                    var isValidUpdateMetaKey = developerPayload_wrapper.TryGetValue("update_subscription_metadata",
                        out var updateMetadataObject);

                    if (isValidUpdateMetaKey)
                    {
                        updateMetadata = (string)updateMetadataObject;
                    }
                }
            }

            var skuDetail = skuDetails.First();


            return new SubscriptionInfo(skuDetail, isAutoRenewing, purchaseDate, isFreeTrial, hasIntroductoryPrice,
                purchaseHistorySupported, updateMetadata);
        }
    }

    /// <summary>
    /// A container for a Product’s subscription-related information.
    /// </summary>
    /// <seealso cref="SubscriptionManager.getSubscriptionInfo"/>
    public class SubscriptionInfo
    {
        private readonly Result is_subscribed;
        private readonly Result is_expired;
        private readonly Result is_cancelled;
        private readonly Result is_free_trial;
        private readonly Result is_auto_renewing;
        private readonly Result is_introductory_price_period;
        private readonly string productId;
        private readonly DateTime purchaseDate;
        private readonly DateTime subscriptionExpireDate;
        private readonly DateTime subscriptionCancelDate;
        private readonly TimeSpan remainedTime;
        private readonly string introductory_price;
        private readonly TimeSpan introductory_price_period;
        private readonly long introductory_price_cycles;

        private readonly TimeSpan freeTrialPeriod;
        private readonly TimeSpan subscriptionPeriod;

        // for test
        private readonly string free_trial_period_string;
        private readonly string sku_details;

        /// <summary>
        /// Unpack Apple receipt subscription data.
        /// </summary>
        /// <param name="r">The Apple receipt from <typeparamref name="CrossPlatformValidator"/></param>
        /// <param name="intro_json">From <typeparamref name="IAppleExtensions.GetIntroductoryPriceDictionary"/>. Keys:
        /// <c>introductoryPriceLocale</c>, <c>introductoryPrice</c>, <c>introductoryPriceNumberOfPeriods</c>, <c>numberOfUnits</c>,
        /// <c>unit</c>, which can be fetched from Apple's remote service.</param>
        /// <exception cref="InvalidProductTypeException">Error found involving an invalid product type.</exception>
        /// <see cref="CrossPlatformValidator"/>
        public SubscriptionInfo(AppleInAppPurchaseReceipt r, string intro_json)
        {

            var productType = (AppleStoreProductType)Enum.Parse(typeof(AppleStoreProductType), r.productType.ToString());

            if (productType == AppleStoreProductType.Consumable || productType == AppleStoreProductType.NonConsumable)
            {
                throw new InvalidProductTypeException();
            }

            if (!string.IsNullOrEmpty(intro_json))
            {
                var intro_wrapper = (Dictionary<string, object>)MiniJson.JsonDecode(intro_json);
                var nunit = -1;
                var unit = SubscriptionPeriodUnit.NotAvailable;
                introductory_price = intro_wrapper.TryGetString("introductoryPrice") + intro_wrapper.TryGetString("introductoryPriceLocale");
                if (string.IsNullOrEmpty(introductory_price))
                {
                    introductory_price = "not available";
                }
                else
                {
                    try
                    {
                        introductory_price_cycles = Convert.ToInt64(intro_wrapper.TryGetString("introductoryPriceNumberOfPeriods"));
                        nunit = Convert.ToInt32(intro_wrapper.TryGetString("numberOfUnits"));
                        unit = (SubscriptionPeriodUnit)Convert.ToInt32(intro_wrapper.TryGetString("unit"));
                    }
                    catch (Exception e)
                    {
                        Debug.unityLogger.Log("Unable to parse introductory period cycles and duration, this product does not have configuration of introductory price period", e);
                        unit = SubscriptionPeriodUnit.NotAvailable;
                    }
                }
                var now = DateTime.Now;
                switch (unit)
                {
                    case SubscriptionPeriodUnit.Day:
                        introductory_price_period = TimeSpan.FromTicks(TimeSpan.FromDays(1).Ticks * nunit);
                        break;
                    case SubscriptionPeriodUnit.Month:
                        var month_span = now.AddMonths(1) - now;
                        introductory_price_period = TimeSpan.FromTicks(month_span.Ticks * nunit);
                        break;
                    case SubscriptionPeriodUnit.Week:
                        introductory_price_period = TimeSpan.FromTicks(TimeSpan.FromDays(7).Ticks * nunit);
                        break;
                    case SubscriptionPeriodUnit.Year:
                        var year_span = now.AddYears(1) - now;
                        introductory_price_period = TimeSpan.FromTicks(year_span.Ticks * nunit);
                        break;
                    case SubscriptionPeriodUnit.NotAvailable:
                        introductory_price_period = TimeSpan.Zero;
                        introductory_price_cycles = 0;
                        break;
                }
            }
            else
            {
                introductory_price = "not available";
                introductory_price_period = TimeSpan.Zero;
                introductory_price_cycles = 0;
            }

            var current_date = DateTime.UtcNow;
            purchaseDate = r.purchaseDate;
            productId = r.productID;

            subscriptionExpireDate = r.subscriptionExpirationDate;
            subscriptionCancelDate = r.cancellationDate;

            // if the product is non-renewing subscription, apple store will not return expiration date for this product
            if (productType == AppleStoreProductType.NonRenewingSubscription)
            {
                is_subscribed = Result.Unsupported;
                is_expired = Result.Unsupported;
                is_cancelled = Result.Unsupported;
                is_free_trial = Result.Unsupported;
                is_auto_renewing = Result.Unsupported;
                is_introductory_price_period = Result.Unsupported;
            }
            else
            {
                is_cancelled = (r.cancellationDate.Ticks > 0) && (r.cancellationDate.Ticks < current_date.Ticks) ? Result.True : Result.False;
                is_subscribed = r.subscriptionExpirationDate.Ticks >= current_date.Ticks ? Result.True : Result.False;
                is_expired = (r.subscriptionExpirationDate.Ticks > 0 && r.subscriptionExpirationDate.Ticks < current_date.Ticks) ? Result.True : Result.False;
                is_free_trial = (r.isFreeTrial == 1) ? Result.True : Result.False;
                is_auto_renewing = ((productType == AppleStoreProductType.AutoRenewingSubscription) && is_cancelled == Result.False
                        && is_expired == Result.False) ? Result.True : Result.False;
                is_introductory_price_period = r.isIntroductoryPricePeriod == 1 ? Result.True : Result.False;
            }

            remainedTime = is_subscribed == Result.True ? r.subscriptionExpirationDate.Subtract(current_date) : TimeSpan.Zero;


        }

        /// <summary>
        /// Especially crucial values relating to Google subscription products.
        /// Note this is intended to be called internally.
        /// </summary>
        /// <param name="skuDetails">The raw JSON from <c>SkuDetail.getOriginalJson</c></param>
        /// <param name="isAutoRenewing">Whether this subscription is expected to auto-renew</param>
        /// <param name="purchaseDate">A date this subscription was billed</param>
        /// <param name="isFreeTrial">Indicates whether this Product is a free trial</param>
        /// <param name="hasIntroductoryPriceTrial">Indicates whether this Product may be owned with an introductory price period.</param>
        /// <param name="purchaseHistorySupported">Unsupported</param>
        /// <param name="updateMetadata">Unsupported. Mechanism previously propagated subscription upgrade information to new subscription. </param>
        /// <exception cref="InvalidProductTypeException">For non-subscription product types. </exception>
        public SubscriptionInfo(string skuDetails, bool isAutoRenewing, DateTime purchaseDate, bool isFreeTrial,
                bool hasIntroductoryPriceTrial, bool purchaseHistorySupported, string updateMetadata)
        {

            var skuDetails_wrapper = (Dictionary<string, object>)MiniJson.JsonDecode(skuDetails);
            var validTypeKey = skuDetails_wrapper.TryGetValue("type", out var typeObject);

            if (!validTypeKey || (string)typeObject == "inapp")
            {
                throw new InvalidProductTypeException();
            }

            var validProductIdKey = skuDetails_wrapper.TryGetValue("productId", out var productIdObject);
            productId = null;
            if (validProductIdKey)
            {
                productId = productIdObject as string;
            }

            this.purchaseDate = purchaseDate;
            is_subscribed = Result.True;
            is_auto_renewing = isAutoRenewing ? Result.True : Result.False;
            is_expired = Result.False;
            is_cancelled = isAutoRenewing ? Result.False : Result.True;
            is_free_trial = Result.False;


            string sub_period = null;
            if (skuDetails_wrapper.ContainsKey("subscriptionPeriod"))
            {
                sub_period = (string)skuDetails_wrapper["subscriptionPeriod"];
            }
            string free_trial_period = null;
            if (skuDetails_wrapper.ContainsKey("freeTrialPeriod"))
            {
                free_trial_period = (string)skuDetails_wrapper["freeTrialPeriod"];
            }
            string introductory_price = null;
            if (skuDetails_wrapper.ContainsKey("introductoryPrice"))
            {
                introductory_price = (string)skuDetails_wrapper["introductoryPrice"];
            }
            string introductory_price_period_string = null;
            if (skuDetails_wrapper.ContainsKey("introductoryPricePeriod"))
            {
                introductory_price_period_string = (string)skuDetails_wrapper["introductoryPricePeriod"];
            }
            long introductory_price_cycles = 0;
            if (skuDetails_wrapper.ContainsKey("introductoryPriceCycles"))
            {
                introductory_price_cycles = (long)skuDetails_wrapper["introductoryPriceCycles"];
            }

            // for test
            free_trial_period_string = free_trial_period;

            subscriptionPeriod = computePeriodTimeSpan(parsePeriodTimeSpanUnits(sub_period));

            freeTrialPeriod = TimeSpan.Zero;
            if (isFreeTrial)
            {
                freeTrialPeriod = parseTimeSpan(free_trial_period);
            }

            this.introductory_price = introductory_price;
            this.introductory_price_cycles = introductory_price_cycles;
            introductory_price_period = TimeSpan.Zero;
            is_introductory_price_period = Result.False;
            var total_introductory_duration = TimeSpan.Zero;

            if (hasIntroductoryPriceTrial)
            {
                introductory_price_period = introductory_price_period_string != null && introductory_price_period_string.Equals(sub_period)
                    ? subscriptionPeriod
                    : parseTimeSpan(introductory_price_period_string);
                // compute the total introductory duration according to the introductory price period and period cycles
                total_introductory_duration = accumulateIntroductoryDuration(parsePeriodTimeSpanUnits(introductory_price_period_string), this.introductory_price_cycles);
            }

            // if this subscription is updated from other subscription, the remaining time will be applied to this subscription
            var extra_time = TimeSpan.FromSeconds(updateMetadata == null ? 0.0 : computeExtraTime(updateMetadata, subscriptionPeriod.TotalSeconds));

            var time_since_purchased = DateTime.UtcNow.Subtract(purchaseDate);


            // this subscription is still in the extra time (the time left by the previous subscription when updated to the current one)
            if (time_since_purchased <= extra_time)
            {
                // this subscription is in the remaining credits from the previous updated one
                subscriptionExpireDate = purchaseDate.Add(extra_time);
            }
            else if (time_since_purchased <= freeTrialPeriod.Add(extra_time))
            {
                // this subscription is in the free trial period
                // this product will be valid until free trial ends, the beginning of next billing date
                is_free_trial = Result.True;
                subscriptionExpireDate = purchaseDate.Add(freeTrialPeriod.Add(extra_time));
            }
            else if (time_since_purchased < freeTrialPeriod.Add(extra_time).Add(total_introductory_duration))
            {
                // this subscription is in the introductory price period
                is_introductory_price_period = Result.True;
                var introductory_price_begin_date = this.purchaseDate.Add(freeTrialPeriod.Add(extra_time));
                subscriptionExpireDate = nextBillingDate(introductory_price_begin_date, parsePeriodTimeSpanUnits(introductory_price_period_string));
            }
            else
            {
                // no matter sub is cancelled or not, the expire date will be next billing date
                var billing_begin_date = this.purchaseDate.Add(freeTrialPeriod.Add(extra_time).Add(total_introductory_duration));
                subscriptionExpireDate = nextBillingDate(billing_begin_date, parsePeriodTimeSpanUnits(sub_period));
            }

            remainedTime = subscriptionExpireDate.Subtract(DateTime.UtcNow);
            sku_details = skuDetails;
        }

        /// <summary>
        /// Especially crucial values relating to subscription products.
        /// Note this is intended to be called internally.
        /// </summary>
        /// <param name="productId">This subscription's product identifier</param>
        public SubscriptionInfo(string productId)
        {
            this.productId = productId;
            is_subscribed = Result.True;
            is_expired = Result.False;
            is_cancelled = Result.Unsupported;
            is_free_trial = Result.Unsupported;
            is_auto_renewing = Result.Unsupported;
            remainedTime = TimeSpan.MaxValue;
            is_introductory_price_period = Result.Unsupported;
            introductory_price_period = TimeSpan.MaxValue;
            introductory_price = null;
            introductory_price_cycles = 0;
        }

        /// <summary>
        /// Store specific product identifier.
        /// </summary>
        /// <returns>The product identifier from the store receipt.</returns>
        public string getProductId() { return productId; }

        /// <summary>
        /// A date this subscription was billed.
        /// Note the store-specific behavior.
        /// </summary>
        /// <returns>
        /// For Apple, the purchase date is the date when the subscription was either purchased or renewed.
        /// For Google, the purchase date is the date when the subscription was originally purchased.
        /// </returns>
        public DateTime getPurchaseDate() { return purchaseDate; }

        /// <summary>
        /// Indicates whether this auto-renewable subscription Product is currently subscribed or not.
        /// Note the store-specific behavior.
        /// Note also that the receipt may update and change this subscription expiration status if the user sends
        /// their iOS app to the background and then returns it to the foreground. It is therefore recommended to remember
        /// subscription expiration state at app-launch, and ignore the fact that a subscription may expire later during
        /// this app launch runtime session.
        /// </summary>
        /// <returns>
        /// <typeparamref name="Result.True"/> Subscription status if the store receipt's expiration date is
        /// after the device's current time.
        /// <typeparamref name="Result.False"/> otherwise.
        /// Non-renewable subscriptions in the Apple store return a <typeparamref name="Result.Unsupported"/> value.
        /// </returns>
        /// <seealso cref="isExpired"/>
        /// <seealso cref="DateTime.UtcNow"/>
        public Result isSubscribed() { return is_subscribed; }

        /// <summary>
        /// Indicates whether this auto-renewable subscription Product is currently unsubscribed or not.
        /// Note the store-specific behavior.
        /// Note also that the receipt may update and change this subscription expiration status if the user sends
        /// their iOS app to the background and then returns it to the foreground. It is therefore recommended to remember
        /// subscription expiration state at app-launch, and ignore the fact that a subscription may expire later during
        /// this app launch runtime session.
        /// </summary>
        /// <returns>
        /// <typeparamref name="Result.True"/> Subscription status if the store receipt's expiration date is
        /// before the device's current time.
        /// <typeparamref name="Result.False"/> otherwise.
        /// Non-renewable subscriptions in the Apple store return a <typeparamref name="Result.Unsupported"/> value.
        /// </returns>
        /// <seealso cref="isSubscribed"/>
        /// <seealso cref="DateTime.UtcNow"/>
        public Result isExpired() { return is_expired; }

        /// <summary>
        /// Indicates whether this Product has been cancelled.
        /// A cancelled subscription means the Product is currently subscribed, and will not renew on the next billing date.
        /// </summary>
        /// <returns>
        /// <typeparamref name="Result.True"/> Cancellation status if the store receipt's indicates this subscription is cancelled.
        /// <typeparamref name="Result.False"/> otherwise.
        /// Non-renewable subscriptions in the Apple store return a <typeparamref name="Result.Unsupported"/> value.
        /// </returns>
        public Result isCancelled() { return is_cancelled; }

        /// <summary>
        /// Indicates whether this Product is a free trial.
        /// Note the store-specific behavior.
        /// </summary>
        /// <returns>
        /// <typeparamref name="Result.True"/> This subscription is a free trial according to the store receipt.
        /// <typeparamref name="Result.False"/> This subscription is not a free trial according to the store receipt.
        /// Non-renewable subscriptions in the Apple store
        /// and Google subscriptions queried on devices with version lower than 6 of the Android in-app billing API return a <typeparamref name="Result.Unsupported"/> value.
        /// </returns>
        public Result isFreeTrial() { return is_free_trial; }

        /// <summary>
        /// Indicates whether this Product is expected to auto-renew. The product must be auto-renewable, not canceled, and not expired.
        /// </summary>
        /// <returns>
        /// <typeparamref name="Result.True"/> The store receipt's indicates this subscription is auto-renewing.
        /// <typeparamref name="Result.False"/> The store receipt's indicates this subscription is not auto-renewing.
        /// Non-renewable subscriptions in the Apple store return a <typeparamref name="Result.Unsupported"/> value.
        /// </returns>
        public Result isAutoRenewing() { return is_auto_renewing; }

        /// <summary>
        /// Indicates how much time remains until the next billing date.
        /// Note the store-specific behavior.
        /// Note also that the receipt may update and change this subscription expiration status if the user sends
        /// their iOS app to the background and then returns it to the foreground.
        /// </summary>
        /// <returns>
        /// A time duration from now until subscription billing occurs.
        /// Google subscriptions queried on devices with version lower than 6 of the Android in-app billing API return <typeparamref name="TimeSpan.MaxValue"/>.
        /// </returns>
        /// <seealso cref="DateTime.UtcNow"/>
        public TimeSpan getRemainingTime() { return remainedTime; }

        /// <summary>
        /// Indicates whether this Product is currently owned within an introductory price period.
        /// Note the store-specific behavior.
        /// </summary>
        /// <returns>
        /// <typeparamref name="Result.True"/> The store receipt's indicates this subscription is within its introductory price period.
        /// <typeparamref name="Result.False"/> The store receipt's indicates this subscription is not within its introductory price period.
        /// <typeparamref name="Result.False"/> If the product is not configured to have an introductory period.
        /// Non-renewable subscriptions in the Apple store return a <typeparamref name="Result.Unsupported"/> value.
        /// Google subscriptions queried on devices with version lower than 6 of the Android in-app billing API return a <typeparamref name="Result.Unsupported"/> value.
        /// </returns>
        public Result isIntroductoryPricePeriod() { return is_introductory_price_period; }

        /// <summary>
        /// Indicates how much time remains for the introductory price period.
        /// Note the store-specific behavior.
        /// </summary>
        /// <returns>
        /// Duration remaining in this product's introductory price period.
        /// Subscription products with no introductory price period return <typeparamref name="TimeSpan.Zero"/>.
        /// Products in the Apple store return <typeparamref name="TimeSpan.Zero"/> if the application does
        /// not support iOS version 11.2+, macOS 10.13.2+, or tvOS 11.2+.
        /// <typeparamref name="TimeSpan.Zero"/> returned also for products which do not have an introductory period configured.
        /// </returns>
        public TimeSpan getIntroductoryPricePeriod() { return introductory_price_period; }

        /// <summary>
        /// For subscriptions with an introductory price, get this price.
        /// Note the store-specific behavior.
        /// </summary>
        /// <returns>
        /// For subscriptions with a introductory price, a localized price string.
        /// For Google store the price may not include the currency symbol (e.g. $) and the currency code is available in <typeparamref name="ProductMetadata.isoCurrencyCode"/>.
        /// For all other product configurations, the string <c>"not available"</c>.
        /// </returns>
        /// <seealso cref="ProductMetadata.isoCurrencyCode"/>
        public string getIntroductoryPrice() { return string.IsNullOrEmpty(introductory_price) ? "not available" : introductory_price; }

        /// <summary>
        /// Indicates the number of introductory price billing periods that can be applied to this subscription Product.
        /// Note the store-specific behavior.
        /// </summary>
        /// <returns>
        /// Products in the Apple store return <c>0</c> if the application does not support iOS version 11.2+, macOS 10.13.2+, or tvOS 11.2+.
        /// <c>0</c> returned also for products which do not have an introductory period configured.
        /// </returns>
        /// <seealso cref="intro"/>
        public long getIntroductoryPricePeriodCycles() { return introductory_price_cycles; }

        /// <summary>
        /// When this auto-renewable receipt expires.
        /// </summary>
        /// <returns>
        /// An absolute date when this receipt will expire.
        /// </returns>
        public DateTime getExpireDate() { return subscriptionExpireDate; }

        /// <summary>
        /// When this auto-renewable receipt was canceled.
        /// Note the store-specific behavior.
        /// </summary>
        /// <returns>
        /// For Apple store, the date when this receipt was canceled.
        /// For other stores this will be <c>null</c>.
        /// </returns>
        public DateTime getCancelDate() { return subscriptionCancelDate; }

        /// <summary>
        /// The period duration of the free trial for this subscription, if enabled.
        /// Note the store-specific behavior.
        /// </summary>
        /// <returns>
        /// For Google Play store if the product is configured with a free trial, this will be the period duration.
        /// For Apple store this will be <c> null </c>.
        /// </returns>
        public TimeSpan getFreeTrialPeriod() { return freeTrialPeriod; }

        /// <summary>
        /// The duration of this subscription.
        /// Note the store-specific behavior.
        /// </summary>
        /// <returns>
        /// A duration this subscription is valid for.
        /// <typeparamref name="TimeSpan.Zero"/> returned for Apple products.
        /// </returns>
        public TimeSpan getSubscriptionPeriod() { return subscriptionPeriod; }

        /// <summary>
        /// The string representation of the period in ISO8601 format this subscription is free for.
        /// Note the store-specific behavior.
        /// </summary>
        /// <returns>
        /// For Google Play store on configured subscription this will be the period which the can own this product for free, unless
        /// the user is ineligible for this free trial.
        /// For Apple store this will be <c> null </c>.
        /// </returns>
        public string getFreeTrialPeriodString() { return free_trial_period_string; }

        /// <summary>
        /// The raw JSON SkuDetails from the underlying Google API.
        /// Note the store-specific behavior.
        /// Note this is not supported.
        /// </summary>
        /// <returns>
        /// For Google store the <c> SkuDetails#getOriginalJson </c> results.
        /// For Apple this returns <c>null</c>.
        /// </returns>
        public string getSkuDetails() { return sku_details; }

        /// <summary>
        /// A JSON including a collection of data involving free-trial and introductory prices.
        /// Note the store-specific behavior.
        /// Used internally for subscription updating on Google store.
        /// </summary>
        /// <returns>
        /// A JSON with keys: <c>productId</c>, <c>is_free_trial</c>, <c>is_introductory_price_period</c>, <c>remaining_time_in_seconds</c>.
        /// </returns>
        /// <seealso cref="SubscriptionManager.UpdateSubscription"/>
        public string getSubscriptionInfoJsonString()
        {
            var dict = new Dictionary<string, object>
            {
                { "productId", productId },
                { "is_free_trial", is_free_trial },
                { "is_introductory_price_period", is_introductory_price_period == Result.True },
                { "remaining_time_in_seconds", remainedTime.TotalSeconds }
            };
            return MiniJson.JsonEncode(dict);
        }

        private DateTime nextBillingDate(DateTime billing_begin_date, TimeSpanUnits units)
        {

            if (units.days == 0.0 && units.months == 0 && units.years == 0)
            {
                return new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc);
            }

            var next_billing_date = billing_begin_date;
            // find the next billing date that after the current date
            while (DateTime.Compare(next_billing_date, DateTime.UtcNow) <= 0)
            {

                next_billing_date = next_billing_date.AddDays(units.days).AddMonths(units.months).AddYears(units.years);
            }
            return next_billing_date;
        }

        private TimeSpan accumulateIntroductoryDuration(TimeSpanUnits units, long cycles)
        {
            var result = TimeSpan.Zero;
            for (long i = 0; i < cycles; i++)
            {
                result = result.Add(computePeriodTimeSpan(units));
            }
            return result;
        }

        private TimeSpan computePeriodTimeSpan(TimeSpanUnits units)
        {
            var now = DateTime.Now;
            return now.AddDays(units.days).AddMonths(units.months).AddYears(units.years).Subtract(now);
        }


        private double computeExtraTime(string metadata, double new_sku_period_in_seconds)
        {
            var wrapper = (Dictionary<string, object>)MiniJson.JsonDecode(metadata);
            var old_sku_remaining_seconds = (long)wrapper["old_sku_remaining_seconds"];
            var old_sku_price_in_micros = (long)wrapper["old_sku_price_in_micros"];

            var old_sku_period_in_seconds = parseTimeSpan((string)wrapper["old_sku_period_string"]).TotalSeconds;
            var new_sku_price_in_micros = (long)wrapper["new_sku_price_in_micros"];
            var result = old_sku_remaining_seconds / (double)old_sku_period_in_seconds * old_sku_price_in_micros / new_sku_price_in_micros * new_sku_period_in_seconds;
            return result;
        }

        private TimeSpan parseTimeSpan(string period_string)
        {
            TimeSpan result;
            try
            {
                result = XmlConvert.ToTimeSpan(period_string);
            }
            catch (Exception)
            {
                if (period_string == null || period_string.Length == 0)
                {
                    result = TimeSpan.Zero;
                }
                else
                {
                    // .Net "P1W" is not supported and throws a FormatException
                    // not sure if only weekly billing contains "W"
                    // need more testing
                    result = new TimeSpan(7, 0, 0, 0);
                }
            }
            return result;
        }

        private TimeSpanUnits parsePeriodTimeSpanUnits(string time_span)
        {
            switch (time_span)
            {
                case "P1W":
                    // weekly subscription
                    return new TimeSpanUnits(7.0, 0, 0);
                case "P1M":
                    // monthly subscription
                    return new TimeSpanUnits(0.0, 1, 0);
                case "P3M":
                    // 3 months subscription
                    return new TimeSpanUnits(0.0, 3, 0);
                case "P6M":
                    // 6 months subscription
                    return new TimeSpanUnits(0.0, 6, 0);
                case "P1Y":
                    // yearly subscription
                    return new TimeSpanUnits(0.0, 0, 1);
                default:
                    // seasonal subscription or duration in days
                    return new TimeSpanUnits(parseTimeSpan(time_span).Days, 0, 0);
            }
        }


    }


    /// <summary>
    /// For representing boolean values which may also be not available.
    /// </summary>
    public enum Result
    {
        /// <summary>
        /// Corresponds to boolean <c> true </c>.
        /// </summary>
        True,
        /// <summary>
        /// Corresponds to boolean <c> false </c>.
        /// </summary>
        False,
        /// <summary>
        /// Corresponds to no value, such as for situations where no result is available.
        /// </summary>
        Unsupported,
    };

    /// <summary>
    /// Used internally to parse Apple receipts. Corresponds to Apple SKProductPeriodUnit.
    /// </summary>
    /// <see cref="https://developer.apple.com/documentation/storekit/skproductperiodunit?language=objc"/>
    public enum SubscriptionPeriodUnit
    {
        /// <summary>
        /// An interval lasting one day.
        /// </summary>
        Day = 0,
        /// <summary>
        /// An interval lasting one month.
        /// </summary>
        Month = 1,
        /// <summary>
        /// An interval lasting one week.
        /// </summary>
        Week = 2,
        /// <summary>
        /// An interval lasting one year.
        /// </summary>
        Year = 3,
        /// <summary>
        /// Default value when no value is available.
        /// </summary>
        NotAvailable = 4,
    };

    enum AppleStoreProductType
    {
        NonConsumable = 0,
        Consumable = 1,
        NonRenewingSubscription = 2,
        AutoRenewingSubscription = 3,
    };

    /// <summary>
    /// Error found during receipt parsing.
    /// </summary>
    public class ReceiptParserException : Exception
    {
        /// <summary>
        /// Construct an error object for receipt parsing.
        /// </summary>
        public ReceiptParserException() { }

        /// <summary>
        /// Construct an error object for receipt parsing.
        /// </summary>
        /// <param name="message">Description of error</param>
        public ReceiptParserException(string message) : base(message) { }
    }

    /// <summary>
    /// An error was found when an invalid <typeparamref name="Product.definition.type"/> is provided.
    /// </summary>
    public class InvalidProductTypeException : ReceiptParserException { }

    /// <summary>
    /// An error was found when an unexpectedly null <typeparamref name="Product.definition.id"/> is provided.
    /// </summary>
    public class NullProductIdException : ReceiptParserException { }

    /// <summary>
    /// An error was found when an unexpectedly null <typeparamref name="Product.receipt"/> is provided.
    /// </summary>
    public class NullReceiptException : ReceiptParserException { }

    /// <summary>
    /// An error was found when an unsupported app store <typeparamref name="Product.receipt"/> is provided.
    /// </summary>
    public class StoreSubscriptionInfoNotSupportedException : ReceiptParserException
    {
        /// <summary>
        /// An error was found when an unsupported app store <typeparamref name="Product.receipt"/> is provided.
        /// </summary>
        /// <param name="message">Human readable explanation of this error</param>
        public StoreSubscriptionInfoNotSupportedException(string message) : base(message)
        {
        }
    }
}