using System.Net.Http.Headers;
using System.Text.Json;
using Microsoft.Extensions.Caching.Memory;
using Microsoft.Extensions.Options;
using ProofOfConcept.Models;
using ProofOfConcept.Utilities;
using SzakatsA.Result;

namespace ProofOfConcept.Services;

public class TeslaAuthenticatorService
{
    private readonly ILogger<TeslaAuthenticatorService> logger;
    private readonly TeslaAuthenticatorServiceConfiguration configuration;
    private readonly IHttpClientFactory httpClientFactory;
    private readonly IMemoryCache memoryCache;

    const string authEndpointURL = "https://fleet-auth.prd.vn.cloud.tesla.com/oauth2/v3/token";
    const string euBaseURL = "https://fleet-api.prd.eu.vn.cloud.tesla.com";

    public TeslaAuthenticatorService(ILogger<TeslaAuthenticatorService> logger, IOptions<TeslaAuthenticatorServiceConfiguration> options, IHttpClientFactory httpClientFactory, IMemoryCache memoryCache)
    {
        this.logger = logger;
        this.httpClientFactory = httpClientFactory;
        this.memoryCache = memoryCache;
        this.configuration = options.Value;
    }

    /// Asynchronously retrieves an authentication token from the Tesla partner API.
    /// This method sends a POST request with client credentials to obtain an
    /// OAuth2 access token that grants access to Tesla partner services.
    /// <return>Returns a string containing the authentication token received from the API.</return>
    /// <exception cref="HttpRequestException">Thrown when the HTTP request to the API fails.</exception>
    public async Task<Token> AcquirePartnerAuthenticationTokenAsync()
    {
        this.logger.LogTrace("Acquiring authentication token from Tesla partner API...");
        
        using HttpClient client = httpClientFactory.CreateClient();

        // URL to request the token
        const string audience = euBaseURL;

        // Prepare the form-urlencoded body
        Dictionary<string, string> formData = new Dictionary<string, string>
        {
            { "grant_type", "client_credentials" },
            { "client_id", this.configuration.ClientID },
            { "client_secret", this.configuration.ClientSecret },
            { "scope", "openid offline_access vehicle_device_data vehicle_location" },
            { "audience", audience }
        };

        FormUrlEncodedContent content = new FormUrlEncodedContent(formData);

        // Send POST request
        HttpResponseMessage response = await client.PostAsync(authEndpointURL, content);
        this.logger.LogTrace("Response status code: {0}", response.StatusCode);

        // Throw if not successful
        response.EnsureSuccessStatusCode();

        // Read the response body as a string
        string json = await response.Content.ReadAsStringAsync();
        
        // Deserialize
        Token? result = JsonSerializer.Deserialize<Token>(json);
        
        if (result is null)
            throw new FormatException($"Could not deserialize token response: {json}");
        
        // Return the token response
        return result;
    }

    /// Retrieves a cached partner authentication token or acquires a new one if not available.
    /// This method first attempts to fetch the token from the memory cache. If the token is not found
    /// or has expired, it invokes the method to retrieve a new token from the Tesla partner API and stores it in the cache.
    /// The cached token is set to expire slightly earlier than its actual expiration time to avoid unexpected token expiry during usage.
    /// <return>Returns a Token object containing the authentication token and its expiration details.</return>
    /// <exception cref="HttpRequestException">Thrown when the HTTP request to acquire a new partner token fails.</exception>
    /// <exception cref="Exception">Thrown for any unexpected errors during the token retrieval or caching process.</exception>
    public async Task<Token> GetPartnerAuthenticationTokenAsync()
    {
        this.logger.LogTrace("Getting partner authentication token...");
        
        //Token is available in cache
        if (this.memoryCache.TryGetValue(Keys.TeslaPartnerToken, out Token? token) && token is not null)
        {
            this.logger.LogInformation("Partner authentication token provided from cache");
            return token;
        }

        //Acquire token
        token = await AcquirePartnerAuthenticationTokenAsync();
        
        //Save to cache
        this.memoryCache.Set(Keys.TeslaPartnerToken, token, token.Expires.Subtract(this.configuration.MemoryCacheDelta));
        
        this.logger.LogInformation("Partner authentication token provided provided by acquiring from API");
        return token;
    }

    public async Task<Result> RegisterApplicationAsync(CancellationToken cancellationToken = default(CancellationToken))
    {
        this.logger.LogTrace("Registering application to Tesla fleet API...");

        //Create client and get partner token
        HttpClient httpClient = httpClientFactory.CreateClient();
        Token partnerToken = await GetPartnerAuthenticationTokenAsync();

        //Set headers
        httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
        httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", partnerToken.AccessToken);
        
        //Prepare body
        var postBody = new { domain = this.configuration.Domain };

        //Send request
        HttpResponseMessage response = await httpClient.PostAsJsonAsync($"{euBaseURL}/api/1/partner_accounts", postBody, cancellationToken);
        bool success = response.IsSuccessStatusCode;
        
        logger.LogInformation("Application registration result: {Success}", success ? "Success" : "Failed");
        return new Result(success);
    }

    public async Task<Result<bool>> CheckApplicationRegistrationAsync(CancellationToken cancellationToken = default(CancellationToken))
    {
        this.logger.LogTrace("Checking application registration...");
        
        //Create client and get partner token
        HttpClient httpClient = httpClientFactory.CreateClient();
        Token partnerToken = await GetPartnerAuthenticationTokenAsync();
        
        //Set headers
        httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
        httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", partnerToken.AccessToken);

        //Send request
        HttpResponseMessage response = await httpClient.GetAsync($"{euBaseURL}/api/1/partner_accounts", cancellationToken);
        string responseBody = await response.Content.ReadAsStringAsync(cancellationToken);
        
        logger.LogInformation("Application registration result: {Result}", responseBody);
        return new Result<bool>();
    }
}

public class TeslaAuthenticatorServiceConfiguration
{
    public string ClientID { get; set; } = "b2240ee4-332a-4252-91aa-bbcc24f78fdb";
    public string ClientSecret { get; set; } = "ta-secret.YG+XSdlvr6Lv8U-x";
    public TimeSpan MemoryCacheDelta { get; set; } = TimeSpan.FromSeconds(5);
    public string Domain { get; set; } = "tesla-connector.automatic-parking.app";
}