using Newtonsoft.Json;
using System.Net.Http.Json;
using System.Text;
using TIAMWebApp.Shared.Application.Interfaces;
using TIAMWebApp.Shared.Application.Models;
using TIAMWebApp.Shared.Application.Models.ClientSide;
using TIAMWebApp.Shared.Application.Models.PageModels;
using TIAMWebApp.Shared.Application.Utility;
using AyCode.Interfaces.StorageHandlers;
using TIAM.Models.Dtos.Users;
using AyCode.Services.Loggers;
using System.Net.Http;
using AyCode.Core.Extensions;
using System.Text.Json;


namespace TIAMWebApp.Client.Services
{
    public class UserDataServiceWeb : IUserDataService
    {
        private readonly HttpClient http;
        private readonly ISecureStorageHandler secureStorageHandler;
        //private readonly BrowserConsoleLogWriter _browserConsoleLogWriter;
        private readonly IServiceProviderDataService serviceProviderDataService;
        private readonly LoggerClient<UserDataServiceWeb> _logger;

        

        public UserDataServiceWeb(HttpClient http, ISecureStorageHandler secureStorageHandler, IServiceProviderDataService serviceProviderDataService, IEnumerable<IAcLogWriterClientBase> logWriters)
        //public UserDataServiceWeb(HttpClient http, ISecureStorageHandler secureStorageHandler, IJSRuntime jSRuntime, IServiceProviderDataService serviceProviderDataService, HttpClientLogItemWriter logWriter)
        {
            this.http = http;
            this.secureStorageHandler = secureStorageHandler;
            
            //this._browserConsoleLogWriter = new BrowserConsoleLogWriter(jsRuntime);
            this.serviceProviderDataService = serviceProviderDataService;
            _logger = new LoggerClient<UserDataServiceWeb>(logWriters.ToArray());
            //_logger = new TIAM.Core.Loggers.Logger<UserDataServiceWeb>(AppType.Web, LogLevel.Info, logWriters.ToArray());
            //_logger = new TIAM.Core.Loggers.Logger<UserDataServiceWeb>(AppType.Web, LogLevel.Info, logWriter);
        }
        

        public async Task<UserSessionModel> IsLoggedInAsync(Guid id)
        {
            //api call to get user
            var userModelDto = await GetUserDetailByIdAsync(id);

            if (userModelDto != null)
            {
                var userProperties = new Dictionary<Guid, string>();
                //get user's properties
                var hasProperties = userModelDto.ServiceProviders.Count > 0 ? true : (userModelDto.ServiceProviders.Count == 0 ? false : false);
                if (hasProperties)
                {

                    //var Properties = await serviceProviderDataService.GetPropertiesByOwnerIdAsync(userModelDto.Id);
                    var properties = userModelDto.ServiceProviders;
                    
                    _logger.Info($"{properties.Count} properties found");
                    foreach ( var property in properties )
                    {
                        userProperties.Add(property.Id, property.Name); 
                    }
                }

                //create user session model
                var user = new UserSessionModel(userModelDto.Id, UserType.User, userModelDto, userProperties, 1);
                return user;
            }
            else
            {

                return null;
            }

        }

        public async Task<string> TestUserApi(int Param)
        {
            var url = $"{Setting.ApiBaseUrl}/{APIUrls.UserTest}";


            var response = await http.PostAsJsonAsync(url, Param);
            var result = await response.Content.ReadAsStringAsync();
            return result;
        }

        public async Task<string> AuthenticateUser(LoginModel loginModel)
        {
            string result = string.Empty;
            var url = $"{Setting.ApiBaseUrl}/{APIUrls.AuthenticateUser}";

            var response = await http.PostAsJsonAsync(url, loginModel);

            //try
            //{
            //    Logger.Detail("Login started: " + "Email: " + loginModel.Email + ", Password: " + loginModel.Password);
            //}
            //catch (Exception ex)
            //{
            //    _logger.Error(ex.Message, ex);
            //}

            if (response.IsSuccessStatusCode)
            {
                result = await response.Content.ReadAsStringAsync();
            }
            else
            {
                result = await response.Content.ReadAsStringAsync();
            }

            //result = await response.Content.ReadAsStringAsync();            
            return result;

        }

        public async Task<(bool isSuccess, string ErrorMessage)> CreateUser(RegistrationModel regModel)
        {

            bool isSuccess = true;
            string result = string.Empty;
            var url = $"{Setting.ApiBaseUrl}/{APIUrls.CreateUser}";
            _logger.Info("CreateUser url: " + url);
            var response = await http.PostAsJsonAsync(url, regModel);
            result = await response.Content.ReadAsStringAsync();
            /*if (response.IsSuccessStatusCode)
            {
                isSuccess = true;
                result = await response.Content.ReadAsStringAsync();
            }
            else
            {
                isSuccess = false;
                result = await response.Content.ReadAsStringAsync();
            }*/


            return (isSuccess, result);
        }

        public async Task<(bool isSuccess, UserModelDto? user)> CreateGuestUser(RegistrationModel regModel)
        {

            bool isSuccess = false;
            string result = string.Empty;
            UserModelDto? user = new UserModelDto();
            var url = $"{Setting.ApiBaseUrl}/{APIUrls.CreateGuestUser}";
            _logger.Info("CreateGuestUser url: " + url);
            var response = await http.PostAsJsonAsync(url, regModel);
            

            if (response.IsSuccessStatusCode)
            {
                isSuccess = true;
                result = await response.Content.ReadAsStringAsync();
                _logger.Info("CreateGuestUser result: " + result);
                user = JsonConvert.DeserializeObject<UserModelDto>(result);
            }
            else
            {
                isSuccess = false;
                result = await response.Content.ReadAsStringAsync();
                user = null;
            }


            return (isSuccess, user);
        }


        public async Task<List<UserModelDto>?> GetUsersAsync()
        {
            return await http.GetFromJsonAsync<List<UserModelDto>>(APIUrls.GetUsers);
        }

        public async Task<List<UserModelDtoDetail>> GetUsersWithDetailsAsync()
        {
            var url = $"{Setting.ApiBaseUrl}/{APIUrls.GetUsersWithDetails}";

            _logger.Info("GetUserByEmailAsync url: " + url + "!");
            var response = await http.GetFromJsonAsync<List<UserModelDtoDetail>>(APIUrls.GetUsersWithDetails);
            //var result = await response.Content.ReadAsStringAsync();
            //var user = JsonConvert.DeserializeObject<UserModelDto>(result);
            return response ?? [];

        }

        public async Task<UserModelDto?> GetUserByEmailAsync(string email)
        {
            

            try
            {
                var url = $"{Setting.ApiBaseUrl}/{APIUrls.GetUserByEmail}/{email}";
                _logger.Info("GetUserByEmailAsync url: " + url + ", " + email);
                var response = await http.GetAsync(url);

                response.EnsureSuccessStatusCode();
                if (response.Content != null)
                {
                    var jsonResponse = await response.Content.ReadAsStringAsync();
                    var user = System.Text.Json.JsonSerializer.Deserialize<UserModelDto>(jsonResponse, new JsonSerializerOptions
                    {
                        PropertyNameCaseInsensitive = true
                    });
                    return user;
                }

                else
                {
                    return null;
                }

            }
            catch (HttpRequestException httpRequestException)
            {
                // Handle specific HTTP request exceptions
                _logger.DebugConditional($"Request error: {httpRequestException.Message}");
                throw;
            }
            catch (Exception ex)
            {
                // Handle other possible exceptions
                _logger.DebugConditional($"An error occurred: {ex.Message}");
                throw;
            }



        }

        public async Task<UserModelDto?> GetUserByIdAsync(Guid id)
        {
            var url = $"{Setting.ApiBaseUrl}/{APIUrls.GetUserById}";
            _logger.Info("GetUserByIdAsync url: " + url + ", " + id.ToString());

            var response = await http.PostAsJsonAsync(url, id);
            var result = await response.Content.ReadAsStringAsync();
            var user = JsonConvert.DeserializeObject<UserModelDto>(result);

            return user;
        }

        public async Task<UserModelDtoDetail?> GetUserDetailByIdAsync(Guid id)
        {
            _logger.Info("GetUserDetailByIdAsync", "GLOBAL_LOGGER");

            var url = $"{Setting.ApiBaseUrl}/{APIUrls.GetUserDetailById}";
            _logger.Info("GetUserDetailByIdAsync url: " + url + ", " + id.ToString());

            var response = await http.PostAsJsonAsync(url, id);
            //var result = await response.Content.ReadAsStringAsync();
            var result = await response.Content.ReadFromJsonAsync<UserModelDtoDetail>();
            //var user = JsonConvert.DeserializeObject<UserModelDtoDetail>(result);

            return result;
        }

        public async Task<bool> RefreshToken()
        {
            _logger.Info("RefreshToken() called");
            bool isTokenRefreshed = false;

            var url = $"{Setting.ApiBaseUrl}/{APIUrls.RefreshToken}";
            //var url = APIUrls.RefreshToken;                

            var serializedStr = JsonConvert.SerializeObject(new AuthenticateRequestAndResponse
            {
                RefreshToken = Setting.UserBasicDetails.RefreshToken,
                AccessToken = Setting.UserBasicDetails.AccessToken
            });

            try
            {
                _logger.Info("Refreshtoken url: " + url);
                var response = await http.PostAsync(url, new StringContent(serializedStr, Encoding.UTF8, "application/json"));
                if (response.IsSuccessStatusCode)
                {
                    string contentStr = await response.Content.ReadAsStringAsync();
                    var mainResponse = JsonConvert.DeserializeObject<MainResponse>(contentStr);
                    if (mainResponse.IsSuccess)
                    {
                        var tokenDetails = JsonConvert.DeserializeObject<AuthenticateRequestAndResponse>(mainResponse.Content.ToString());
                        Setting.UserBasicDetails.AccessToken = tokenDetails.AccessToken;
                        Setting.UserBasicDetails.RefreshToken = tokenDetails.RefreshToken;

                        string userDetailsStr = JsonConvert.SerializeObject(Setting.UserBasicDetails);
                        await secureStorageHandler.SaveToSecureStorageAsync(nameof(Setting.UserBasicDetails), userDetailsStr);
                        isTokenRefreshed = true;
                    }
                }
            }
            catch (Exception ex)
            {
                string msg = ex.Message;
                _logger.Error("Refreshtoken exception: " + ex.Message, ex);
            }



            return isTokenRefreshed;
        }

        public async Task<bool> Logout(string refreshToken)
        {
            _logger.Info("Logout() called");

            var url = $"{Setting.ApiBaseUrl}/{APIUrls.LogoutUser}";
            bool result = false;
            var response = await http.PostAsJsonAsync(url, refreshToken);
            if (response.IsSuccessStatusCode)
            {
                string resultMessage = await response.Content.ReadAsStringAsync();
                _logger.Detail($"Logout response: {resultMessage}");                
                if(resultMessage == "OK")
                {
                    result = true;
                }
                else
                {
                    result = false;
                }
            }
            else
            {
                result = false;
            }

            _logger.Detail($"Logout: {result}");
            return result;
        }

        public async Task<bool> SendForgottenPasswordMail(string emailAddress)
        {
            _logger.Info("SendForgottenPasswordMail() called");

            var url = $"{Setting.ApiBaseUrl}/{APIUrls.SendForgottenPasswordMail}";
            var response = await http.PostAsJsonAsync(url, emailAddress);
            var success = await response.Content.ReadFromJsonAsync<bool>();

            _logger.Detail($"SendForgottenPasswordMail(): {success.ToString()}");
            return success;
        }

        public async Task<string> ValidateForgotPasswordToken(Guid userId, string token)
        {
            string? result = "";
            _logger.Info("ValidateForgotPasswordToken() called");

            var url = $"{Setting.ApiBaseUrl}/{APIUrls.ValidateForgottenPasswordToken}";
            var parameters = new[] { userId.ToString(), token };

            var response = await http.PostAsJsonAsync(url, parameters);
            result = await response.Content.ReadAsStringAsync();

            _logger.Detail($"ValidateForgotPasswordToken(): {result}");

            return result;
        }

        public async Task<bool> SetEmailConfirmed(Guid userId)
        {
            bool result = false;
            _logger.Info("SetEmailConfirmed() called");

            var url = $"{Setting.ApiBaseUrl}/{APIUrls.SetEmailConfirmed}";
            
            var response = await http.PostAsJsonAsync(url, userId);
            result = await response.Content.ReadFromJsonAsync<bool>();

            _logger.Detail($"ValidateForgotPasswordToken(): {result.ToString()}");

            return result;
        }

        /*public Task<Dictionary<int, string>> GetUserRolesAsync(UserModel userModel)
        {
            //TODO: finish this
            //get the userModel's roles
            int role = userModel.UserRoles;

            foreach (var roleType in roleTypes)
            {
                if ((role & roleType.Id) == roleType.Id)
                {

                    //add the role to the dictionary
                    userRoleTypes.Add(roleType.Id, roleType.RoleName);

                }
            }
            return Task.FromResult(userRoleTypes);

        }*/
    }
}