using Mogafa.Common;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace Mogafa.App.LogEvents
{
    /// <summary>
    /// 理想的使用方式：
    /// LogEventReporter.Init(commonEventParameters)
    /// .EnableAbGroup(abGroups, abGroupEventNames)
    /// .UseAppsflyer(appsflyerEventNameMap, appsflyerEventParameterNameMap)
    /// .UseFirebase(firebaseEventNameMap, firebaseEventParameterNameMap);
    /// LogEventReporter.LogEvent(name, parameters);
    /// </summary>
    public abstract class EventReporterAbstract : MogafaBase, ILogEventReporter
    {
        /// <summary>
        /// 名称
        /// </summary>
        public abstract string Name { get; }
        protected List<string> enabledEventNames;
        /// <summary>
        /// 通用事件参数, 每次上报事件时都需要的事件参数 比如用户ID等
        /// 这个配置是和不同log event Provider不想关
        /// </summary>
        protected Dictionary<string, string> commonEventParameters;
        /// <summary>
        /// 事件名称映射表，
        /// 每个不同的log event Provider配置不一样
        /// </summary>
        protected Dictionary<string, string> eventNameMap;
        /// <summary>
        /// 时间参数名称映射表
        /// 每个不同的log event Provider配置不一样
        /// </summary>
        protected Dictionary<string, string> eventParameterNameMap;

        protected EventReporterAbstract()
        {
            commonEventParameters = new Dictionary<string, string>();
        }

        public Task Initialize(List<string> enabledEventNames,
            Dictionary<string, string> eventNameMap,
            Dictionary<string, string> eventParameterNameMap)
        {
            Logger.LogInformation($"Log event reporter {Name} init start.");
            this.eventNameMap = eventNameMap;
            if (this.eventNameMap == null)
            {
                this.eventNameMap = new Dictionary<string, string>();
            }
            this.eventParameterNameMap = eventParameterNameMap;
            if (this.eventParameterNameMap == null)
            {
                this.eventParameterNameMap = new Dictionary<string, string>();
            }
            this.enabledEventNames = enabledEventNames;
            if (this.enabledEventNames == null)
            {
                this.enabledEventNames = new List<string>();
            }
            Logger.LogInformation($"Log event reporter {Name} init finished.");
            AfterInitialize(this.enabledEventNames, this.eventNameMap, this.eventParameterNameMap);
            return Task.CompletedTask;
        }
        protected virtual void AfterInitialize(List<string> enabledEventNames,
            Dictionary<string, string> eventNameMap,
            Dictionary<string, string> eventParameterNameMap)
        {

        }
        public void AddCommonEventParameter(string eventParameterName, string value)
        {
            if (commonEventParameters.ContainsKey(eventParameterName))
            {
                commonEventParameters.Remove(eventParameterName);
            }
            commonEventParameters.Add(eventParameterName, value);
            AfterAddCommonEventParameter(eventParameterName, value);
        }
        protected virtual void AfterAddCommonEventParameter(string eventParameterName, string value)
        {

        }
        public Task LogEvent(string name, Dictionary<string, string> eventParameters)
        {
            if (enabledEventNames.Count > 0)
            {
                var needReportEvent = enabledEventNames.Where(en =>
                (en.EndsWith("_") && (name.StartsWith(en) || name == en.Substring(0, en.Length - 1)) ||
                (!en.EndsWith("_") && name == en)));
                if (needReportEvent == null || needReportEvent.Count() == 0)
                {
                    return Task.CompletedTask;
                }
            }
            Logger.LogInformation($"Log event to: {Name}, event name: {name}");
            var cloneEventParameters = new Dictionary<string, string>();
            foreach(var commonParameter in commonEventParameters)
            {
                cloneEventParameters.Add(commonParameter.Key, commonParameter.Value);
            }
            foreach (var parameter in eventParameters)
            {
                if (!cloneEventParameters.ContainsKey(parameter.Key))
                {
                    cloneEventParameters.Add(parameter.Key, parameter.Value);
                }
                else
                {
                    cloneEventParameters[parameter.Key] = parameter.Value;
                }
            }
            var mapName = MapName(name, eventNameMap);
            var mapEventParameters = new Dictionary<string, string>();
            foreach (var parameter in cloneEventParameters)
            {
                var mapParameterName = MapName(parameter.Key, eventParameterNameMap);
                mapEventParameters.Add(mapParameterName, parameter.Value);
            }
            return LogEventInternal(mapName, mapEventParameters);
        }
        protected string MapName(string eventName, Dictionary<string, string> nameMap)
        {
            if (nameMap == null || nameMap.Count == 0)
            {
                return eventName;
            }
            var needMapName = nameMap.Keys.FirstOrDefault(nm =>
                (nm.EndsWith("_") && (eventName.StartsWith(nm) || eventName == nm.Substring(0, nm.Length - 1)) ||
                (!nm.EndsWith("_") && eventName == nm)));
            if (needMapName == null)
            {
                return eventName;
            }
            var mapName = nameMap[needMapName];
            if (!needMapName.EndsWith("_"))
            {
                return mapName;
            }
            needMapName = needMapName.Substring(0, needMapName.Length - 1);
            if (needMapName == eventName)
            {
                return mapName;
            }
            mapName = eventName.Replace($"{needMapName}_", $"{mapName}_");
            if (mapName.EndsWith("_"))
            {
                mapName = mapName.Substring(0, mapName.Length - 1);
            }
            return mapName;
        }
        protected abstract Task LogEventInternal(string name, Dictionary<string, string> eventParameters);

        public void ChangeEnabledEventNames(params string[] eventNames)
        {
            enabledEventNames = new List<string>(eventNames);
        }

        public void ChangeEventNameMap(Dictionary<string, string> eventNameMap)
        {
            this.eventNameMap = eventNameMap;
            if (this.eventNameMap == null)
            {
                this.eventNameMap = new Dictionary<string, string>();
            }
        }

        public void ChangeEventParameterNameMap(Dictionary<string, string> eventParameterNameMap)
        {
            this.eventParameterNameMap = eventParameterNameMap;
            if (this.eventParameterNameMap == null)
            {
                this.eventParameterNameMap = new Dictionary<string, string>();
            }
        }
    }
}