using DidabuCloud.Unity.Core.NetWorking;
using Mogafa.App.Assets;
using Mogafa.App.Assets.EventIntercepts;
using Mogafa.Common;
using Mogafa.Common.HttpClients;
using Newtonsoft.Json;
using System.Collections.Generic;
using System.Threading.Tasks;
using System.Linq;
using Mogafa.App.LogEvents;

namespace DidabuCloud.Unity.Core
{
    public partial class Didabu : MogafaBase
    {
        private bool enableAssetStatistical = false;
        private AssetChangedEventGenerator assetChangedEventGenerator = null;
        private readonly string AssetsLocalStoragePrefixKey = "DidabuAssetsLocalStorageKey";
        private UserAsset userAsset = null;
        private float purchase = 0;
        private float cumulativePurchase = 0;
        private readonly string didabuAdPurchaseDataKey = "didabuAdPurchaseDataKey";

        internal string GetAssetLeaderboardsUrl
        {
            get
            {
                return BaseUrl + "application/assetLeaderboard";
            }
        }
        internal string GetRedeemLeaderboardsUrl
        {
            get
            {
                return BaseUrl + "redeem/leaderboard";
            }
        }
        internal async Task<UserAsset> GetUserAsset()
        {
            if (userAsset != null)
            {
                return userAsset;
            }
            var key = AssetsLocalStoragePrefixKey;
            //if (!string.IsNullOrEmpty(DidabuId))
            //{
            //    key = $"{key}_{DidabuId}";
            //}
            userAsset = await LocalStorage.Get<UserAsset>(key);
            if (userAsset == null)
            {
                userAsset = new UserAsset();
                await LocalStorage.Set(key, userAsset);
            }
            return userAsset;

        }
        private async Task SetUserAsset()
        {
            if (userAsset == null)
            {
                return;
            }
            var key = AssetsLocalStoragePrefixKey;
            //if (!string.IsNullOrEmpty(DidabuId))
            //{
            //    key = $"{key}_{DidabuId}";
            //}
            Logger.LogDebug($"set userAssets:Key:{key},{JsonConvert.SerializeObject(userAsset)}");
            await LocalStorage.Set(key, userAsset);
        }
        public async Task<long> AddAsset(string code, long value)
        {
            var asset = await GetUserAsset();
            var banlance = asset.AddAsset(code, value);
            await SetUserAsset();
            return banlance;
        }

        public async Task<long> SubAsset(string code, long value)
        {
            var asset = await GetUserAsset();
            var banlance = asset.SubAsset(code, value);
            await SetUserAsset();
            return banlance;
        }
        public async Task<long> GetAsset(string code, long value)
        {
            var asset = await GetUserAsset();
            var banlance = asset.GetAsset(code);
            return banlance;
        }
        public async void EnableAssetChangedEvent(List<AssetChangedEventConfiguration> assetChangedEventConfigurations)
        {
            if (assetChangedEventGenerator != null && this.userAsset != null)
            {
                this.userAsset.AssetIncreased -= assetChangedEventGenerator.AssetIncreasedCallback;
            }
            assetChangedEventGenerator = new AssetChangedEventGenerator(assetChangedEventConfigurations);
            var userAsset = await GetUserAsset();
            userAsset.AssetIncreased += assetChangedEventGenerator.AssetIncreasedCallback;

        }
        public async void EnableAssetStatistical()
        {
            if (enableAssetStatistical)
            {
                return;
            }
            var userAsset = await GetUserAsset();
            userAsset.AssetIncreased += UserAssetAssetForStatistical;
            userAsset.AssetReduced += UserAssetAssetForStatistical;
            enableAssetStatistical = true;
        }

        private async void UserAssetAssetForStatistical(string assetCode, long newValue, long oldValue)
        {
            var utcNow = RemoteUtcTimestamp;
            var userStatisticals = userAsset.PeriodicAssets;
            if (userStatisticals == null)
            {
                userStatisticals = new List<UserPeriodicAsset>();
            }
            var configs = Config.GetPeriodicAssets(assetCode, utcNow);
            foreach (var config in configs)
            {
                var assetStatistical = userStatisticals.FirstOrDefault(s => s.StartTime == config.StartTime &&
                s.EndTime == config.EndTime && s.AssetCode == assetCode);
                if (assetStatistical == null)
                {
                    assetStatistical = config;
                    assetStatistical.AccountId = User.DidabuId;
                    assetStatistical.AssetDeltaValue = 0;
                    userStatisticals.Add(assetStatistical);
                }
                if (newValue > oldValue)
                {
                    assetStatistical.Income += newValue - oldValue;
                }
                else
                {
                    assetStatistical.Consumption += oldValue - newValue;
                }
                assetStatistical.AssetDeltaValue += newValue - oldValue;
            }
            userStatisticals.ForEach(s =>
            {
                if (s.EndTime <= utcNow)
                {
                    s.IsPeriodEnded = true;
                }
            });
            userAsset.PeriodicAssets = userStatisticals;
            await SetUserAsset();
        }

        public void EnableAssetEventParameter(string assetEventParameterName)
        {
            if (string.IsNullOrEmpty(assetEventParameterName))
            {

                assetEventParameterName = "";
            }
            var assetAccessor = new DidabuAssetAccessor(this);
            var intercept = new AssetEventIntercept(assetAccessor, assetEventParameterName);
            LogEventReporter.AddIntercept(intercept);
        }
        public async Task<List<AssetLeaderboardDto>> GetAssetLeaderboards(string periodCode, AssetLeaderboardType leaderboardType, string assetCode)
        {
            var dto = new AssetLeaderboardDto();
            dto.Code = "1";
            dto.Name = "";
            dto.Value = 0;
            dto.Id = 1;
            var url = $"{GetAssetLeaderboardsUrl}?appId={AppId}&accountId={User.DidabuId}&periodCode={periodCode}&leaderboardType={leaderboardType}&assetCode={assetCode}";
            var leaderboards = new List<AssetLeaderboardDto>();
            var response = await HttpUtility.Get<List<AssetLeaderboardDto>>(url);
            if (response.Code == HttpStatusCodes.OK && response.IsSuccessful)
            {
                leaderboards = response.Data;
            }
            else
            {
                Logger.LogError($"get asset leaderboards error:{response.Message}");
            }
            return leaderboards;
        }
        public async Task<List<AssetLeaderboardDto>> GetRedeemLeaderboards(string periodCode)
        {
            var dto = new AssetLeaderboardDto();
            dto.Code = "1";
            dto.Name = "";
            dto.Value = 0;
            dto.Id = 1;
            var url = $"{GetAssetLeaderboardsUrl}?appId={AppId}&accountId={User.DidabuId}&periodCode={periodCode}";
            var leaderboards = new List<AssetLeaderboardDto>();
            var response = await HttpUtility.Get<List<AssetLeaderboardDto>>(url);
            if (response.Code == HttpStatusCodes.OK && response.IsSuccessful)
            {
                leaderboards = response.Data;
            }
            return leaderboards;
        }
        public void Purchase(float value)
        {
            purchase += value;
            cumulativePurchase += value;
            SavePurchaseData();
        }
        public Task<float> GetCumulativePurchase()
        {
            return Task.FromResult(cumulativePurchase);
        }
        public Task<float> GetPurchase()
        {
            return Task.FromResult(purchase);
        }
        private float GetPurchaseData()
        {
            return LocalStorage.GetFloat(didabuAdPurchaseDataKey).Result;
        }
        private void SavePurchaseData()
        {
            LocalStorage.SetFloat(didabuAdPurchaseDataKey, cumulativePurchase).Wait();
            LocalStorage.Save().Wait();
        }
    }
}