using ScoreTracker.Configuration;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http;
using System.Threading.Tasks;

namespace ScoreTracker.API
{
    internal class AuthHelper
    {
        public bool IsLoggedIn;
        public string FailReason = "";

        /// <summary>
        /// Ensure the user is logged in
        /// </summary>
        /// <returns>the task</returns>
        public async Task EnsureLoggedIn()
        {
            if (Authentication.IsSignedIn() && await Authentication.ValidateAuthToken())
            {
                return; // Already logged in with a valid token
            }

            await Authentication.LoginUser(
                token => {
                    IsLoggedIn = true;
                    Request.PersistHeaders(new Dictionary<string, string>
                    {
                            { "Authorization", $"Bearer {token}" }
                    });
                },
                reason =>
                {
                    FailReason = reason; // Store the reason for failure
                    Request.HttpClient.DefaultRequestHeaders.Clear(); // Clear headers
                }
            );
        }
    }

    internal class Authentication
    {
        private static bool _signedIn = false;
        private static string _authToken;

        /// <summary>
        /// Are we signed in?
        /// </summary>
        public static bool IsSignedIn()
        {
            return _signedIn;
        }

        /// <summary>
        /// Get the steam ticket and user info
        /// </summary>
        /// <returns>the steam ticket</returns>
        private static async Task<string> GetSteamTicket()
        {
            Plugin.Log.Info("Getting steam ticket...");
            return (await new SteamPlatformUserModel().GetUserAuthToken()).token;
        }

        /// <summary>
        /// Login the user
        /// </summary>
        /// <param name="onSuccess">callback for successful login, returns the token</param>
        /// <param name="onFail">callback for failed login</param>
        /// <returns>an IEnumerator</returns>
        public static async Task LoginUser(Action<string> onSuccess, Action<string> onFail)
        {
            if (_signedIn && !string.IsNullOrEmpty(_authToken))
            {
                onSuccess(_authToken);
                return;
            }

            var ticketTask = GetSteamTicket();
            await Task.Run(() => ticketTask.Wait());

            var ticket = ticketTask.Result;
            if (string.IsNullOrEmpty(ticket))
            {
                Plugin.Log.Error("Login failed :( no steam auth token");
                onFail("No Steam Auth Token");
                return;
            }

            Plugin.Log.Info("Logging in...");
            var request = await Request.PostJsonAsync($"{PluginConfig.Instance.ApiUrl}/auth/login", new Dictionary<object, object> {
                { "ticket", ticket }
            }, false);
            if (request.IsSuccessStatusCode)
            {
                var authToken = request.Headers.GetValues("Authorization").First();
                Plugin.Log.Info($"Login successful! auth token: {authToken}"); 

                onSuccess(authToken);
                _signedIn = true;
                _authToken = authToken;
            }
            else
            {
                Plugin.Log.Error($"Login failed! body: {request.StatusCode}");
                onFail($"Login failed: {request.StatusCode}");

                _signedIn = false;
                _authToken = null;
            }
        }


        /// <summary>
        /// Validates the auth token and logs out if it's invalid
        /// </summary>
        /// <returns>whether the token is valid</returns>
        public static async Task<bool> ValidateAuthToken()
        {
            if (!_signedIn || string.IsNullOrEmpty(_authToken)) // If we're not signed in, return false
            {
                return false;
            }

            var request = await Request.PostJsonAsync($"{PluginConfig.Instance.ApiUrl}/auth/validate", new Dictionary<object, object> {
                { "token", _authToken }
            }, false);

            if (request.IsSuccessStatusCode)
            {
                return true;
            }
            else
            {
                _signedIn = false;
                _authToken = null;
                return false;
            }
        }
    }
}