using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Authentication;
using System.Text;
using System.Threading.Tasks;
using System.Timers;
using Tango.BL;
using Tango.BL.Builders;
using Tango.BL.Entities;
using Tango.BL.Enumerations;
using Tango.Core;
using Tango.Core.DI;
using Tango.Core.ExtensionMethods;
using Tango.FSE.BL;
using Tango.FSE.BL.Web;
using Tango.FSE.Common;
using Tango.FSE.Common.Authentication;
using Tango.FSE.Common.FSEApplication;
using Tango.FSE.Common.Navigation;
using Tango.FSE.Common.Notifications;
using Tango.FSE.UI.ViewModels;
using Tango.FSE.Web.Messages;
using Tango.MachineService.Gateway;
using Tango.Settings;

namespace Tango.FSE.UI.Authentication
{
    /// <summary>
    /// Represents the default FSE authentication provider.
    /// </summary>
    /// <seealso cref="Tango.Core.ExtendedObject" />
    /// <seealso cref="Tango.FSE.Common.Authentication.IAuthenticationProvider" />
    public class DefaultAuthenticationProvider : ExtendedObject, IAuthenticationProvider
    {
        private const string WEB_DEBUG_ADDRESS = "http://localhost:1111";
        private Timer _tokenRefreshTimer;

        [TangoInject(TangoInjectMode.WhenAvailable)]
        private IFSEApplicationManager ApplicationManager { get; set; }

        [TangoInject(TangoInjectMode.WhenAvailable)]
        private INavigationManager NavigationManager { get; set; }

        [TangoInject(TangoInjectMode.WhenAvailable)]
        private INotificationProvider NotificationProvider { get; set; }

        [TangoInject(TangoInjectMode.WhenAvailable)]
        private FSEServicesContainer Services { get; set; }

        [TangoInject(TangoInjectMode.WhenAvailable)]
        private FSEWebClient WebClient { get; set; }

        /// <summary>
        /// Occurs when the current logged-in user has changed.
        /// </summary>
        public event EventHandler<User> CurrentUserChanged;

        private User _currentUser;
        /// <summary>
        /// Gets the current logged-in user.
        /// </summary>
        public User CurrentUser
        {
            get { return _currentUser; }
            private set
            {
                _currentUser = value;
                RaisePropertyChangedAuto();
            }
        }

        private EnvironmentConfiguration _currentEnvironment;
        /// <summary>
        /// Gets the current environment configuration.
        /// </summary>
        public EnvironmentConfiguration CurrentEnvironment
        {
            get { return _currentEnvironment; }
            private set { _currentEnvironment = value; RaisePropertyChangedAuto(); }
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="DefaultAuthenticationProvider"/> class.
        /// </summary>
        public DefaultAuthenticationProvider()
        {
            _tokenRefreshTimer = new Timer(TimeSpan.FromMinutes(30).TotalMilliseconds);
            _tokenRefreshTimer.Elapsed += OnRefreshTokenTimer;
            _tokenRefreshTimer.Stop();
        }

        /// <summary>
        /// Logins the specified email.
        /// </summary>
        /// <param name="email">The email.</param>
        /// <param name="password">The password.</param>
        /// <param name="environment">The environment.</param>
        /// <returns></returns>
        public Task<AuthenticationResult> Login(String email, String password, EnvironmentConfiguration environment, Action<String> onStatusChanged = null)
        {
            return Task.Factory.StartNew<AuthenticationResult>(() =>
            {
                _tokenRefreshTimer.Stop();

                LogManager.Log($"Authenticating user '{email}'...");

                onStatusChanged?.Invoke($"Authenticating user {email}...");

                var settings = SettingsManager.Default.GetOrCreate<FSESettings>();

                if (ApplicationManager.IsWebDebugMode)
                {
                    LogManager.Log($"Application is currently in web debug mode. Authenticating through '{WEB_DEBUG_ADDRESS}'.");
                    WebClient.Address = WEB_DEBUG_ADDRESS;
                }
                else
                {
                    LogManager.Log($"Authenticating through machine service at '{environment.MachineServiceAddress}'...");
                    WebClient.Address = environment.MachineServiceAddress;
                }

                var appVersion = ApplicationManager.Version.ToString();

                if (settings.ForceVersionUpdate)
                {
                    LogManager.Log("Application settings are set to force version update. Setting reported application version to '1.0.0.0'.");
                    appVersion = "1.0.0.0";
                }

                LoginResponse response = null;

                try
                {
                    onStatusChanged?.Invoke($"Contacting machine service at '{WebClient.Address}'...");

                    CurrentEnvironment = environment;

                    response = Services.AuthenticationService.Authenticate(new LoginRequest()
                    {

                        Email = email,
                        Password = password,
                        Version = appVersion,
                        Build = BuildProvider.Build

                    }).Result;

                    LogManager.Log($"Authentication response received:\n{response.ToJsonString()}");

                    settings.Save();
                }
                catch (Exception ex)
                {
                    LogManager.Log(ex, "Error authenticating user.");
                    throw new AggregateException(new AuthenticationException("Error logging in to machine service."), ex);
                }

                if (settings.Environment == FSESettings.WorkingEnvironment.Remote)
                {
                    ObservablesContext.OverrideSettingsDataSource(response.DataSource);
                }

                if (response.PasswordChangeRequired)
                {
                    LogManager.Log("User password change required.");
                    Services.AuthenticationService.DropCachedResponse(email);
                    return new AuthenticationResult() { Response = response };
                }

                LogManager.Log("Retrieving full user details...");
                User user = Services.UsersService.GetUserFull(email.ToLower()).Result;

                if (user != null)
                {
                    LogManager.Log($"Current user is now: {user.Contact.FullName}.");
                }
                else
                {
                    throw LogManager.Log(new AuthenticationException("Login failed for some strange reason."));
                }

                _tokenRefreshTimer.Start();

                CurrentUser = user;

                settings.Save();

                InvokeUI(() =>
                {
                    CurrentUserChanged?.Invoke(this, CurrentUser);
                });

                return new AuthenticationResult()
                {
                    Response = response,
                    User = CurrentUser,
                };
            });
        }

        /// <summary>
        /// Logs-out the current logged-in user.
        /// </summary>
        public async void LogOut()
        {
            LogManager.Log("Logging out current user...");

            using (NotificationProvider.PushTaskItem("Logging out..."))
            {
                await Task.Delay(1000);

                LogManager.Log($"Invoking {nameof(FSEViewModel.OnApplicationLogout)} on all FSE view models...");

                foreach (var vm in TangoIOC.Default.GetAllInstancesByBase<FSEViewModel>())
                {
                    try
                    {
                        if (!await vm.OnApplicationLogout())
                        {
                            return;
                        }
                    }
                    catch (Exception ex)
                    {
                        LogManager.Log(ex, $"An error occurred on ApplicationLogOut on {vm.GetType().FullName}.");
                    }
                }

                await Task.Delay(1000);
            }

            LogManager.Log("Logging out current user.");
            CurrentUser = null;
            CurrentUserChanged?.Invoke(this, CurrentUser);

            LogManager.Log($"Navigating to {nameof(NavigationView.LoginView)}...");

            _tokenRefreshTimer.Stop();

            MemoryCacheManager.Default.ClearAll();

            await NavigationManager.NavigateWithObject<LoginViewVM.NavigationObject>(NavigationView.LoginView, new LoginViewVM.NavigationObject()
            {
                IsLoggingOut = true,
            }, false);
        }

        /// <summary>
        /// Throws an exception if the current user does not have the specified permission.
        /// </summary>
        /// <param name="permission">The permission.</param>
        /// <param name="message">Optional message.</param>
        /// <exception cref="AuthorizationException">
        /// </exception>
        public void ThrowIfNoPermission(Permissions permission, String message = null)
        {
            if (CurrentUser == null || !CurrentUser.HasPermission(permission))
            {
                if (message == null)
                {
                    throw new AuthorizationException();
                }
                else
                {
                    throw new AuthorizationException(message);
                }
            }
        }

        /// <summary>
        /// Changes the specified user password.
        /// </summary>
        /// <param name="email">The email.</param>
        /// <param name="oldPassword">The old password.</param>
        /// <param name="newPassword">The new password.</param>
        /// <returns></returns>
        public Task ChangePassword(string email, string oldPassword, string newPassword)
        {
            return Services.AuthenticationService.ChangePassword(email, oldPassword, newPassword);
        }

        private async void OnRefreshTokenTimer(object sender, ElapsedEventArgs e)
        {
            _tokenRefreshTimer.Stop();

            if (ObservablesContext.GetActualDataSource().Type == DataSourceType.AccessToken)
            {
                try
                {
                    LogManager.Log("Refreshing database access token...");
                    var response = await WebClient.RefreshToken(new RefreshTokenRequest());
                    ObservablesContext.UpdateAccessToken(response.AccessToken, response.Expiration);
                }
                catch (Exception ex)
                {
                    LogManager.Log(ex, "Error occurred while trying to refresh the database access token.");
                }
            }

            _tokenRefreshTimer.Start();
        }
    }
}