using Dpz.Core.EnumLibrary;

namespace Dpz.Core.Web.Jobs.Hangfire.Build;

/// <summary>
/// 探测各发布目标当前运行版本，并与即将发布的版本比较
/// </summary>
public class PipelineVersionProbe(
    IHttpClientFactory httpClientFactory,
    IConfiguration configuration,
    ILogger<PipelineVersionProbe> logger
)
{
    public const string HttpClientName = "pipeline-version";
    public const string WaitCacheKeyPrefix = "pipeline:version-wait:";
    public const string DecisionCacheKeyPrefix = "pipeline:version-decision:";
    public const string DecisionConfirm = "confirm";
    public const string DecisionCancel = "cancel";

    public static readonly TimeSpan ConfirmTimeout = TimeSpan.FromMinutes(2);

    public static string WaitCacheKey(string runId) => $"{WaitCacheKeyPrefix}{runId}";

    public static string DecisionCacheKey(string runId) => $"{DecisionCacheKeyPrefix}{runId}";

    /// <summary>
    /// 找出即将发布版本与线上运行版本相同的项目。
    /// 未配置 host、探测失败的项目会被跳过，不阻断发布。
    /// </summary>
    public async Task<List<PipelineVersionMatch>> FindSameVersionsAsync(
        IReadOnlyDictionary<BuildProject, string> publishVersions,
        CancellationToken cancellationToken = default
    )
    {
        var hosts = ReadVersionHosts();
        var matches = new List<PipelineVersionMatch>();
        foreach (var (project, publishVersion) in publishVersions)
        {
            if (project == BuildProject.None)
            {
                continue;
            }

            if (!hosts.TryGetValue(project.ToString(), out var host))
            {
                logger.LogWarning("未配置 {Project} 的版本探测地址，已跳过同版本检查", project);
                continue;
            }

            var liveVersion = await ProbeLiveVersionAsync(project, host, cancellationToken);
            if (string.IsNullOrWhiteSpace(liveVersion))
            {
                continue;
            }

            if (!IsSameVersion(liveVersion, publishVersion))
            {
                continue;
            }

            matches.Add(
                new PipelineVersionMatch
                {
                    Project = project,
                    Host = host,
                    LiveVersion = liveVersion,
                    PublishVersion = publishVersion,
                }
            );
        }

        return matches;
    }

    private Dictionary<string, string> ReadVersionHosts()
    {
        var section = configuration.GetSection("Pipeline:VersionHosts");
        var hosts = section.Get<Dictionary<string, string>>() ?? [];
        var lookup = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
        foreach (var (key, value) in hosts)
        {
            if (string.IsNullOrWhiteSpace(key) || string.IsNullOrWhiteSpace(value))
            {
                continue;
            }

            lookup[key.Trim()] = value.Trim();
        }

        return lookup;
    }

    private async Task<string?> ProbeLiveVersionAsync(
        BuildProject project,
        string host,
        CancellationToken cancellationToken
    )
    {
        if (
            !Uri.TryCreate(host, UriKind.Absolute, out var baseUri)
            || (baseUri.Scheme != Uri.UriSchemeHttp && baseUri.Scheme != Uri.UriSchemeHttps)
        )
        {
            logger.LogWarning(
                "{Project} 的版本探测地址无效，已跳过同版本检查：{Host}",
                project,
                host
            );
            return null;
        }

        var url = new Uri(baseUri, "/api/version");
        try
        {
            var client = httpClientFactory.CreateClient(HttpClientName);
            var raw = (await client.GetStringAsync(url, cancellationToken)).Trim().Trim('"');
            if (string.IsNullOrWhiteSpace(raw))
            {
                logger.LogWarning("{Project} 线上版本为空，已跳过同版本检查：{Url}", project, url);
                return null;
            }

            return raw;
        }
        catch (Exception e)
        {
            logger.LogWarning(e, "探测 {Project} 线上版本失败：{Url}", project, url);
            return null;
        }
    }

    private static bool IsSameVersion(string liveVersion, string publishVersion)
    {
        if (
            Version.TryParse(liveVersion, out var live)
            && Version.TryParse(publishVersion, out var publish)
        )
        {
            return live == publish;
        }

        return string.Equals(liveVersion, publishVersion, StringComparison.OrdinalIgnoreCase);
    }
}

/// <summary>
/// 用户未确认或超时未确认同版本发布
/// </summary>
public sealed class PipelineVersionNotConfirmedException(string message) : Exception(message);