namespace PS.IPAM.Helpers;
using System;
using System.Management.Automation;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
using PS.IPAM;

public static class SessionManager
{
    private static Session? _currentSession;

    public static Session? CurrentSession
    {
        get => _currentSession;
        set => _currentSession = value;
    }

    public static string TestSession()
    {
        if (_currentSession == null)
        {
            return "NoToken";
        }

        if (_currentSession.Expires == null)
        {
            return "Valid";
        }

        if (_currentSession.Expires < DateTime.Now)
        {
            return "Expired";
        }

        return "Valid";
    }

    public static async Task<Session> CreateSessionWithCredentials(
        string url,
        string appId,
        PSCredential credentials,
        bool ignoreSsl = false)
    {
        var uri = $"{url}/api/{appId}/user";
        var auth = Convert.ToBase64String(
            Encoding.UTF8.GetBytes($"{credentials.UserName}:{GetPassword(credentials)}"));

        using var client = CreateHttpClient(ignoreSsl);
        client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
        client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", auth);

        var response = await client.PostAsync(uri, null);
        var content = await response.Content.ReadAsStringAsync();
        var jsonResponse = JsonConvert.DeserializeObject<dynamic>(content);

        if (jsonResponse?.success != true)
        {
            throw new Exception(jsonResponse?.error?.ToString() ?? "Failed to create session");
        }

        var token = jsonResponse.data.token.ToString();
        var expires = DateTime.Parse(jsonResponse.data.expires.ToString());

        _currentSession = new Session(
            AuthType.credentials,
            token,
            appId,
            url,
            expires,
            credentials
        );

        return _currentSession;
    }

    public static Session CreateSessionWithToken(
        string url,
        string appId,
        string token)
    {
        _currentSession = new Session(
            AuthType.token,
            token,
            appId,
            url,
            null,
            null
        );

        return _currentSession;
    }

    public static void CloseSession()
    {
        _currentSession = null;
    }

    private static string GetPassword(PSCredential credential)
    {
        var ptr = System.Runtime.InteropServices.Marshal.SecureStringToBSTR(credential.Password);
        try
        {
            return System.Runtime.InteropServices.Marshal.PtrToStringBSTR(ptr);
        }
        finally
        {
            System.Runtime.InteropServices.Marshal.ZeroFreeBSTR(ptr);
        }
    }

    public static HttpClient CreateHttpClient(bool ignoreSsl = false, HttpMessageHandler? handler = null)
    {
        if (handler != null)
        {
            return new HttpClient(handler);
        }

        if (ignoreSsl)
        {
            var sslHandler = new HttpClientHandler
            {
                ServerCertificateCustomValidationCallback = (message, cert, chain, errors) => true
            };
            return new HttpClient(sslHandler);
        }
        return new HttpClient();
    }
}