using System.Net.Http.Json;
using System.Text;
using System.Text.Json;
using AyCode.Core.Extensions;
using AyCode.Interfaces.StorageHandlers;
using AyCode.Services.Loggers;
using Microsoft.IdentityModel.Tokens;
using Newtonsoft.Json;
using TIAM.Models.Dtos.Users;
using TIAM.Services;
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;

namespace TIAMWebApp.Shared.Application.Services;

public abstract class UserDataServiceClientBase : IUserDataService
{
    protected readonly HttpClient Http;
    protected readonly LoggerClient Logger;
    protected readonly AdminSignalRClient AdminSignalRClient;

    protected readonly ISessionService SessionService;
    protected readonly ISecureStorageHandler SecureStorageHandler;
    protected readonly IServiceProviderDataService ServiceProviderDataService;
        

    protected UserDataServiceClientBase(HttpClient http, AdminSignalRClient adminSignalRClient, ISessionService sessionService, ISecureStorageHandler secureStorageHandler, IServiceProviderDataService serviceProviderDataService, IEnumerable<IAcLogWriterClientBase> logWriters)
    {
        Http = http;
        AdminSignalRClient = adminSignalRClient;

        SessionService = sessionService;
        SecureStorageHandler = secureStorageHandler;
        
        ServiceProviderDataService = serviceProviderDataService;
        Logger = new LoggerClient(this.GetType().Name, logWriters.ToArray());
    }


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

        if (userModelDto == null) return 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;
    }

    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<MainResponse?> AuthenticateUser(LoginModel loginModel)
    {
        Logger.Debug($"AuthenticateUser; email: {loginModel.Email}");

        return await AdminSignalRClient.PostDataAsync<LoginModel, MainResponse>(SignalRTags.AuthenticateUser, loginModel);

        //var 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)
    {
        var isSuccess = true;
        var result = string.Empty;
        var url = $"{Setting.ApiBaseUrl}/{APIUrls.CreateUser}";

        Logger.Debug("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)
    {
        var isSuccess = false;
        var result = string.Empty;
        var user = new UserModelDto();
        var url = $"{Setting.ApiBaseUrl}/{APIUrls.CreateGuestUser}";

        Logger.Debug("CreateGuestUser url: " + url);

        var response = await Http.PostAsJsonAsync(url, regModel);
        
        if (response.IsSuccessStatusCode)
        {
            isSuccess = true;
            result = await response.Content.ReadAsStringAsync();
            Logger.Debug("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()
    {
        Logger.Debug($"GetUsersAsync");

        return await AdminSignalRClient.GetAllAsync<List<UserModelDto>>(SignalRTags.GetAllUserModelDto) ?? [];
        
        //return await Http.GetFromJsonAsync<List<UserModelDto>>(APIUrls.GetUsers);
    }

    public async Task<List<UserModelDtoDetail>> GetUsersWithDetailsAsync()
    {
        Logger.Debug($"GetUsersWithDetailsAsync");

        return await AdminSignalRClient.GetAllAsync<List<UserModelDtoDetail>>(SignalRTags.GetAllUserModelDtoDetails) ?? [];

        ////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)
    {
        Logger.Debug($"GetUserByEmailAsync; email: {email}");

        return await AdminSignalRClient.GetByIdAsync<UserModelDto>(SignalRTags.GetUserModelDtoByEmail, 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.IsSuccessStatusCode)
        //    {
        //        var jsonResponse = await response.Content.ReadAsStringAsync();
        //        var user = System.Text.Json.JsonSerializer.Deserialize<UserModelDto>(jsonResponse, new JsonSerializerOptions
        //        {
        //            PropertyNameCaseInsensitive = true
        //        });
        //        return user;
        //    }

        //    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)
    {
        Logger.Debug($"GetUserByIdAsync; id: {id}");

        return await AdminSignalRClient.GetByIdAsync<UserModelDto>(SignalRTags.GetUserModelDtoById, id);

        //var url = $"{Setting.ApiBaseUrl}/{APIUrls.GetUserById}";
        //Logger.Debug("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.Debug($"GetUserDetailByIdAsync; id: {id}");

        return await AdminSignalRClient.GetByIdAsync<UserModelDtoDetail>(SignalRTags.GetUserModelDtoDetailById, id);

        //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.Debug("RefreshToken() called");

        var isTokenRefreshed = false;
        MainResponse? mainResponse = null;

        try
        {
            var postAuthenticationTokens = new AuthenticationTokens
            {
                RefreshToken = Setting.UserBasicDetails.RefreshToken,
                AccessToken = Setting.UserBasicDetails.AccessToken
            };

            mainResponse = await AdminSignalRClient.PostDataAsync<AuthenticationTokens, MainResponse>(SignalRTags.RefreshToken, postAuthenticationTokens);

            if (mainResponse is { IsSuccess: true })
            {
                var tokenDetails = mainResponse.Content.ToJson().JsonTo<AuthenticationTokens>();
                if (tokenDetails == null || string.IsNullOrWhiteSpace(tokenDetails.AccessToken) || string.IsNullOrWhiteSpace(tokenDetails.RefreshToken))
                {
                    Logger.Error($"Refreshtoken error! tokenDetails == null || string.IsNullOrWhiteSpace(tokenDetails.AccessToken) || string.IsNullOrWhiteSpace(tokenDetails.RefreshToken); AccessToken: {tokenDetails?.AccessToken}; RefreshToken: {tokenDetails?.RefreshToken}");
                }
                else
                {
                    Setting.UserBasicDetails.AccessToken = tokenDetails.AccessToken;
                    Setting.UserBasicDetails.RefreshToken = tokenDetails.RefreshToken;

                    var userDetailsStr = Setting.UserBasicDetails.ToJson(); //JsonConvert.SerializeObject(Setting.UserBasicDetails);
                    await SecureStorageHandler.SaveToSecureStorageAsync(nameof(Setting.UserBasicDetails), userDetailsStr);
                    isTokenRefreshed = true;
                }
            }
            else Logger.Info($"Refreshtoken is not success! {mainResponse?.ErrorMessage ?? "mainResponse == null"}");
        }
        catch (Exception ex)
        {
            Logger.Error($"Refreshtoken, {mainResponse?.ErrorMessage ?? "mainResponse == null"}! exception: {ex.Message}", ex);
        }

        return isTokenRefreshed;
    }

    public async Task<bool> Logout(string? refreshToken)
    {
        Logger.Info($"Logout called; refreshToken: {refreshToken}");

        var url = $"{Setting.ApiBaseUrl}/{APIUrls.LogoutUser}";
        var result = false;
        var response = await Http.PostAsJsonAsync(url, refreshToken);

        if (response.IsSuccessStatusCode)
        {
            var 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)
    {
        var 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)
    {
        var 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 async Task<bool> SendWelcomeMail(string emailAddress)
    {
        Logger.Info("SendWelcomeMail() called");

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

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

    /*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);

        }*/
}