using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Firebase;
using Firebase.Auth;
using Firebase.Database;
using Firebase.Extensions;
using UnityEngine;

/// <summary>
///     the general managing class for handling communication with the firebase backend
///     (to be initialised by GameManager)
/// </summary>
public class Backend
{
    /// <summary>
    ///     enum for the result of the authentication process
    /// </summary>
    public enum AuthenticationResult
    {
        Ok,
        AlreadyAuthenticated,
        NonExistentUser,
        AlreadyExistingUser,
        InvalidEmail,
        InvalidCredentials,
        GenericError
    }

    /// <summary>
    ///     generic enum for the result of a database transaction
    /// </summary>
    public enum DatabaseTransactionResult
    {
        Ok,
        Unauthenticated,
        Error
    }

    /// <summary>
    ///     enum for the connection status of the firebase backend
    /// </summary>
    public enum FirebaseConnectionStatus
    {
        NotConnected,
        Connected,
        UpdateRequired, // "a required system component is out of date"
        Updating, // "a required system component is updating, retrying in a bit..."
        ExternalError, // "a system component is disabled, invalid, missing, or permissions are insufficient"
        InternalError // "an unknown error occurred"
    }

    /// <summary>
    ///     callback functions to be invoked when the user signs in
    /// </summary>
    private readonly List<Action<FirebaseUser>> _onSignInCallback = new();

    /// <summary>
    ///     callback functions to be invoked when the user signs out
    /// </summary>
    private readonly List<Action<FirebaseUser>> _onSignOutCallback = new();

    /// <summary>
    ///     the firebase authentication object
    /// </summary>
    private FirebaseAuth _auth;

    /// <summary>
    ///     the firebase database reference
    /// </summary>
    private DatabaseReference _db;

    /// <summary>
    ///     the current user object, if authenticated
    /// </summary>
    private FirebaseUser _user;

    /// <summary>
    ///     the current user's username, if authenticated
    /// </summary>
    private string _username;

    /// <summary>
    ///     whether the backend is connected to the firebase backend
    /// </summary>
    public FirebaseConnectionStatus Status = FirebaseConnectionStatus.NotConnected;

    /// <summary>
    ///     variable initialisation function
    /// </summary>
    public void Initialise()
    {
        FirebaseApp.CheckAndFixDependenciesAsync().ContinueWith(task =>
        {
            // cher is this robust enough
            switch (task.Result)
            {
                case DependencyStatus.Available:
                    _auth = FirebaseAuth.GetAuth(FirebaseApp.DefaultInstance);
                    _auth.StateChanged += AuthStateChanged;
                    _db = FirebaseDatabase.DefaultInstance.RootReference;
                    Status = FirebaseConnectionStatus.Connected;
                    break;

                case DependencyStatus.UnavailableDisabled:
                case DependencyStatus.UnavailableInvalid:
                case DependencyStatus.UnavilableMissing:
                case DependencyStatus.UnavailablePermission:
                    Status = FirebaseConnectionStatus.ExternalError;
                    break;

                case DependencyStatus.UnavailableUpdating:
                    Status = FirebaseConnectionStatus.Updating;
                    RetryInitialiseAfterDelay();
                    break;

                case DependencyStatus.UnavailableUpdaterequired:
                    Status = FirebaseConnectionStatus.UpdateRequired;
                    break;

                case DependencyStatus.UnavailableOther:
                default:
                    Status = FirebaseConnectionStatus.InternalError;
                    Debug.LogError("firebase ??? blew up or something," + task.Result);
                    break;
            }

            Debug.Log("firebase status is" + Status);
        });
    }

    /// <summary>
    ///     async function to retry initialisation after a delay
    /// </summary>
    private async void RetryInitialiseAfterDelay()
    {
        await Task.Delay(TimeSpan.FromSeconds(10));
        Initialise();
    }

    /// <summary>
    ///     cleanup function
    /// </summary>
    public void Cleanup()
    {
        SignOutUser();
        _auth.StateChanged -= AuthStateChanged;
        _auth = null;
    }

    /// <summary>
    ///     function to handle the authentication state change event
    /// </summary>
    /// <param name="sender">the object that triggered the event</param>
    /// <param name="eventArgs">the event arguments</param>
    private void AuthStateChanged(object sender, EventArgs eventArgs)
    {
        // if the user hasn't changed, do nothing
        if (_auth.CurrentUser == _user) return;

        // if the user has changed, check if they've signed in or out
        var signedIn = _user != _auth.CurrentUser && _auth.CurrentUser != null;

        // if we're not signed in, but we still hold _user locally, we've signed out
        if (!signedIn && _user != null)
        {
            Debug.Log($"signed out successfully as {_user.UserId}");
            foreach (var callback in _onSignOutCallback)
                callback(_user);
        }

        // they have signed in, update _user
        _user = _auth.CurrentUser;
        if (signedIn)
        {
            Debug.Log($"signed in successfully as {_user.UserId}");
            RetrieveUsername();
            foreach (var callback in _onSignInCallback) callback(_user);
        }
    }

    /// <summary>
    ///     function to register a callback for when the user signs in
    /// </summary>
    /// <param name="callback">callback function that takes in a FirebaseUser argument</param>
    public void RegisterOnSignInCallback(Action<FirebaseUser> callback)
    {
        _onSignInCallback.Add(callback);
    }

    /// <summary>
    ///     function to register a callback for when the user signs out
    /// </summary>
    /// <param name="callback">callback function that takes in a FirebaseUser argument</param>
    public void RegisterOnSignOutCallback(Action<FirebaseUser> callback)
    {
        _onSignOutCallback.Add(callback);
    }

    /// <summary>
    ///     abstraction function to authenticate the user
    /// </summary>
    /// <param name="email">email string</param>
    /// <param name="password">user raw password string</param>
    /// <param name="callback">callback function that takes in an AuthenticationResult argument</param>
    /// <param name="registerUser">whether to treat authentication as registration</param>
    /// <param name="registeringUsername">username string if registering</param>
    public void AuthenticateUser(
        string email,
        string password,
        Action<AuthenticationResult> callback,
        bool registerUser = false,
        string registeringUsername = "")
    {
        if (GameManager.Instance.Backend.GetUser() != null)
        {
            callback(AuthenticationResult.AlreadyAuthenticated);
            return;
        }

        if (registerUser)
        {
            // register user
            _auth.CreateUserWithEmailAndPasswordAsync(email, password)
                .ContinueWithOnMainThread(createTask =>
                {
                    if (createTask.IsCompletedSuccessfully)
                    {
                        // store username
                        _db.Child("users")
                            .Child(_user.UserId)
                            .Child("username")
                            .SetValueAsync(registeringUsername)
                            .ContinueWithOnMainThread(setUsernameTask =>
                            {
                                if (setUsernameTask.IsCompletedSuccessfully)
                                {
                                    _username = registeringUsername;
                                    callback(AuthenticationResult.Ok);
                                }
                                else
                                {
                                    Debug.LogError(setUsernameTask.Exception);
                                    callback(AuthenticationResult.GenericError);
                                }
                            });
                        return;
                    }

                    if (createTask.Exception?.InnerException == null)
                    {
                        callback(AuthenticationResult.GenericError);
                        return;
                    }

                    var error = (AuthError)((FirebaseException)createTask.Exception.InnerException).ErrorCode;

                    // ReSharper disable once SwitchStatementHandlesSomeKnownEnumValuesWithDefault
                    switch (error)
                    {
                        case AuthError.UserNotFound:
                            callback(AuthenticationResult.NonExistentUser);
                            return;

                        case AuthError.InvalidEmail:
                            callback(AuthenticationResult.InvalidEmail);
                            return;

                        case AuthError.WeakPassword:
                        case AuthError.InvalidCredential:
                            callback(AuthenticationResult.InvalidCredentials);
                            return;

                        case AuthError.AccountExistsWithDifferentCredentials:
                        case AuthError.EmailAlreadyInUse:
                            callback(AuthenticationResult.AlreadyExistingUser);
                            return;

                        case AuthError.Failure:
                        default:
                            Debug.LogError(error);
                            Debug.LogError(createTask.Exception);
                            callback(AuthenticationResult.GenericError);
                            break;
                    }
                });
            return;
        }

        _auth.SignInWithEmailAndPasswordAsync(email, password)
            .ContinueWithOnMainThread(signInTask =>
            {
                if (signInTask.IsCompletedSuccessfully)
                {
                    callback(AuthenticationResult.Ok);
                    return;
                }

                if (signInTask.Exception?.InnerException == null)
                {
                    callback(AuthenticationResult.GenericError);
                    return;
                }

                var error = (AuthError)((FirebaseException)signInTask.Exception.InnerException).ErrorCode;

                // ReSharper disable once SwitchStatementHandlesSomeKnownEnumValuesWithDefault
                switch (error)
                {
                    case AuthError.UserNotFound:
                        callback(AuthenticationResult.NonExistentUser);
                        return;
                    case AuthError.InvalidEmail:
                        callback(AuthenticationResult.InvalidEmail);
                        return;
                    case AuthError.WeakPassword:
                    case AuthError.InvalidCredential:
                        callback(AuthenticationResult.InvalidCredentials);
                        return;
                    case AuthError.AccountExistsWithDifferentCredentials:
                    case AuthError.EmailAlreadyInUse:
                        callback(AuthenticationResult.AlreadyExistingUser);
                        return;
                    case AuthError.Failure:
                    default:
                        Debug.LogError(error);
                        Debug.LogError(signInTask.Exception);
                        callback(AuthenticationResult.GenericError);
                        break;
                }
            });
    }

    /// <summary>
    ///     function to retrieve the user's username from the database
    /// </summary>
    private void RetrieveUsername()
    {
        if (!Status.Equals(FirebaseConnectionStatus.Connected)) return;
        _db.Child("users").Child(_user.UserId).Child("username").GetValueAsync().ContinueWith(task =>
        {
            if (task.IsCompletedSuccessfully)
            {
                _username = task.Result.Value.ToString();
                Debug.Log($"our username is {_username}");
            }
            else
            {
                _username = "???";
                Debug.LogError("failed to get username");
            }
        });
    }

    /// <summary>
    ///     abstraction function to retrieve the user
    /// </summary>
    /// <returns>the firebase user object</returns>
    public FirebaseUser GetUser()
    {
        return _user;
    }

    public string GetUsername()
    {
        return _username;
    }

    /// <summary>
    ///     abstraction function to sign out the user
    /// </summary>
    public void SignOutUser()
    {
        _auth.SignOut();
    }

    /// <summary>
    ///     abstraction function to submit a play to the database
    /// </summary>
    /// <param name="playData">play data</param>
    /// <param name="callback">callback function that takes in one DatabaseTransactionResult argument</param>
    public void SubmitPlay(
        PlayData playData,
        Action<DatabaseTransactionResult> callback)
    {
        throw new NotImplementedException();
    }

    /// <summary>
    ///     abstraction function to get and calculate the user's rating from the database
    ///     calculation is done locally, call UpdateUserRating to update the user's rating in the database
    /// </summary>
    /// <param name="callback">callback function that takes in a DatabaseTransactionResult and float (user rating) argument</param>
    public void CalculateUserRating(
        Action<DatabaseTransactionResult, float> callback)
    {
        throw new NotImplementedException();
    }

    /// <summary>
    ///     abstraction function to update the user's rating in the database
    /// </summary>
    /// <param name="newRating">new user rating value as a float</param>
    /// <param name="callback">callback function that takes in one DatabaseTransactionResult argument</param>
    public void UpdateUserRating(
        float newRating,
        Action<DatabaseTransactionResult> callback)
    {
        throw new NotImplementedException();
    }

    /// <summary>
    ///     abstraction function to get the leaderboard from the database
    /// </summary>
    /// <param name="callback">
    ///     callback function that takes in a DatabaseTransactionResult and LeaderboardEntry[] argument
    /// </param>
    public void GetLeaderboard(
        Action<DatabaseTransactionResult, LeaderboardEntry[]> callback)
    {
        throw new NotImplementedException();
    }

    // private void Playground()
    // {
    //     // update username
    //     _db.Child("users").Child(_user.UserId).Child("username").SetValueAsync("newusername").ContinueWith(task => { });
    //
    //     // update email
    //     _user.SendEmailVerificationBeforeUpdatingEmailAsync("name@example.com").ContinueWith(task => { });
    //
    //     // update password
    //     _user.UpdatePasswordAsync("password").ContinueWith(task => { });
    //
    //     // reset password
    //     _auth.SendPasswordResetEmailAsync("name@example.com").ContinueWith(task => { });
    // }

    /// <summary>
    ///     struct for a leaderboard entry
    /// </summary>
    public struct LeaderboardEntry
    {
        public string Username;
        public float Rating;
        public int PlayCount;

        public LeaderboardEntry(string username, float rating, int playCount)
        {
            Username = username;
            Rating = rating;
            PlayCount = playCount;
        }
    }

    /// <summary>
    ///     struct for play data
    /// </summary>
    public struct PlayData
    {
        public int RoundsPlayed;
        public float AverageOverallAccuracy;
        public float AverageLightnessAccuracy;
        public float AverageChromaAccuracy;
        public float AverageHueAccuracy;
    }
}