using DidabuCloud.Unity.Core.NetWorking;
using Mogafa.Common;
using Mogafa.Common.Utils;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using UnityEngine.Networking;

namespace DidabuCloud.Unity.Core
{
    public partial class Didabu : MogafaBase
    {
        private readonly string didabuCoreConfigKey = "DidabuCoreConfigKey";
        private readonly string abGroupWeightStrategyName = "Weight";
        private readonly int getConfigMaxRetyTimes = 3;
        private int getConfigRetyTimes = 0;

        protected string ConfigUrl
        {
            get
            {
                return $"{BaseUrl}application/config?appId={AppId}&appVersion={UnityEngine.Application.version}";
            }
        }

        private List<AbGroupDto> abGroups;
        public IEnumerable<AbGroupDto> AbGroups
        {
            get
            {
                return abGroups;
            }
        }
        public void SetAbGroup(string groupName, string value)
        {

            if (abGroups == null)
            {
                abGroups = new List<AbGroupDto>();
            }
            var abGroup = abGroups.FirstOrDefault(ab => ab.Name == groupName);
            if (abGroup != null)
            {
                abGroups.Remove(abGroup);
            }
            abGroup = new AbGroupDto
            {
                Name = groupName,
                Value = value,
                Time = LocalTimestamp
            };
            abGroups.Add(abGroup);
            AddCommonEventParameter("abGroups", JsonConvert.SerializeObject(abGroups));
            SaveDidabuData();
        }
        public bool IsAbGroup(string groupName, string value)
        {
            var abGroup = AbGroups.FirstOrDefault(ab => ab.Name == groupName);
            if (abGroup != null && abGroup.Value != value)
            {
                return false;
            }
            if (abGroup == null)
            {
                if (Config.AbGroupConfigurations == null || Config.AbGroupConfigurations.Count == 0)
                {
                    return false;
                }
                var abConfig = Config.AbGroupConfigurations.FirstOrDefault(ab => ab.Name == groupName);
                if (abConfig == null)
                {
                    return false;
                }
                abGroup = new AbGroupDto
                {
                    Name = groupName,
                    AbGroupConfigTime = abConfig.LastModifyTime,
                    Time = RemoteUtcTimestamp
                };
                abGroups.Add(abGroup);
                abGroup.Value = GetAbGroupValueByConfig(abConfig);
                if (abGroups != null && abGroups.Count > 0)
                {
                    AddCommonEventParameter("abGroups", JsonConvert.SerializeObject(abGroups));
                }
                SaveDidabuData();
                Logger.LogWarning($"Generate ab group local, group name:{groupName},value:{abGroup.Value}");
            }
            return abGroup.Value == value;
        }
        public DidabuCoreConfig Config { get; private set; }
        private string controlData;
        public string ControlData
        {
            get
            {
                if (!string.IsNullOrEmpty(controlData))
                {
                    return controlData;
                }
                if (Config == null)
                {
                    return "";
                }
                if (Config.AbGroupConfigurations == null || Config.AbGroupConfigurations.Count == 0 ||
                    Config.AbGroupControlDatas == null || Config.AbGroupControlDatas.Count == 0)
                {
                    controlData = Config.ControlData;
                }
                else
                {
                    if (abGroups == null)
                    {
                        abGroups = new List<AbGroupDto>();
                    }
                    foreach (var abGroupConfig in Config.AbGroupConfigurations)
                    {
                        var abGroup = abGroups.FirstOrDefault(ab => ab.Name == abGroupConfig.Name);
                        if (abGroup == null)
                        {
                            var abGroupValue = GetAbGroupValueByConfig(abGroupConfig);
                            abGroup = new AbGroupDto
                            {
                                AbGroupConfigTime = abGroupConfig.LastModifyTime,
                                Name = abGroupConfig.Name,
                                Time = RemoteUtcTimestamp,
                                Value = abGroupValue
                            };
                            abGroups.Add(abGroup);
                        }
                        var abGroupControlData = Config.AbGroupControlDatas.FirstOrDefault(ab => ab.AbGroupName == abGroupConfig.Name && ab.AbGroupValue == abGroup.Value);
                        if (abGroupControlData != null && !string.IsNullOrEmpty(abGroupControlData.ControlData))
                        {
                            controlData = abGroupControlData.ControlData;
                        }
                    }
                    if (abGroups != null && abGroups.Count > 0)
                    {
                        AddCommonEventParameter("abGroups", JsonConvert.SerializeObject(abGroups));
                    }
                }
                SaveDidabuData();
                return controlData;
            }
        }
        public event Action<DidabuCoreConfig> OnGetConfigurationSuccessed;
        private async Task InitConfiguration(DidabuCoreConfig defaultConfig)
        {
            var localConfig = GetConfigFromFile();
            if (localConfig == null && defaultConfig != null)
            {
                localConfig = defaultConfig;
                SaveConfigToFile(localConfig);
            }
            if (localConfig.ControlDataVersion < defaultConfig.ControlDataVersion)
            {
                localConfig = defaultConfig;
                SaveConfigToFile(localConfig);
            }
            Config = localConfig;
            InitByConfig();
            await GetConfig();
        }
        private string GetAbGroupValueByConfig(AbGroupConfigurationDto abGroupConfiguration)
        {
            if (abGroupConfiguration.StrategyName != abGroupWeightStrategyName)
            {
                return abGroupConfiguration.DefaultValue;
            }
            var weightObjects = abGroupConfiguration.Values.Select(ab => new AbGroupValueWeight
            {
                Value = ab,
                Weight = int.Parse(ab.StrategyValue)
            }).ToList();
            var weightObject = WeightUtil.GetObject(weightObjects) as AbGroupValueWeight;
            return weightObject.Value.Value;
        }
        private DidabuCoreConfig GetConfigFromFile()
        {
            DidabuCoreConfig config = null;
            var path = Path.Combine(UnityEngine.Application.persistentDataPath, $"{didabuCoreConfigKey}.dat");
            if (!File.Exists(path))
            {
                Logger.LogInformation($"The file {path} is not exist.");
                return config;
            }
            try
            {
                var json = File.ReadAllText(path);
                config = JsonConvert.DeserializeObject<DidabuCoreConfig>(json);
            }
            catch (Exception ex)
            {
                Logger.LogError($"Read config from file error, file:{path}\nmessge:{ex.Message}");
            }
            return config;
        }
        private void SaveConfigToFile(DidabuCoreConfig config)
        {
            var path = Path.Combine(UnityEngine.Application.persistentDataPath, $"{didabuCoreConfigKey}.dat");
            try
            {
                var json = JsonConvert.SerializeObject(config);
                File.WriteAllText(path, json);
            }
            catch (Exception ex)
            {
                Logger.LogError($"Save config to file error,file:{path}\nmessage:{ex.Message}");
            }
        }
        private async Task GetConfig()
        {
            var url = ConfigUrl;
            if (abGroups != null && abGroups.Count != 0)
            {
                var abGroupsJson = JsonConvert.SerializeObject(abGroups);

                url += $"&abGroups={UnityWebRequest.EscapeURL(abGroupsJson)}";
            }
            var result = await HttpUtility.Get<DidabuCoreConfig>(url);

            if (result.IsSuccessful)
            {
                Config = result.Data;
                SaveConfigToFile(Config);
                if (abGroups == null || abGroups.Count == 0)
                {
                    foreach (var abGroup in Config.AbGroups)
                    {
                        if (abGroups == null)
                        {
                            abGroups = new List<AbGroupDto>();
                        }
                        var oldGroups = abGroups.Where(ab => ab.Name == abGroup.Name).ToList();
                        foreach (var oldGroup in oldGroups)
                        {
                            abGroups.Remove(oldGroup);
                        }
                        if (abGroups.FirstOrDefault(ab => ab.Name == abGroup.Name) == null)
                        {
                            abGroups.Add(new AbGroupDto
                            {
                                Name = abGroup.Name,
                                Value = abGroup.Value,
                                AbGroupConfigTime = abGroup.AbGroupConfigTime,
                                Time = abGroup.Time
                            });
                        }
                    }
                }
                controlData = Config.ControlData;
                SaveDidabuData();
                InitByConfig();
                OnGetConfigurationSuccessed?.Invoke(Config);
                Logger.LogDebug($"Config:{JsonConvert.SerializeObject(Config)}");
            }
            else
            {
                getConfigRetyTimes++;
                Logger.LogInformation($"Retry get config, times:{getConfigRetyTimes}");
                if (getConfigRetyTimes <= getConfigMaxRetyTimes)
                {
                    AddTask(500, 500, 1, GetConfig);
                }
            }
        }
        private void InitByConfig()
        {
            if (Config != null)
            {
                EnableAbGroup(Config.AbGroupEvents);
                EnableEventCounter(Config.EventCounters);
                EnableAssetChangedEvent(Config.AssetChangedEvents);
                EnableAssetEventParameter(Config.AssetEventParameterName);
                AddCommonEventParameter("controlDataVersion", Config.ControlDataVersion.ToString());
                if (Config.AbGroups != null && Config.AbGroups.Count > 0)
                {
                    AddCommonEventParameter("abGroups", JsonConvert.SerializeObject(Config.AbGroups));
                }
            }
        }
    }
}