using System;
using System.Collections.Generic;
using GameAnalyticsSDK.Net.Threading;
using GameAnalyticsSDK.Net.Logging;
using GameAnalyticsSDK.Net.State;
using GameAnalyticsSDK.Net.Validators;
using GameAnalyticsSDK.Net.Device;
using GameAnalyticsSDK.Net.Events;
using GameAnalyticsSDK.Net.Store;
#if WINDOWS_UWP || WINDOWS_WSA
using Windows.ApplicationModel;
using Windows.ApplicationModel.Core;
using System.Threading.Tasks;
#else
using System.Threading;
#endif

namespace GameAnalyticsSDK.Net
{
    public static class GameAnalytics
    {
        private static bool _endThread;

        static GameAnalytics()
        {
            _endThread = false;
            GADevice.Touch();
        }

#if !UNITY && !MONO
        public static event Action<string, EGALoggerMessageType> OnMessageLogged;

        internal static void MessageLogged(string message, EGALoggerMessageType type)
        {
            OnMessageLogged?.Invoke(message, type);
        }
#endif


        #region CONFIGURE

        public static void ConfigureAvailableCustomDimensions01(params string[] customDimensions)
        {
            if(_endThread)
            {
                return;
            }

            GAThreading.PerformTaskOnGAThread("configureAvailableCustomDimensions01", () =>
            {
                if (IsSdkReady(true, false))
                {
                    GALogger.W("Available custom dimensions must be set before SDK is initialized");
                    return;
                }
                GAState.AvailableCustomDimensions01 = customDimensions;
            });
        }

        public static void ConfigureAvailableCustomDimensions02(params string[] customDimensions)
        {
            if(_endThread)
            {
                return;
            }

            GAThreading.PerformTaskOnGAThread("configureAvailableCustomDimensions02", () =>
            {
                if (IsSdkReady(true, false))
                {
                    GALogger.W("Available custom dimensions must be set before SDK is initialized");
                    return;
                }
                GAState.AvailableCustomDimensions02 = customDimensions;
            });
        }

        public static void ConfigureAvailableCustomDimensions03(params string[] customDimensions)
        {
            if(_endThread)
            {
                return;
            }

            GAThreading.PerformTaskOnGAThread("configureAvailableCustomDimensions03", () =>
            {
                if (IsSdkReady(true, false))
                {
                    GALogger.W("Available custom dimensions must be set before SDK is initialized");
                    return;
                }
                GAState.AvailableCustomDimensions03 = customDimensions;
            });
        }

        public static void ConfigureAvailableResourceCurrencies(params string[] resourceCurrencies)
        {
            if(_endThread)
            {
                return;
            }

            GAThreading.PerformTaskOnGAThread("configureAvailableResourceCurrencies", () =>
            {
                if (IsSdkReady(true, false))
                {
                    GALogger.W("Available resource currencies must be set before SDK is initialized");
                    return;
                }
                GAState.AvailableResourceCurrencies = resourceCurrencies;
            });
        }

        public static void ConfigureAvailableResourceItemTypes(params string[] resourceItemTypes)
        {
            if(_endThread)
            {
                return;
            }

            GAThreading.PerformTaskOnGAThread("configureAvailableResourceItemTypes", () =>
            {
                if (IsSdkReady(true, false))
                {
                    GALogger.W("Available resource item types must be set before SDK is initialized");
                    return;
                }
                GAState.AvailableResourceItemTypes = resourceItemTypes;
            });
        }

        public static void ConfigureBuild(string build)
        {
            if(_endThread)
            {
                return;
            }

            GAThreading.PerformTaskOnGAThread("configureBuild", () =>
            {
                if (IsSdkReady(true, false))
                {
                    GALogger.W("Build version must be set before SDK is initialized.");
                    return;
                }
                if (!GAValidator.ValidateBuild(build))
                {
                    GALogger.I("Validation fail - configure build: Cannot be null, empty or above 32 length. String: " + build);
                    return;
                }
                GAState.Build = build;
            });
        }

        public static void ConfigureSdkGameEngineVersion(string sdkGameEngineVersion)
        {
            if(_endThread)
            {
                return;
            }

            GAThreading.PerformTaskOnGAThread("configureSdkGameEngineVersion", () =>
            {
                if (IsSdkReady(true, false))
                {
                    return;
                }
                if (!GAValidator.ValidateSdkWrapperVersion(sdkGameEngineVersion))
                {
                    GALogger.I("Validation fail - configure sdk version: Sdk version not supported. String: " + sdkGameEngineVersion);
                    return;
                }
                GADevice.SdkGameEngineVersion = sdkGameEngineVersion;
            });
        }

        public static void ConfigureGameEngineVersion(string gameEngineVersion)
        {
            if(_endThread)
            {
                return;
            }

            GAThreading.PerformTaskOnGAThread("configureGameEngineVersion", () =>
            {
                if (IsSdkReady(true, false))
                {
                    return;
                }
                if (!GAValidator.ValidateEngineVersion(gameEngineVersion))
                {
                    GALogger.I("Validation fail - configure sdk version: Sdk version not supported. String: " + gameEngineVersion);
                    return;
                }
                GADevice.GameEngineVersion = gameEngineVersion;
            });
        }

        public static void ConfigureUserId(string uId)
        {
            if(_endThread)
            {
                return;
            }

            GAThreading.PerformTaskOnGAThread("configureUserId", () =>
            {
                if (IsSdkReady(true, false))
                {
                    GALogger.W("A custom user id must be set before SDK is initialized.");
                    return;
                }
                if (!GAValidator.ValidateUserId(uId))
                {
                    GALogger.I("Validation fail - configure user_id: Cannot be null, empty or above 64 length. Will use default user_id method. Used string: " + uId);
                    return;
                }

                GAState.UserId = uId;
            });
        }

        #endregion // CONFIGURE

        #region INITIALIZE

        public static void Initialize(string gameKey, string gameSecret)
        {
            if(_endThread)
            {
                return;
            }

#if WINDOWS_UWP || WINDOWS_WSA
            CoreApplication.Suspending += OnSuspending;
            CoreApplication.Resuming += OnResuming;
#endif
            GADevice.UpdateConnectionType();

            GAThreading.PerformTaskOnGAThread("initialize", () =>
            {
                if (IsSdkReady(true, false))
                {
                    GALogger.W("SDK already initialized. Can only be called once.");
                    return;
                }
                if (!GAValidator.ValidateKeys(gameKey, gameSecret))
                {
                    GALogger.W("SDK failed initialize. Game key or secret key is invalid. Can only contain characters A-z 0-9, gameKey is 32 length, gameSecret is 40 length. Failed keys - gameKey: " + gameKey + ", secretKey: " + gameSecret);
                    return;
                }

                GAState.SetKeys(gameKey, gameSecret);

                if (!GAStore.EnsureDatabase(false, gameKey))
                {
                    GALogger.W("Could not ensure/validate local event database: " + GADevice.WritablePath);
                }

                GAState.InternalInitialize();
            });
        }

#if WINDOWS_UWP || WINDOWS_WSA
        private static async void OnSuspending(object sender, SuspendingEventArgs e)
        {
            var deferral = e.SuspendingOperation.GetDeferral();
            await WaitOnSuspend();
            deferral.Complete();
        }

        private static async Task WaitOnSuspend()
        {
            if (!GAState.UseManualSessionHandling)
            {
                OnSuspend();

                while (!GAThreading.IsThreadFinished())
                {
                    await Task.Delay(100);
                }
            }
            else
            {
                GALogger.I("OnSuspending: Not calling GameAnalytics.OnStop() as using manual session handling");
            }
        }

        private static void OnResuming(object sender, object e)
        {
            GAThreading.PerformTaskOnGAThread("onResuming", () =>
            {
                if(!GAState.UseManualSessionHandling)
                {
                    OnResume();
                }
                else
                {
                    GALogger.I("OnResuming: Not calling GameAnalytics.OnResume() as using manual session handling");
                }
            });
        }
#endif

        #endregion // INITIALIZE

        #region ADD EVENTS

        public static void AddBusinessEvent(string currency, int amount, string itemType, string itemId, string cartType/*, IDictionary<string, object> fields = null*/)
        {
            if(_endThread)
            {
                return;
            }

            GADevice.UpdateConnectionType();

            GAThreading.PerformTaskOnGAThread("addBusinessEvent", () =>
            {
                if (!IsSdkReady(true, true, "Could not add business event"))
                {
                    return;
                }
                // Send to events
                GAEvents.AddBusinessEvent(currency, amount, itemType, itemId, cartType, null);
            });
        }

        public static void AddResourceEvent(EGAResourceFlowType flowType, string currency, float amount, string itemType, string itemId/*, IDictionary<string, object> fields = null*/)
        {
            if(_endThread)
            {
                return;
            }

            GADevice.UpdateConnectionType();

            GAThreading.PerformTaskOnGAThread("addResourceEvent", () =>
            {
                if (!IsSdkReady(true, true, "Could not add resource event"))
                {
                    return;
                }

                GAEvents.AddResourceEvent(flowType, currency, amount, itemType, itemId, null);
            });
        }

        public static void AddProgressionEvent(EGAProgressionStatus progressionStatus, string progression01/*, IDictionary<string, object> fields = null*/)
        {
            AddProgressionEvent(progressionStatus, progression01, "", ""/*, fields*/);
        }

        public static void AddProgressionEvent(EGAProgressionStatus progressionStatus, string progression01, double score/*, IDictionary<string, object> fields = null*/)
        {
            AddProgressionEvent(progressionStatus, progression01, "", "", score/*, fields*/);
        }

        public static void AddProgressionEvent(EGAProgressionStatus progressionStatus, string progression01, string progression02/*, IDictionary<string, object> fields = null*/)
        {
            AddProgressionEvent(progressionStatus, progression01, progression02, ""/*, fields*/);
        }

        public static void AddProgressionEvent(EGAProgressionStatus progressionStatus, string progression01, string progression02, double score/*, IDictionary<string, object> fields = null*/)
        {
            AddProgressionEvent(progressionStatus, progression01, progression02, "", score/*, fields*/);
        }

        public static void AddProgressionEvent(EGAProgressionStatus progressionStatus, string progression01, string progression02, string progression03/*, IDictionary<string, object> fields = null*/)
        {
            if(_endThread)
            {
                return;
            }

            GADevice.UpdateConnectionType();

            GAThreading.PerformTaskOnGAThread("addProgressionEvent", () =>
            {
                if(!IsSdkReady(true, true, "Could not add progression event"))
                {
                    return;
                }

                // Send to events
                // TODO(nikolaj): check if this cast from int to double is OK
                GAEvents.AddProgressionEvent(progressionStatus, progression01, progression02, progression03, 0, false, null);
            });
        }

        public static void AddProgressionEvent(EGAProgressionStatus progressionStatus, string progression01, string progression02, string progression03, double score/*, IDictionary<string, object> fields = null*/)
        {
            if(_endThread)
            {
                return;
            }

            GADevice.UpdateConnectionType();

            GAThreading.PerformTaskOnGAThread("addProgressionEvent", () =>
            {
                if (!IsSdkReady(true, true, "Could not add progression event"))
                {
                    return;
                }

                // Send to events
                // TODO(nikolaj): check if this cast from int to double is OK
                GAEvents.AddProgressionEvent(progressionStatus, progression01, progression02, progression03, score, true, null);
            });
        }

        public static void AddDesignEvent(string eventId, IDictionary<string, object> fields = null)
        {
            if(_endThread)
            {
                return;
            }

            GADevice.UpdateConnectionType();

            GAThreading.PerformTaskOnGAThread("addDesignEvent", () =>
            {
                if(!IsSdkReady(true, true, "Could not add design event"))
                {
                    return;
                }
                GAEvents.AddDesignEvent(eventId, 0, false, fields);
            });
        }

        public static void AddDesignEvent(string eventId, double value/*, IDictionary<string, object> fields = null*/)
        {
            if(_endThread)
            {
                return;
            }

            GADevice.UpdateConnectionType();

            GAThreading.PerformTaskOnGAThread("addDesignEvent", () =>
            {
                if (!IsSdkReady(true, true, "Could not add design event"))
                {
                    return;
                }
                GAEvents.AddDesignEvent(eventId, value, true, null);
            });
        }

        public static void AddErrorEvent(EGAErrorSeverity severity, string message/*, IDictionary<string, object> fields = null*/)
        {
            if(_endThread)
            {
                return;
            }

            GADevice.UpdateConnectionType();

            GAThreading.PerformTaskOnGAThread("addErrorEvent", () =>
            {
                if (!IsSdkReady(true, true, "Could not add error event"))
                {
                    return;
                }
                GAEvents.AddErrorEvent(severity, message, null);
            });
        }

        #endregion // ADD EVENTS

        #region SET STATE CHANGES WHILE RUNNING

        public static void SetEnabledInfoLog(bool flag)
        {
            if(_endThread)
            {
                return;
            }

            GAThreading.PerformTaskOnGAThread("setEnabledInfoLog", () =>
            {
                if (flag)
                {
                    GALogger.InfoLog = flag;
                    GALogger.I("Info logging enabled");
                }
                else
                {
                    GALogger.I("Info logging disabled");
                    GALogger.InfoLog = flag;
                }
            });
        }

        public static void SetEnabledVerboseLog(bool flag)
        {
            if(_endThread)
            {
                return;
            }

            GAThreading.PerformTaskOnGAThread("setEnabledVerboseLog", () =>
            {
                if (flag)
                {
                    GALogger.VerboseLog = flag;
                    GALogger.I("Verbose logging enabled");
                }
                else
                {
                    GALogger.I("Verbose logging disabled");
                    GALogger.VerboseLog = flag;
                }
            });
        }

        public static void SetEnabledManualSessionHandling(bool flag)
        {
            if(_endThread)
            {
                return;
            }

            GAThreading.PerformTaskOnGAThread("setEnabledManualSessionHandling", () =>
            {
                GAState.SetManualSessionHandling(flag);
            });
        }

        public static void SetEnabledEventSubmission(bool flag)
        {
            if(_endThread)
            {
                return;
            }

            GAThreading.PerformTaskOnGAThread("setEnabledEventSubmission", () =>
            {
                if (flag)
                {
                    GAState.SetEnabledEventSubmission(flag);
                    GALogger.I("Event submission enabled");
                }
                else
                {
                    GALogger.I("Event submission disabled");
                    GAState.SetEnabledEventSubmission(flag);
                }
            });
        }

        public static void SetCustomDimension01(string dimension)
        {
            if(_endThread)
            {
                return;
            }

            GAThreading.PerformTaskOnGAThread("setCustomDimension01", () =>
            {
                if (!GAValidator.ValidateDimension01(dimension))
                {
                    GALogger.W("Could not set custom01 dimension value to '" + dimension + "'. Value not found in available custom01 dimension values");
                    return;
                }
                GAState.SetCustomDimension01(dimension);
            });
        }

        public static void SetCustomDimension02(string dimension)
        {
            if(_endThread)
            {
                return;
            }

            GAThreading.PerformTaskOnGAThread("setCustomDimension02", () =>
            {
                if (!GAValidator.ValidateDimension02(dimension))
                {
                    GALogger.W("Could not set custom02 dimension value to '" + dimension + "'. Value not found in available custom02 dimension values");
                    return;
                }
                GAState.SetCustomDimension02(dimension);
            });
        }

        public static void SetCustomDimension03(string dimension)
        {
            if(_endThread)
            {
                return;
            }

            GAThreading.PerformTaskOnGAThread("setCustomDimension03", () =>
            {
                if (!GAValidator.ValidateDimension03(dimension))
                {
                    GALogger.W("Could not set custom03 dimension value to '" + dimension + "'. Value not found in available custom03 dimension values");
                    return;
                }
                GAState.SetCustomDimension03(dimension);
            });
        }

        public static void SetFacebookId(string facebookId)
        {
            if(_endThread)
            {
                return;
            }

            GAThreading.PerformTaskOnGAThread("setFacebookId", () =>
            {
                if (GAValidator.ValidateFacebookId(facebookId))
                {
                    GAState.SetFacebookId(facebookId);
                }
            });
        }

        public static void SetGender(EGAGender gender)
        {
            if(_endThread)
            {
                return;
            }

            GAThreading.PerformTaskOnGAThread("setGender", () =>
            {
                if (GAValidator.ValidateGender(gender))
                {
                    GAState.SetGender(gender);
                }
            });
        }

        public static void SetBirthYear(int birthYear)
        {
            if(_endThread)
            {
                return;
            }

            GAThreading.PerformTaskOnGAThread("setBirthYear", () =>
            {
                if (GAValidator.ValidateBirthyear(birthYear))
                {
                    GAState.SetBirthYear(birthYear);
                }
            });
        }

        #endregion // SET STATE CHANGES WHILE RUNNING

        public static void StartSession()
        {
            if(_endThread)
            {
                return;
            }

            GAThreading.PerformTaskOnGAThread("startSession", () =>
            {
#if WINDOWS_UWP || WINDOWS_WSA
                if(GAState.UseManualSessionHandling)
#endif
                {
                    if(!GAState.Initialized)
                    {
                        return;
                    }

                    if(GAState.IsEnabled() && GAState.SessionIsStarted())
                    {
                        GAState.EndSessionAndStopQueue(false);
                    }

                    GAState.ResumeSessionAndStartQueue();
                }
            });
        }

        public static void EndSession()
        {
#if WINDOWS_UWP || WINDOWS_WSA
            if(GAState.UseManualSessionHandling)
#endif
            {
                OnSuspend();
            }
        }

        public static void OnResume()
        {
            if(_endThread)
            {
                return;
            }

            GALogger.D("OnResume() called");
            GAThreading.PerformTaskOnGAThread("onResume", () =>
            {
                GAState.ResumeSessionAndStartQueue();
            });
        }

        public static void OnSuspend()
        {
            if(_endThread)
            {
                return;
            }

            GALogger.D("OnSuspend() called");
            GAThreading.PerformTaskOnGAThread("onSuspend", () =>
            {
                try
                {
                    GAState.EndSessionAndStopQueue(false);
                }
                catch(Exception)
                {
                }
            });
        }

        public static void OnQuit()
        {
            if(_endThread)
            {
                return;
            }

            GALogger.D("OnQuit() called");
            GAThreading.PerformTaskOnGAThread("onQuit", () =>
            {
                try
                {
                    _endThread = true;
                    GAState.EndSessionAndStopQueue(true);
                }
                catch(Exception)
                {
                }
            });
        }

        #region COMMAND CENTER

        public static string GetCommandCenterValueAsString(string key, string defaultValue = null)
        {
            return GAState.GetConfigurationStringValue(key, defaultValue);
        }

        public static bool IsCommandCenterReady()
        {
            return GAState.IsCommandCenterReady();
        }

        public static void AddCommandCenterListener(ICommandCenterListener listener)
        {
            GAState.AddCommandCenterListener(listener);
        }

        public static void RemoveCommandCenterListener(ICommandCenterListener listener)
        {
            GAState.RemoveCommandCenterListener(listener);
        }

        public static string GetConfigurationsAsString()
        {
            return GAState.GetConfigurationsAsString();
        }

#endregion // COMMAND CENTER

#region PRIVATE HELPERS

        private static bool IsSdkReady(bool needsInitialized)
        {
            return IsSdkReady(needsInitialized, true);
        }

        private static bool IsSdkReady(bool needsInitialized, bool warn)
        {
            return IsSdkReady(needsInitialized, warn, "");
        }

        private static bool IsSdkReady(bool needsInitialized, bool warn, String message)
        {
            if (!string.IsNullOrEmpty(message))
            {
                message = message + ": ";
            }

            // Make sure database is ready
            if (!GAStore.IsTableReady)
            {
                if (warn)
                {
                    GALogger.W(message + "Datastore not initialized");
                }
                return false;
            }
            // Is SDK initialized
            if (needsInitialized && !GAState.Initialized)
            {
                if (warn)
                {
                    GALogger.W(message + "SDK is not initialized");
                }
                return false;
            }
            // Is SDK enabled
            if (needsInitialized && !GAState.IsEnabled())
            {
                if (warn)
                {
                    GALogger.W(message + "SDK is disabled");
                }
                return false;
            }
            // Is session started
            if (needsInitialized && !GAState.SessionIsStarted())
            {
                if (warn)
                {
                    GALogger.W(message + "Session has not started yet");
                }
                return false;
            }
            return true;
        }

#endregion // PRIVATE HELPERS
    }
}