using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.Diagnostics;
using Newtonsoft.Json;

public class AtonHealthMonitor
{
    private readonly HttpClient _httpClient;
    private readonly string _baseUrl;
    private readonly IAtonHealthAuth _authClient;

    public AtonHealthMonitor(string baseUrl, IAtonHealthAuth authClient)
    {
        _httpClient = new HttpClient { Timeout = TimeSpan.FromSeconds(10) };
        _baseUrl = baseUrl;
        _authClient = authClient;
    }

    public async Task<HealthCheckResult> PingAsync()
    {
        var stopwatch = Stopwatch.StartNew();

        try
        {
            var token = await _authClient.GetAccessTokenAsync();

            var request = new HttpRequestMessage(HttpMethod.Get, $"{_baseUrl}/health/ping");
            request.Headers.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", token);
            request.Headers.Add("Content-Type", "application/json");

            var response = await _httpClient.SendAsync(request);
            stopwatch.Stop();

            response.EnsureSuccessStatusCode();

            var content = await response.Content.ReadAsStringAsync();
            var pingResponse = JsonConvert.DeserializeObject<PingResponse>(content);

            return new HealthCheckResult
            {
                Success = true,
                Message = pingResponse.Message,
                ServerTimestamp = pingResponse.Timestamp,
                ResponseTimeMs = stopwatch.ElapsedMilliseconds,
                StatusCode = (int)response.StatusCode
            };
        }
        catch (Exception ex)
        {
            stopwatch.Stop();

            return new HealthCheckResult
            {
                Success = false,
                Error = ex.Message,
                ResponseTimeMs = stopwatch.ElapsedMilliseconds,
                Timestamp = DateTime.UtcNow.ToString("yyyy-MM-ddTHH:mm:ss.ffffffZ")
            };
        }
    }

    public async Task<HealthCheckResult> HealthCheckWithRetryAsync(int maxRetries = 3, int initialDelayMs = 1000)
    {
        var delay = initialDelayMs;

        for (int attempt = 0; attempt < maxRetries; attempt++)
        {
            var result = await PingAsync();

            if (result.Success)
            {
                return result;
            }

            if (attempt < maxRetries - 1)
            {
                Console.WriteLine($"Health check failed (attempt {attempt + 1}/{maxRetries}), retrying in {delay}ms...");
                await Task.Delay(delay);
                delay *= 2; // Exponential backoff
            }
        }

        return await PingAsync();
    }

    public class HealthCheckResult
    {
        public bool Success { get; set; }
        public string Message { get; set; }
        public string ServerTimestamp { get; set; }
        public long ResponseTimeMs { get; set; }
        public int? StatusCode { get; set; }
        public string Error { get; set; }
        public string Timestamp { get; set; }
    }

    private class PingResponse
    {
        [JsonProperty("message")]
        public string Message { get; set; }

        [JsonProperty("timestamp")]
        public string Timestamp { get; set; }
    }
}

// Usage example
var auth = new AtonHealthAuth();
var monitor = new AtonHealthMonitor("https://api.aton.health", auth);

var result = await monitor.PingAsync();
if (result.Success)
{
    Console.WriteLine($"API is healthy - Response: {result.Message}");
    Console.WriteLine($"Server time: {result.ServerTimestamp}");
    Console.WriteLine($"Response time: {result.ResponseTimeMs}ms");
}
else
{
    Console.WriteLine($"API health check failed: {result.Error}");
}