using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using gehGassi.Dto;
using gehGassiApp.Core.Interfaces;
using gehGassiApp.Core.Resources;
using gehGassiApp.Domain.Authentication;
using gehGassiApp.Domain.Common;
using gehGassiApp.Domain.Users;

namespace gehGassiApp.Core.Services
{
    /// <summary>
    /// Service der alle Funktionen rund um die Accountverwaltung bietet
    /// </summary>
    public class AccountService : IAccountService
    {
        private readonly ICommunicationService _communicationService;

        /// <summary>
        /// Erstellt eine Instanz
        /// </summary>
        /// <param name="communicationService">Instanz eines ICommunicationService</param>
        public AccountService(ICommunicationService communicationService)
        {
            _communicationService = communicationService;
        }

        /// <summary>
        /// Prüfen ob ein Benutzername noch verfügbar ist und ob das Passwort den Regeln entspricht.
        /// </summary>
        /// <param name="userName">Benutzername</param>
        /// <param name="password">Passwort</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        public async Task<CommunicationResult<bool>> RegisterCheckAvailableAsync(string userName, string password, CancellationToken token)
        {
            var result = new CommunicationResult<bool>();

            var hasConnection = await _communicationService.IsConnected();
            if (hasConnection)
            {
                var checkResult = await _communicationService.RegisterCheckAvailableAsync(userName, password, token);
                return checkResult;
            }
            else
            {
                result.Success = false;
                result.ErrorCode = CommunicationErrors.ServerNoConnection;
                result.ErrorMessage = Errors.Server_NoConnection;
            }

            return result;
        }

        /// <summary>
        /// Prüfen ob ein Passwort den Regeln entspricht
        /// </summary>
        /// <param name="password">Zu prüfendes Passwort</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        public async Task<CommunicationResult<bool>> CheckPasswordAsync(string password, CancellationToken token)
        {
            var result = new CommunicationResult<bool>();

            var hasConnection = await _communicationService.IsConnected();
            if (hasConnection)
            {
                var checkResult = await _communicationService.CheckPasswordAsync(password, token);
                return checkResult;
            }
            else
            {
                result.Success = false;
                result.ErrorCode = CommunicationErrors.ServerNoConnection;
                result.ErrorMessage = Errors.Server_NoConnection;
            }

            return result;
        }

        /// <summary>
        /// Registrieren eines App-Users
        /// </summary>
        /// <param name="userName">Benutzername</param>
        /// <param name="password">Passwort</param>
        /// <param name="country">Land</param>
        /// <param name="token">CancellationToken</param>
        /// <param name="appUserType">AppUser-Typ</param>
        /// <param name="firstName">Vorname</param>
        /// <param name="lastName">Nachname</param>
        /// <param name="birthDate">Geburtsdatum</param>
        /// <param name="zip">PLZ</param>
        /// <param name="city">Ort</param>
        /// <param name="state">Bundesland</param>
        /// <param name="nationality">Nationalität</param>
        /// <param name="mainResidence">Land Hauptwohnsitz</param>
        /// <returns>true wenn alles passt, false sonst</returns>
        public async Task<CommunicationResult<bool>> RegisterAsync(string userName, string password, AppUserType appUserType, string firstName, string lastName, DateTimeOffset? birthDate, string zip, string city, string state, string country, string nationality, string mainResidence, CancellationToken token)
        {
            var result = new CommunicationResult<bool>();

            var hasConnection = await _communicationService.IsConnected();
            if (hasConnection)
            {
                var registerResult = await _communicationService.RegisterAsync(userName, password, appUserType, firstName, lastName, birthDate, zip, city, state, country, nationality, mainResidence, token);
                return registerResult;
            }
            else
            {
                result.Success = false;
                result.ErrorCode = CommunicationErrors.ServerNoConnection;
                result.ErrorMessage = Errors.Server_NoConnection;
            }

            return result;
        }

        /// <summary>
        /// Registrieren eines App-Users - Extern
        /// </summary>
        /// <param name="userName">Benutzername</param>
        /// <param name="password">Passwort</param>
        /// <param name="country">Land</param>
        /// <param name="loginProvider">Login-Provider</param>
        /// <param name="token">CancellationToken</param>
        /// <param name="appUserType">AppUser-Typ</param>
        /// <param name="firstName">Vorname</param>
        /// <param name="lastName">Nachname</param>
        /// <param name="birthDate">Geburtsdatum</param>
        /// <param name="zip">PLZ</param>
        /// <param name="city">Ort</param>
        /// <param name="state">Bundesland</param>
        /// <param name="accessToken">Token des externen Providers</param>
        /// <param name="nationality">Nationalität</param>
        /// <param name="mainResidence">Land Hauptwohnsitz</param>
        /// <returns>CommunicationResult</returns>
        public async Task<CommunicationResult<User>> RegisterExternalAsync(string userName, string password, AppUserType appUserType, string firstName, string lastName, DateTimeOffset? birthDate, string zip, string city, string state, string country, string nationality, string mainResidence, string accessToken, string loginProvider, CancellationToken token)
        {
            var result = new CommunicationResult<User>();

            var hasConnection = await _communicationService.IsConnected();
            if (hasConnection)
            {
                var registerResult = await _communicationService.RegisterExternalAsync(userName, password, appUserType, firstName, lastName, birthDate, zip, city, state, country, nationality, mainResidence, accessToken, loginProvider, token);
                return registerResult;
            }
            else
            {
                result.Success = false;
                result.ErrorCode = CommunicationErrors.ServerNoConnection;
                result.ErrorMessage = Errors.Server_NoConnection;
            }

            return result;
        }

        /// <summary>
        /// Anmelden eines Benutzers
        /// </summary>
        /// <param name="userName">Benutzername</param>
        /// <param name="password">Passwort</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        public async Task<CommunicationResult<User>> LoginAsync(string userName, string password, CancellationToken token)
        {
            var result = new CommunicationResult<User>();

            var hasConnection = await _communicationService.IsConnected();
            if (hasConnection)
            {
                var loginResult = await _communicationService.LoginAsync(userName, password, token);
                return loginResult;
            }
            else
            {
                result.Success = false;
                result.ErrorCode = CommunicationErrors.ServerNoConnection;
                result.ErrorMessage = Errors.Server_NoConnection;
            }

            return result;
        }

        /// <summary>
        /// Anmelden eines Benutzers mittels externem Provider. Wer es ist wird über das Token bestimmt
        /// </summary>
        /// <param name="accessToken">Access-Token</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        public async Task<CommunicationResult<User>> LoginExternalAsync(string accessToken, CancellationToken token)
        {
            var result = new CommunicationResult<User>();

            var hasConnection = await _communicationService.IsConnected();
            if (hasConnection)
            {
                var loginResult = await _communicationService.LoginExternalAsync(accessToken, token);
                return loginResult;
            }
            else
            {
                result.Success = false;
                result.ErrorCode = CommunicationErrors.ServerNoConnection;
                result.ErrorMessage = Errors.Server_NoConnection;
            }

            return result;
        }

        /// <summary>
        /// Anmelden eines Benutzers mittels Apple Provider
        /// </summary>
        /// <param name="dto">bjekt mit benötigten Login-Daten</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        public async Task<CommunicationResult<User>> LoginAppleAsync(LoginAppleDto dto, CancellationToken token)
        {
            var result = new CommunicationResult<User>();

            var hasConnection = await _communicationService.IsConnected();
            if (hasConnection)
            {
                var loginResult = await _communicationService.LoginAppleAsync(dto, token);
                return loginResult;
            }
            else
            {
                result.Success = false;
                result.ErrorCode = CommunicationErrors.ServerNoConnection;
                result.ErrorMessage = Errors.Server_NoConnection;
            }

            return result;
        }

        /// <summary>
        /// Abmelden eines Benutzers.
        /// Löscht alle Refreshtokens des Benutzers
        /// </summary>
        /// <param name="accessToken">Access-Token</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        public async Task<CommunicationResult<bool>> LogoutAsync(string accessToken, CancellationToken token)
        {
            var result = new CommunicationResult<bool>();

            var hasConnection = await _communicationService.IsConnected();
            if (hasConnection)
            {
                var logoutResult = await _communicationService.LogoutAsync(accessToken, token);
                return logoutResult;
            }
            else
            {
                result.Success = false;
                result.ErrorCode = CommunicationErrors.ServerNoConnection;
                result.ErrorMessage = Errors.Server_NoConnection;
            }

            return result;
        }

        /// <summary>
        /// Zurücksetzen des Passworts eines Benutzers
        /// </summary>
        /// <param name="userName">Benutzername / Email</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        public async Task<CommunicationResult<bool>> ResetPasswordAsync(string userName, CancellationToken token)
        {
            var result = new CommunicationResult<bool>();

            var hasConnection = await _communicationService.IsConnected();
            if (hasConnection)
            {
                var resetPasswordResult = await _communicationService.ResetPasswordAsync(userName, token);
                return resetPasswordResult;
            }
            else
            {
                result.Success = false;
                result.ErrorCode = CommunicationErrors.ServerNoConnection;
                result.ErrorMessage = Errors.Server_NoConnection;
            }

            return result;
        }

        /// <summary>
        /// Senden der E-Mail Bestätigung für einen Benutzer
        /// </summary>
        /// <param name="userName">Benutzername / Email</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        public async Task<CommunicationResult<bool>> ResendConfirmationAsync(string userName, CancellationToken token)
        {
            var result = new CommunicationResult<bool>();

            var hasConnection = await _communicationService.IsConnected();
            if (hasConnection)
            {
                var resendConfirmationResult = await _communicationService.ResendConfirmationAsync(userName, token);
                return resendConfirmationResult;
            }
            else
            {
                result.Success = false;
                result.ErrorCode = CommunicationErrors.ServerNoConnection;
                result.ErrorMessage = Errors.Server_NoConnection;
            }

            return result;
        }

        /// <summary>
        /// Anmelden eines Benutzers mittels Refreshtoken
        /// </summary>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="refreshToken">Refreshtoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        public async Task<CommunicationResult<TokenResponse>> RefreshTokenAsync(string accessToken, string refreshToken, CancellationToken token)
        {
            var result = new CommunicationResult<TokenResponse>() {Success = false};

            var hasConnection = await _communicationService.IsConnected();
            if (hasConnection)
            {
                var refreshTokenResult = await _communicationService.RefreshTokenAsync(accessToken, refreshToken, token);
                if (refreshTokenResult.Success && refreshTokenResult.Value != null)
                {
                    return refreshTokenResult;
                }
                else
                {
                    result.ErrorCode = refreshTokenResult.ErrorCode;
                    result.ErrorMessage = refreshTokenResult.ErrorMessage;
                    result.Success = false;
                }
            }
            else
            {
                result.Success = false;
                result.ErrorCode = CommunicationErrors.ServerNoConnection;
                result.ErrorMessage = Errors.Server_NoConnection;
            }

            return result;
        }

        /// <summary>
        /// Prüfen ob ein Benutzer ein Passwort hat
        /// </summary>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        public async Task<CommunicationResult<bool>> HasPasswordAsync(string accessToken, CancellationToken token)
        {
            var result = new CommunicationResult<bool>() { Success = false };

            var hasConnection = await _communicationService.IsConnected();
            if (hasConnection)
            {
                var hasPasswordResult = await _communicationService.HasPasswordAsync(accessToken, token);
                if (hasPasswordResult.Success)
                {
                    return hasPasswordResult;
                }
                else
                {
                    result.ErrorCode = hasPasswordResult.ErrorCode;
                    result.ErrorMessage = hasPasswordResult.ErrorMessage;
                    result.Success = false;
                }
            }
            else
            {
                result.Success = false;
                result.ErrorCode = CommunicationErrors.ServerNoConnection;
                result.ErrorMessage = Errors.Server_NoConnection;
            }

            return result;
        }

        /// <summary>
        /// Hinzufügen eines Passswortes zu einem Benutzer, wenn dieser keines hat
        /// </summary>
        /// <param name="userName">Benutzername</param>
        /// <param name="password">Passwort das hinzugefügt werden soll</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        public async Task<CommunicationResult<bool>> AddPasswordAsync(string userName, string password, string accessToken, CancellationToken token)
        {
            var result = new CommunicationResult<bool>() { Success = false };

            var hasConnection = await _communicationService.IsConnected();
            if (hasConnection)
            {
                var addPasswordResult = await _communicationService.AddPasswordAsync(userName, password, accessToken, token);
                if (addPasswordResult.Success)
                {
                    return addPasswordResult;
                }
                else
                {
                    result.ErrorCode = addPasswordResult.ErrorCode;
                    result.ErrorMessage = addPasswordResult.ErrorMessage;
                    result.Success = false;
                }
            }
            else
            {
                result.Success = false;
                result.ErrorCode = CommunicationErrors.ServerNoConnection;
                result.ErrorMessage = Errors.Server_NoConnection;
            }

            return result;
        }

        /// <summary>
        /// Ändern des Passwortes eines Benutzers
        /// </summary>
        /// <param name="userName">Benutzername</param>
        /// <param name="password">Passwort das gesetzt werden soll</param>
        /// <param name="oldPassword">Bisheriges Passwort</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        public async Task<CommunicationResult<bool>> ChangePasswordAsync(string userName, string password, string oldPassword, string accessToken, CancellationToken token)
        {
            var result = new CommunicationResult<bool>() { Success = false };

            var hasConnection = await _communicationService.IsConnected();
            if (hasConnection)
            {
                var changePasswordResult = await _communicationService.ChangePasswordAsync(userName, password, oldPassword, accessToken, token);
                if (changePasswordResult.Success)
                {
                    return changePasswordResult;
                }
                else
                {
                    result.ErrorCode = changePasswordResult.ErrorCode;
                    result.ErrorMessage = changePasswordResult.ErrorMessage;
                    result.Success = false;
                }
            }
            else
            {
                result.Success = false;
                result.ErrorCode = CommunicationErrors.ServerNoConnection;
                result.ErrorMessage = Errors.Server_NoConnection;
            }

            return result;
        }

        /// <summary>
        /// Löschen des Accounts eines Benutzers
        /// </summary>
        /// <param name="userName">Benutzername</param>
        /// <param name="userId">Id des Benutzers</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        public async Task<CommunicationResult<bool>> DeleteAccountAsync(string userName, string userId, string accessToken, CancellationToken token)
        {
            var result = new CommunicationResult<bool>() { Success = false };

            var hasConnection = await _communicationService.IsConnected();
            if (hasConnection)
            {
                var deleteAccountResult = await _communicationService.DeleteAccountAsync(userName, userId, accessToken, token);
                if (deleteAccountResult.Success)
                {
                    return deleteAccountResult;
                }
                else
                {
                    result.ErrorCode = deleteAccountResult.ErrorCode;
                    result.ErrorMessage = deleteAccountResult.ErrorMessage;
                    result.Success = false;
                }
            }
            else
            {
                result.Success = false;
                result.ErrorCode = CommunicationErrors.ServerNoConnection;
                result.ErrorMessage = Errors.Server_NoConnection;
            }

            return result;
        }
    }
}