using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Tango.Core;
using Tango.Core.DI;
using Tango.FSE.BL.Connectivity;
using Tango.Logging;

namespace Tango.FSE.BL
{
    /// <summary>
    /// Represents a cascading/fallback data retrieval mechanism.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <seealso cref="Tango.Core.ExtendedObject" />
    public class DataResolver<T> : ExtendedObject where T : class
    {
        private static object diskLock = new object();
        private static IConnectivityProvider _connectivity;
        private Func<DataResolverContext, T> _onlineAction;
        private Func<DataResolverContext, T> _webAction;
        private Func<DataResolverContext, T> _diskCacheAction;
        private Func<DataResolverContext, T> _memoryCacheAction;
        private Action<Exception> _onError;
        private Action<T> _onComplete;
        private List<DataResolverNode> _nodes;
        private bool _throwOnError;
        private String _callingName;
        private bool _enableLogs = true;

        /// <summary>
        /// Prevents a default instance of the <see cref="DataResolver{T}"/> class from being created.
        /// </summary>
        private DataResolver()
        {
            if (_connectivity == null)
            {
                _connectivity = TangoIOC.Default.GetInstance<IConnectivityProvider>();
            }

            _nodes = new List<DataResolverNode>() { DataResolverNode.Online };
            _throwOnError = true;
        }

        /// <summary>
        /// Executes this data resolver.
        /// </summary>
        /// <returns></returns>
        /// <exception cref="System.InvalidOperationException">Could not execute data resolver with zero nodes.</exception>
        public T Execute()
        {
            if (_enableLogs) LogManager.Log($"Executing data resolver for {_callingName}...");

            T result = null;

            var nodes = _nodes.Distinct().ToList();

            if (nodes.Count == 0)
            {
                throw new InvalidOperationException("Could not execute data resolver with zero nodes.");
            }

            DataResolverContext context = new DataResolverContext();

            foreach (var node in nodes)
            {
                String fallingBackText = String.Empty;

                if (nodes.IndexOf(node) < nodes.Count - 1)
                {
                    fallingBackText = $" Falling back to {nodes[nodes.IndexOf(node) + 1]}...";
                }

                if (node == DataResolverNode.Web)
                {
                    try
                    {
                        if (_enableLogs) LogManager.Log($"Trying {_callingName} via web...");
                        result = ExecuteWebAction(context);
                        break;
                    }
                    catch (Exception ex)
                    {
                        if (_enableLogs) LogManager.Log($"{_callingName} via web failed with exception: {ex.FlattenMessage()}{fallingBackText}", LogCategory.Warning);
                        context.LastError = ex;
                    }
                }
                else if (node == DataResolverNode.Online)
                {
                    try
                    {
                        if (_enableLogs) LogManager.Log($"Trying {_callingName} via online...");
                        result = ExecuteOnlineAction(context);
                        break;
                    }
                    catch (Exception ex)
                    {
                        if (_enableLogs) LogManager.Log($"{_callingName} via online failed with exception: {ex.FlattenMessage()}{fallingBackText}", LogCategory.Warning);
                        context.LastError = ex;
                    }
                }
                else if (node == DataResolverNode.DiskCache)
                {
                    try
                    {
                        if (_enableLogs) LogManager.Log($"Trying {_callingName} via disk cache...");
                        result = _diskCacheAction.Invoke(context);
                        break;
                    }
                    catch (Exception ex)
                    {
                        if (_enableLogs) LogManager.Log($"{_callingName} via disk cache failed with exception: {ex.FlattenMessage()}{fallingBackText}");
                        context.LastError = ex;
                    }
                }
                else if (node == DataResolverNode.InMemoryCache)
                {
                    try
                    {
                        if (_enableLogs) LogManager.Log($"Trying {_callingName} via in-memory cache...");
                        result = _memoryCacheAction.Invoke(context);
                        break;
                    }
                    catch (Exception ex)
                    {
                        if (_enableLogs) LogManager.Log($"{_callingName} via in-memory cache failed with exception: {ex.FlattenMessage()}{fallingBackText}");
                        context.LastError = ex;
                    }
                }

                if (context.Aborted)
                {
                    if (_enableLogs) LogManager.Log($"{_callingName} aborted.");
                    break;
                }
            }

            if (result != null)
            {
                if (_enableLogs) LogManager.Log($"{_callingName} completed successfully.");
                _onComplete?.Invoke(result);
                return result;
            }

            if (context.LastError == null)
            {
                context.LastError = new InvalidOperationException("No nodes were run successfully but could not retrieve the last error.");
            }

            if (_enableLogs) LogManager.Log(context.LastError, $"{_callingName} failed.");

            _onError?.Invoke(context.LastError);

            if (_throwOnError)
            {
                throw context.LastError;
            }
            else
            {
                return null;
            }
        }

        private T ExecuteOnlineAction(DataResolverContext context)
        {
            if (!_connectivity.CheckOnline())
            {
                throw new InternetConnectionException();
            }

            return _onlineAction.Invoke(context);
        }

        private T ExecuteWebAction(DataResolverContext context)
        {
            if (!_connectivity.CheckOnline())
            {
                throw new InternetConnectionException();
            }

            return _webAction.Invoke(context);
        }

        #region Context

        /// <summary>
        /// Represents a data resolver node context.
        /// </summary>
        /// <seealso cref="Tango.Core.ExtendedObject" />
        public class DataResolverContext
        {
            internal bool Aborted { get; set; }

            /// <summary>
            /// Gets the last error, or maybe the reason that the current node is running.
            /// </summary>
            public Exception LastError { get; internal set; }

            internal DataResolverContext()
            {

            }

            /// <summary>
            /// Aborts the entire data resolver.
            /// </summary>
            public void AbortCascade()
            {
                Aborted = true;
            }
        }

        #endregion

        #region Builder

        /// <summary>
        /// Build a <see cref="DataResolver{T}"/> instance.
        /// </summary>
        /// <seealso cref="Tango.Core.ExtendedObject" />
        public class Builder
        {
            private DataResolver<T> _resolver;

            /// <summary>
            /// Prevents a default instance of the <see cref="Builder"/> class from being created.
            /// </summary>
            private Builder()
            {
                _resolver = new DataResolver<T>();
            }

            /// <summary>
            /// Creates a new builder instance.
            /// </summary>
            /// <returns></returns>
            public static Builder New()
            {
                var method = new StackTrace().GetFrame(1).GetMethod();
                var cls = method.ReflectedType.Name;

                var builder = new Builder();
                builder._resolver._callingName = $"'{cls}.{method.Name}'";

                return builder;
            }

            /// <summary>
            /// Specify the method for the online node.
            /// </summary>
            /// <param name="func">The method.</param>
            /// <returns></returns>
            public Builder Online(Func<DataResolverContext, T> func)
            {
                _resolver._onlineAction = func;
                return this;
            }

            /// <summary>
            /// Specify the method for the web client node.
            /// </summary>
            /// <param name="func">The method.</param>
            /// <returns></returns>
            public Builder Web(Func<DataResolverContext, T> func)
            {
                _resolver._webAction = func;
                return this;
            }

            /// <summary>
            /// Specify the method for the disk cache node.
            /// </summary>
            /// <param name="func">The method.</param>
            /// <returns></returns>
            public Builder DiskCache(Func<DataResolverContext, T> func)
            {
                _resolver._diskCacheAction = func;
                return this;
            }

            /// <summary>
            /// Specify the method for the in-memory node.
            /// </summary>
            /// <param name="func">The method.</param>
            /// <returns></returns>
            public Builder InMemoryCache(Func<DataResolverContext, T> func)
            {
                _resolver._memoryCacheAction = func;
                return this;
            }

            /// <summary>
            /// Configure the node cascade priority.
            /// </summary>
            /// <param name="nodes">The nodes.</param>
            /// <returns></returns>
            public Builder ConfigureCascade(params DataResolverNode[] nodes)
            {
                _resolver._nodes = nodes.ToList();
                return this;
            }

            /// <summary>
            /// Called when all nodes have failed.
            /// </summary>
            /// <param name="onError">The on error.</param>
            /// <returns></returns>
            public Builder OnError(Action<Exception> onError)
            {
                _resolver._onError = onError;
                return this;
            }

            /// <summary>
            /// Called when one of the nodes completed successful.
            /// </summary>
            /// <param name="onComplete">The on complete.</param>
            /// <returns></returns>
            public Builder OnComplete(Action<T> onComplete)
            {
                _resolver._onComplete = onComplete;
                return this;
            }

            /// <summary>
            /// Specify whether to throw the last exception when all the nodes have failed.
            /// </summary>
            /// <param name="throwOnError">if set to <c>true</c> [throw on error].</param>
            /// <returns></returns>
            public Builder ThrowOnError(bool throwOnError)
            {
                _resolver._throwOnError = throwOnError;
                return this;
            }

            /// <summary>
            /// Specify whether to enable data resolver logging.
            /// </summary>
            /// <param name="enableLogs">if set to enables logging.</param>
            /// <returns></returns>
            public Builder EnableLogs(bool enableLogs)
            {
                _resolver._enableLogs = enableLogs;
                return this;
            }

            /// <summary>
            /// Specify a custom name for the calling service when logs are enabled.
            /// </summary>
            /// <param name="callingName">Name of the calling service.</param>
            /// <returns></returns>
            public Builder WithLogsCallingName(String callingName)
            {
                var method = new StackTrace().GetFrame(1).GetMethod();
                _resolver._callingName = $"'{callingName}.{method.Name}'";
                return this;
            }

            /// <summary>
            /// Builds this <see cref="DataResolver{T}"/> instance.
            /// </summary>
            /// <returns></returns>
            public DataResolver<T> Build()
            {
                return _resolver;
            }

            /// <summary>
            /// Builds the executes the <see cref="DataResolver{T}"/> instance.
            /// </summary>
            /// <returns></returns>
            public T BuildExecute()
            {
                return Build().Execute();
            }

            /// <summary>
            /// Builds the executes the <see cref="DataResolver{T}"/> instance asynchronous.
            /// </summary>
            /// <returns></returns>
            public Task<T> BuildExecuteAsync()
            {
                return Task.Factory.StartNew(() => Build().Execute());
            }
        }

        #endregion
    }
}