using System.Net.Sockets;
using Dpz.Core.Public.ViewModel.Response;
using ProtocolType = Dpz.Core.EnumLibrary.ProtocolType;

namespace Dpz.Core.Service.Mediator.Features.Health.Commands;

/// <summary>
/// 处理健康检查任务，按配置周期执行端点探测并更新检查结果。
/// </summary>
public class HealthCheckHandler(
    IRepository<HealthCheck> repository,
    IMapper mapper,
    IHttpClientFactory httpClientFactory
) : IRequestHandler<HealthCheckRequest>
{
    private readonly HttpClient _httpClient = httpClientFactory.CreateClient("edge");
    private static Lazy<List<HealthCheckResponse>>? _lazyHealthChecks;

    /// <summary>
    /// 执行健康检查轮询。
    /// </summary>
    public async ValueTask<Unit> Handle(
        HealthCheckRequest request,
        CancellationToken cancellationToken
    )
    {
        if (_lazyHealthChecks is not { IsValueCreated: true })
        {
            var entities = await repository.SearchFor(x => true).ToListAsync(cancellationToken);
            var healthChecks = mapper.Map<List<HealthCheckResponse>>(entities);
            _lazyHealthChecks = new Lazy<List<HealthCheckResponse>>(() => healthChecks);
        }

        foreach (var item in _lazyHealthChecks.Value)
        {
            var lastCheckTime = item.LastCheckTime ?? DateTime.MinValue;
            var currentInterval = DateTime.Now - lastCheckTime;
            if (currentInterval >= item.Interval)
            {
                var result = await CheckAsync(item);
                item.LastCheckDuration = result.LastCheckDuration;
                item.LastCheckTime = result.LastCheckTime;
            }
        }

        return Unit.Value;
    }

    private async Task<HealthCheckResultResponse> CheckAsync(HealthCheckResponse healthCheck)
    {
        var checkTimer = Stopwatch.StartNew();
        var retries = 0;
        Exception? lastError = null;

        while (retries < healthCheck.RetryCount)
        {
            try
            {
                using var cts = new CancellationTokenSource(healthCheck.Timeout);
                var isHealthy = await CheckEndpointAsync(healthCheck, cts.Token);

                return new HealthCheckResultResponse()
                {
                    Status = isHealthy ? HealthStatus.Healthy : HealthStatus.Unhealthy,
                    LastCheckDuration = checkTimer.Elapsed,
                    LastCheckTime = DateTime.Now,
                    ErrorMessage = lastError?.Message,
                };
            }
            catch (Exception ex)
            {
                lastError = ex;
                retries++;
                await Task.Delay(1000);
            }
        }

        return new HealthCheckResultResponse()
        {
            Status = HealthStatus.Unhealthy,
            LastCheckDuration = checkTimer.Elapsed,
            LastCheckTime = DateTime.Now,
            ErrorMessage = lastError?.Message,
        };
    }

    private async Task<bool> CheckEndpointAsync(
        HealthCheckResponse healthCheck,
        CancellationToken cancellationToken
    )
    {
        return healthCheck.Protocol switch
        {
            ProtocolType.Http or ProtocolType.Https => await CheckHttpAsync(
                healthCheck,
                cancellationToken
            ),
            ProtocolType.Tcp => CheckTcp(healthCheck),
            _ => throw new NotSupportedException($"协议 {healthCheck.Protocol} 不支持"),
        };
    }

    private async Task<bool> CheckHttpAsync(
        HealthCheckResponse healthCheck,
        CancellationToken cancellationToken
    )
    {
        var response = await _httpClient.GetAsync(healthCheck.Endpoint, cancellationToken);
        return response.IsSuccessStatusCode;
    }

    private static bool CheckTcp(HealthCheckResponse healthCheck)
    {
        var parts = healthCheck.Endpoint.Split(':');
        using var tcpClient = new TcpClient();
        return tcpClient.ConnectAsync(parts[0], int.Parse(parts[1])).Wait(healthCheck.Timeout);
    }
}