using Dpz.Core.Entity.Base;
using Dpz.Core.EnumLibrary;
using Dpz.Core.Infrastructure;
using Dpz.Core.Service.Mediator.Features.Account.Queries;
using Dpz.Core.Service.Mediator.Features.Pipeline.Contracts;
using Dpz.Core.Service.Mediator.Features.Pipeline.Queries;
using Dpz.Core.Web.Jobs.Hangfire;
using Dpz.Core.Web.Jobs.Hangfire.Build;
using Dpz.Core.Web.Jobs.Security;
using Hangfire;
using Mediator;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using MongoDB.Bson;
using ZiggyCreatures.Caching.Fusion;

namespace Dpz.Core.Web.Jobs.Controllers;

[Authorize]
public class PipelineController(
    IFusionCache fusionCache,
    SshConfigurationService sshConfigurationService,
    IMediator mediator
) : Controller
{
    public IActionResult Index()
    {
        if (!HangfireDashboardPermission.HasPermission(User, Permissions.System))
        {
            return Forbid();
        }

        var sshConfiguration = sshConfigurationService.GetSshConfiguration();
        var problems = SshConfigurationService.GetProblems(sshConfiguration);
        ViewData["ConfigProblems"] = problems;
        return View(sshConfiguration);
    }

    /// <summary>
    /// 查询当前是否有构建正在运行
    /// </summary>
    public async Task<JsonResult> Status(CancellationToken cancellationToken)
    {
        var current = await fusionCache.TryGetAsync<string>(
            BuildActivator.BuildLockKey,
            token: cancellationToken
        );
        var running = current.HasValue && !string.IsNullOrWhiteSpace(current.Value);
        var runId = running ? current.Value : null;
        var pendingConfirmation = false;
        List<PipelineVersionMatch>? matches = null;
        if (runId != null)
        {
            var wait = await fusionCache.TryGetAsync<List<PipelineVersionMatch>>(
                PipelineVersionProbe.WaitCacheKey(runId),
                token: cancellationToken
            );
            if (wait.HasValue && wait.Value.Count > 0)
            {
                pendingConfirmation = true;
                matches = wait.Value;
            }
        }

        return Json(
            new
            {
                running,
                runId,
                pendingConfirmation,
                matches,
            }
        );
    }

    /// <summary>
    /// 确认继续同版本发布
    /// </summary>
    [HttpPost]
    [ValidateAntiForgeryToken]
    public Task<ResponseResult> ConfirmVersion(string runId, CancellationToken cancellationToken)
    {
        return WriteVersionDecisionAsync(
            runId,
            PipelineVersionProbe.DecisionConfirm,
            cancellationToken
        );
    }

    /// <summary>
    /// 取消同版本发布
    /// </summary>
    [HttpPost]
    [ValidateAntiForgeryToken]
    public Task<ResponseResult> CancelVersion(string runId, CancellationToken cancellationToken)
    {
        return WriteVersionDecisionAsync(
            runId,
            PipelineVersionProbe.DecisionCancel,
            cancellationToken
        );
    }

    private async Task<ResponseResult> WriteVersionDecisionAsync(
        string runId,
        string decision,
        CancellationToken cancellationToken
    )
    {
        if (!HangfireDashboardPermission.HasPermission(User, Permissions.System))
        {
            return ResponseResult.Fail("没有权限访问");
        }

        if (string.IsNullOrWhiteSpace(runId))
        {
            return ResponseResult.Fail("运行 ID 无效");
        }

        var current = await fusionCache.TryGetAsync<string>(
            BuildActivator.BuildLockKey,
            token: cancellationToken
        );
        if (!current.HasValue || current.Value != runId)
        {
            return ResponseResult.Fail("没有等待确认的发布任务");
        }

        var wait = await fusionCache.TryGetAsync<List<PipelineVersionMatch>>(
            PipelineVersionProbe.WaitCacheKey(runId),
            token: cancellationToken
        );
        if (!wait.HasValue || wait.Value.Count == 0)
        {
            return ResponseResult.Fail("没有等待确认的发布任务");
        }

        await fusionCache.SetAsync(
            PipelineVersionProbe.DecisionCacheKey(runId),
            decision,
            options => options.SetDuration(TimeSpan.FromMinutes(5)),
            token: cancellationToken
        );
        return ResponseResult.Ok();
    }

    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task<ResponseResult> Run(BuildOption option, CancellationToken cancellationToken)
    {
        var result = new ResponseResult<object>();
        if (!HangfireDashboardPermission.HasPermission(User, Permissions.System))
        {
            return result.WithFail("没有权限访问");
        }
        var current = await fusionCache.TryGetAsync<string>(
            BuildActivator.BuildLockKey,
            token: cancellationToken
        );
        if (current.HasValue && !string.IsNullOrWhiteSpace(current.Value))
        {
            return result.WithOk(new { runId = current.Value, alreadyRunning = true });
        }

        Version? version = null;
        if (!string.IsNullOrWhiteSpace(option.Tag) && !Version.TryParse(option.Tag, out version))
        {
            return result.WithFail("版本号不是预期的");
        }
        option.Tag = version?.ToString();

        var userInfo = await mediator.Send(
            new GetUserInfoRequest { Account = User.NameIdentifier },
            cancellationToken
        );
        var runId = ObjectId.GenerateNewId().ToString();
        BackgroundJob.Enqueue<BuildActivator>(x =>
            x.RunBuildAsync(option, runId, userInfo, CancellationToken.None)
        );
        return result.WithOk(new { runId, alreadyRunning = false });
    }

    /// <summary>
    /// 获取最近的 CI/CD 历史记录
    /// </summary>
    [HttpGet]
    public async Task<ResponseResult<List<PipelineHistoryLatestResponse>>> History(
        CancellationToken cancellationToken
    )
    {
        if (!HangfireDashboardPermission.HasPermission(User, Permissions.System))
        {
            return ResponseResult<List<PipelineHistoryLatestResponse>>.Fail("没有权限访问");
        }
        var list = await mediator.Send(new GetPipelineHistoryLatestRequest(), cancellationToken);
        return ResponseResult<List<PipelineHistoryLatestResponse>>.Ok(list);
    }

    /// <summary>
    /// 获取 CI/CD 历史记录详情
    /// </summary>
    [HttpGet]
    public async Task<ResponseResult<PipelineHistoryResponse?>> HistoryDetail(
        [FromQuery] GetPipelineHistoryDetailRequest request,
        CancellationToken cancellationToken
    )
    {
        if (!HangfireDashboardPermission.HasPermission(User, Permissions.System))
        {
            return ResponseResult<PipelineHistoryResponse?>.Fail("没有权限访问");
        }

        var detail = await mediator.Send(request, cancellationToken);
        if (detail == null)
        {
            return ResponseResult<PipelineHistoryResponse?>.Fail("记录不存在");
        }

        return ResponseResult<PipelineHistoryResponse?>.Ok(detail);
    }
}