using System.ComponentModel.DataAnnotations;
using Jiaowu.Api.Contracts;
using Jiaowu.Api.Domain.Academic;
using Jiaowu.Api.Domain.Identity;
using Jiaowu.Api.Domain.System;
using Jiaowu.Api.Infrastructure.Operations;
using Jiaowu.Api.Infrastructure.Observability;
using Jiaowu.Api.Infrastructure.Persistence;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;

namespace Jiaowu.Api.Controllers;

[ApiController]
[Authorize(Roles = SystemRoles.SuperAdmin)]
[Route("api/operations")]
public sealed class OperationsController(
    AppDbContext db,
    OperationalHealthService healthService,
    DatabaseBackupService backupService,
    PerformanceReportService performanceReportService,
    OperationsOptions options) : ControllerBase
{
    [HttpGet("performance")]
    public async Task<ActionResult<PerformanceReport>> GetPerformance(
        [FromQuery] string? range = "1h",
        CancellationToken cancellationToken = default)
    {
        try
        {
            return Ok(await performanceReportService.GetAsync(
                range,
                cancellationToken));
        }
        catch (ArgumentOutOfRangeException)
        {
            return ValidationProblem(
                "性能报表范围仅支持 15m、1h、24h 或 7d。");
        }
    }

    [HttpGet("summary")]
    public async Task<ActionResult<OperationsSummary>> GetSummary(
        CancellationToken cancellationToken)
    {
        var since = DateTime.UtcNow.AddHours(-24);
        var health = await healthService.CheckAsync(cancellationToken);
        var backups = await backupService.ListAsync(cancellationToken);
        var auditCount = await db.AuditLogs.AsNoTracking()
            .CountAsync(x => x.CreatedAt >= since, cancellationToken);
        var serverErrorCount = await db.AuditLogs.AsNoTracking()
            .CountAsync(
                x => x.CreatedAt >= since && x.StatusCode >= 500,
                cancellationToken);
        var failedJobCount = await CountFailedJobsAsync(
            DateTime.UtcNow.AddDays(-7),
            cancellationToken);
        var alerts = await BuildAlertsAsync(
            health,
            backups,
            serverErrorCount,
            failedJobCount,
            cancellationToken);
        return Ok(new OperationsSummary(
            DateTime.UtcNow,
            health,
            new OperationsCounters(
                auditCount,
                serverErrorCount,
                failedJobCount,
                alerts.Count(x => x.Severity == "critical")),
            alerts,
            backups.FirstOrDefault()));
    }

    [HttpGet("health")]
    public async Task<ActionResult<OperationalHealthSnapshot>> GetHealth(
        CancellationToken cancellationToken) =>
        Ok(await healthService.CheckAsync(cancellationToken));

    [HttpGet("audit-logs")]
    public async Task<ActionResult<PagedResult<AuditLogItem>>> GetAuditLogs(
        [FromQuery] int page = 1,
        [FromQuery] int pageSize = 20,
        [FromQuery] string? method = null,
        [FromQuery] int? statusCode = null,
        [FromQuery] string? userName = null,
        [FromQuery] string? path = null,
        [FromQuery] DateTime? from = null,
        [FromQuery] DateTime? to = null,
        CancellationToken cancellationToken = default)
    {
        var pagingError = ValidatePaging(page, pageSize);
        if (pagingError is not null) return pagingError;
        var rangeError = ValidateRange(from, to);
        if (rangeError is not null) return rangeError;

        var query = db.AuditLogs.AsNoTracking().AsQueryable();
        if (!string.IsNullOrWhiteSpace(method))
        {
            var normalizedMethod = method.Trim().ToUpperInvariant();
            query = query.Where(x => x.Method == normalizedMethod);
        }
        if (statusCode.HasValue)
            query = query.Where(x => x.StatusCode == statusCode.Value);
        if (!string.IsNullOrWhiteSpace(userName))
        {
            var normalizedUser = userName.Trim();
            query = query.Where(x =>
                x.UserName != null && x.UserName.Contains(normalizedUser));
        }
        if (!string.IsNullOrWhiteSpace(path))
        {
            var normalizedPath = path.Trim();
            query = query.Where(x => x.Path.Contains(normalizedPath));
        }
        query = query.Where(x =>
            x.CreatedAt >= (from ?? DateTime.UtcNow.AddDays(-1)));
        if (to.HasValue)
            query = query.Where(x => x.CreatedAt <= to.Value);

        var total = await query.CountAsync(cancellationToken);
        var items = await query
            .OrderByDescending(x => x.CreatedAt)
            .Skip((page - 1) * pageSize)
            .Take(pageSize)
            .Select(x => new AuditLogItem(
                x.Id,
                x.UserName,
                x.Method,
                x.Path,
                x.StatusCode,
                x.IpAddress,
                x.CreatedAt))
            .ToListAsync(cancellationToken);
        return Ok(new PagedResult<AuditLogItem>(items, total, page, pageSize));
    }

    [HttpGet("failed-jobs")]
    public async Task<ActionResult<PagedResult<FailedBackgroundJobItem>>>
        GetFailedJobs(
            [FromQuery] int page = 1,
            [FromQuery] int pageSize = 20,
            [FromQuery] string? kind = null,
            [FromQuery] DateTime? from = null,
            [FromQuery] DateTime? to = null,
            CancellationToken cancellationToken = default)
    {
        var pagingError = ValidatePaging(page, pageSize);
        if (pagingError is not null) return pagingError;
        var rangeError = ValidateRange(from, to);
        if (rangeError is not null) return rangeError;

        var normalizedKind = NormalizeJobKind(kind);
        if (kind is not null && normalizedKind is null)
            return ValidationProblem("后台任务类型无效。");

        var effectiveFrom = from ?? DateTime.UtcNow.AddDays(-30);
        var take = checked(page * pageSize);
        var rows = new List<FailedBackgroundJobItem>();
        var total = 0;

        if (normalizedKind is null or "AutomaticSchedule")
        {
            var query = db.AutomaticScheduleJobs.AsNoTracking()
                .Where(x =>
                    x.Status == AutomaticScheduleJobStatus.Failed &&
                    x.CreatedAt >= effectiveFrom);
            if (to.HasValue) query = query.Where(x => x.CreatedAt <= to.Value);
            total += await query.CountAsync(cancellationToken);
            rows.AddRange(await query
                .OrderByDescending(x => x.CompletedAt ?? x.UpdatedAt)
                .Take(take)
                .Select(x => new FailedBackgroundJobItem(
                    x.Id,
                    "AutomaticSchedule",
                    "自动排课",
                    x.SchedulePlan == null ? "排课方案" : x.SchedulePlan.Name,
                    x.ErrorMessage ?? "任务失败但未记录错误详情。",
                    x.CreatedAt,
                    x.StartedAt,
                    x.CompletedAt,
                    0))
                .ToListAsync(cancellationToken));
        }

        if (normalizedKind is null or "SchedulePublish")
        {
            var query = db.SchedulePublishJobs.AsNoTracking()
                .Where(x =>
                    x.Status == SchedulePublishJobStatus.Failed &&
                    x.CreatedAt >= effectiveFrom);
            if (to.HasValue) query = query.Where(x => x.CreatedAt <= to.Value);
            total += await query.CountAsync(cancellationToken);
            rows.AddRange(await query
                .OrderByDescending(x => x.CompletedAt ?? x.UpdatedAt)
                .Take(take)
                .Select(x => new FailedBackgroundJobItem(
                    x.Id,
                    "SchedulePublish",
                    "课表发布",
                    x.SchedulePlan == null ? "排课方案" : x.SchedulePlan.Name,
                    x.ErrorMessage ?? "任务失败但未记录错误详情。",
                    x.CreatedAt,
                    x.StartedAt,
                    x.CompletedAt,
                    0))
                .ToListAsync(cancellationToken));
        }

        if (normalizedKind is null or "MakeupExamAuto")
        {
            var query = db.MakeupExamAutoJobs.AsNoTracking()
                .Where(x =>
                    x.Status == MakeupExamAutoJobStatus.Failed &&
                    x.CreatedAt >= effectiveFrom);
            if (to.HasValue) query = query.Where(x => x.CreatedAt <= to.Value);
            total += await query.CountAsync(cancellationToken);
            rows.AddRange(await query
                .OrderByDescending(x => x.CompletedAt ?? x.UpdatedAt)
                .Take(take)
                .Select(x => new FailedBackgroundJobItem(
                    x.Id,
                    "MakeupExamAuto",
                    "补考自动安排",
                    x.MakeupExamPlan == null ? "补考计划" : x.MakeupExamPlan.Name,
                    x.ErrorMessage ?? "任务失败但未记录错误详情。",
                    x.CreatedAt,
                    x.StartedAt,
                    x.CompletedAt,
                    0))
                .ToListAsync(cancellationToken));
        }

        if (normalizedKind is null or "ExamArrangement")
        {
            var query = db.ExamArrangementJobs.AsNoTracking()
                .Where(x =>
                    x.Status == ExamArrangementJobStatus.Failed &&
                    x.CreatedAt >= effectiveFrom);
            if (to.HasValue) query = query.Where(x => x.CreatedAt <= to.Value);
            total += await query.CountAsync(cancellationToken);
            rows.AddRange(await query
                .OrderByDescending(x => x.CompletedAt ?? x.UpdatedAt)
                .Take(take)
                .Select(x => new FailedBackgroundJobItem(
                    x.Id,
                    "ExamArrangement",
                    x.Kind == ExamArrangementKind.FormalExam
                        ? "正式考试编排"
                        : "补考编排",
                    x.Kind == ExamArrangementKind.FormalExam
                        ? "正式考试计划"
                        : "补考计划",
                    x.ErrorMessage ?? "任务失败但未记录错误详情。",
                    x.CreatedAt,
                    x.StartedAt,
                    x.CompletedAt,
                    0))
                .ToListAsync(cancellationToken));
        }

        if (normalizedKind is null or "ExamPublish")
        {
            var query = db.ExamPublishJobs.AsNoTracking()
                .Where(x =>
                    x.Status == ExamPublishJobStatus.Failed &&
                    x.CreatedAt >= effectiveFrom);
            if (to.HasValue) query = query.Where(x => x.CreatedAt <= to.Value);
            total += await query.CountAsync(cancellationToken);
            rows.AddRange(await query
                .OrderByDescending(x => x.CompletedAt ?? x.UpdatedAt)
                .Take(take)
                .Select(x => new FailedBackgroundJobItem(
                    x.Id,
                    "ExamPublish",
                    x.Kind == ExamPublishJobKind.FormalExam
                        ? "正式考试发布"
                        : "补考发布",
                    x.Kind == ExamPublishJobKind.FormalExam
                        ? "正式考试计划"
                        : "补考计划",
                    x.ErrorMessage ?? "任务失败但未记录错误详情。",
                    x.CreatedAt,
                    x.StartedAt,
                    x.CompletedAt,
                    0))
                .ToListAsync(cancellationToken));
        }

        var pageItems = rows
            .OrderByDescending(x => x.CompletedAt ?? x.CreatedAt)
            .Skip((page - 1) * pageSize)
            .Take(pageSize)
            .ToArray();
        if (pageItems.Length > 0)
        {
            var ids = pageItems.Select(x => x.Id).ToArray();
            var attempts = await db.BackgroundJobOutboxMessages.AsNoTracking()
                .Where(x => ids.Contains(x.JobId))
                .Select(x => new { x.JobId, x.ProcessingAttempts })
                .ToDictionaryAsync(x => x.JobId, x => x.ProcessingAttempts,
                    cancellationToken);
            pageItems = pageItems
                .Select(x => x with
                {
                    ProcessingAttempts = attempts.GetValueOrDefault(x.Id)
                })
                .ToArray();
        }

        return Ok(new PagedResult<FailedBackgroundJobItem>(
            pageItems,
            total,
            page,
            pageSize));
    }

    [HttpGet("backups")]
    public async Task<ActionResult<IReadOnlyCollection<BackupArtifact>>> GetBackups(
        CancellationToken cancellationToken) =>
        Ok(await backupService.ListAsync(cancellationToken));

    [HttpPost("backups")]
    public async Task<ActionResult<BackupArtifact>> CreateBackup(
        CreateBackupRequest request,
        CancellationToken cancellationToken)
    {
        try
        {
            var artifact = await backupService.CreateAsync(
                request.Note,
                cancellationToken);
            return CreatedAtAction(
                nameof(GetBackups),
                new { id = artifact.Id },
                artifact);
        }
        catch (Exception exception) when (exception is not OperationCanceledException)
        {
            return Problem(
                title: "数据库备份失败",
                detail: SafeMessage(exception),
                statusCode: StatusCodes.Status503ServiceUnavailable);
        }
    }

    [HttpPost("backups/{backupId}/restore-drill")]
    public async Task<ActionResult<RestoreDrillResult>> RunRestoreDrill(
        string backupId,
        RestoreDrillRequest request,
        CancellationToken cancellationToken)
    {
        if (!request.Confirmation.Equals(
                "RESTORE_DRILL",
                StringComparison.Ordinal))
        {
            return ValidationProblem(
                "恢复演练必须明确确认，且不会覆盖当前业务数据库。");
        }

        try
        {
            return Ok(await backupService.RunRestoreDrillAsync(
                backupId,
                cancellationToken));
        }
        catch (FileNotFoundException)
        {
            return NotFound(new ProblemDetails
            {
                Title = "备份不存在",
                Detail = "指定备份不存在或其文件已被移除。",
                Status = StatusCodes.Status404NotFound
            });
        }
    }

    private async Task<IReadOnlyCollection<OperationalAlert>> BuildAlertsAsync(
        OperationalHealthSnapshot health,
        IReadOnlyCollection<BackupArtifact> backups,
        int serverErrorCount,
        int failedJobCount,
        CancellationToken cancellationToken)
    {
        var alerts = health.Components
            .Where(x => x.Status != "healthy")
            .Select(x => new OperationalAlert(
                $"health-{x.Key}",
                x.Status == "unhealthy" ? "critical" : "warning",
                "health",
                $"{x.Label}状态异常",
                x.Detail,
                health.CheckedAt))
            .ToList();

        if (serverErrorCount > 0)
        {
            var latest = await db.AuditLogs.AsNoTracking()
                .Where(x =>
                    x.CreatedAt >= DateTime.UtcNow.AddHours(-24) &&
                    x.StatusCode >= 500)
                .OrderByDescending(x => x.CreatedAt)
                .Select(x => new { x.Path, x.StatusCode, x.CreatedAt })
                .FirstOrDefaultAsync(cancellationToken);
            alerts.Add(new OperationalAlert(
                "http-5xx",
                "critical",
                "audit",
                $"过去 24 小时发生 {serverErrorCount} 次服务端错误",
                latest is null
                    ? "请检查服务日志定位异常。"
                    : $"最近一次为 {latest.StatusCode} {latest.Path}。",
                latest?.CreatedAt ?? DateTime.UtcNow));
        }

        if (failedJobCount > 0)
        {
            alerts.Add(new OperationalAlert(
                "failed-jobs",
                "critical",
                "jobs",
                $"最近 7 天有 {failedJobCount} 个后台任务失败",
                "任务已停止或达到重试上限，请在失败任务中查看错误详情。",
                DateTime.UtcNow));
        }

        var retryingFailures = await db.BackgroundJobOutboxMessages.AsNoTracking()
            .CountAsync(
                x => x.State != BackgroundJobOutboxState.Completed &&
                     x.LastError != null,
                cancellationToken);
        if (retryingFailures > 0)
        {
            alerts.Add(new OperationalAlert(
                "retrying-jobs",
                "warning",
                "jobs",
                $"{retryingFailures} 个后台任务正在错误重试",
                "任务队列仍会自动重试；若持续出现，请检查依赖服务与任务参数。",
                DateTime.UtcNow));
        }

        var latestBackup = backups.FirstOrDefault();
        if (latestBackup is null)
        {
            alerts.Add(new OperationalAlert(
                "backup-missing",
                "critical",
                "backup",
                "尚无可验证的数据库备份",
                "立即创建首个备份，并在创建后执行一次隔离恢复演练。",
                DateTime.UtcNow));
        }
        else
        {
            var ageHours = (DateTime.UtcNow - latestBackup.CreatedAt).TotalHours;
            if (ageHours > options.BackupWarningHours)
            {
                alerts.Add(new OperationalAlert(
                    "backup-stale",
                    "warning",
                    "backup",
                    $"最近备份已超过 {options.BackupWarningHours} 小时",
                    $"最近备份创建于 {latestBackup.CreatedAt:u}。",
                    latestBackup.CreatedAt));
            }
            if (latestBackup.LastDrillSucceeded == false)
            {
                alerts.Add(new OperationalAlert(
                    "restore-drill-failed",
                    "critical",
                    "backup",
                    "最近一次恢复演练失败",
                    latestBackup.LastDrillDetail ?? "请重新运行演练并检查数据库工具日志。",
                    latestBackup.LastDrillAt ?? latestBackup.CreatedAt));
            }
            else if (!latestBackup.LastDrillAt.HasValue)
            {
                alerts.Add(new OperationalAlert(
                    "restore-drill-missing",
                    "warning",
                    "backup",
                    "最近备份尚未完成恢复演练",
                    "恢复演练只写入隔离数据库，不会覆盖当前业务数据。",
                    latestBackup.CreatedAt));
            }
        }

        return alerts
            .OrderBy(x => x.Severity == "critical" ? 0 : 1)
            .ThenByDescending(x => x.OccurredAt)
            .ToArray();
    }

    private async Task<int> CountFailedJobsAsync(
        DateTime from,
        CancellationToken cancellationToken) =>
        await db.AutomaticScheduleJobs.AsNoTracking()
            .CountAsync(
                x => x.Status == AutomaticScheduleJobStatus.Failed &&
                     x.CreatedAt >= from,
                cancellationToken) +
        await db.SchedulePublishJobs.AsNoTracking()
            .CountAsync(
                x => x.Status == SchedulePublishJobStatus.Failed &&
                     x.CreatedAt >= from,
                cancellationToken) +
        await db.MakeupExamAutoJobs.AsNoTracking()
            .CountAsync(
                x => x.Status == MakeupExamAutoJobStatus.Failed &&
                     x.CreatedAt >= from,
                cancellationToken) +
        await db.ExamArrangementJobs.AsNoTracking()
            .CountAsync(
                x => x.Status == ExamArrangementJobStatus.Failed &&
                     x.CreatedAt >= from,
                cancellationToken) +
        await db.ExamPublishJobs.AsNoTracking()
            .CountAsync(
                x => x.Status == ExamPublishJobStatus.Failed &&
                     x.CreatedAt >= from,
                cancellationToken);

    private ActionResult? ValidatePaging(int page, int pageSize)
    {
        if (page is < 1 or > 100000 || pageSize is < 1 or > 100)
        {
            return ValidationProblem(
                "页码必须在 1 到 100000 之间，每页数量必须在 1 到 100 之间。");
        }
        return null;
    }

    private ActionResult? ValidateRange(DateTime? from, DateTime? to)
    {
        if (from.HasValue && to.HasValue && from.Value > to.Value)
            return ValidationProblem("开始时间不能晚于结束时间。");
        return null;
    }

    private static string? NormalizeJobKind(string? kind)
    {
        if (string.IsNullOrWhiteSpace(kind)) return null;
        return kind.Trim() switch
        {
            "AutomaticSchedule" => "AutomaticSchedule",
            "SchedulePublish" => "SchedulePublish",
            "MakeupExamAuto" => "MakeupExamAuto",
            "ExamArrangement" => "ExamArrangement",
            _ => null
        };
    }

    private static string SafeMessage(Exception exception)
    {
        var message = exception.GetBaseException().Message;
        return message.Length <= 500 ? message : message[..500];
    }
}

public sealed record AuditLogItem(
    Guid Id,
    string? UserName,
    string Method,
    string Path,
    int StatusCode,
    string? IpAddress,
    DateTime CreatedAt);

public sealed record FailedBackgroundJobItem(
    Guid Id,
    string Kind,
    string KindLabel,
    string Context,
    string ErrorMessage,
    DateTime CreatedAt,
    DateTime? StartedAt,
    DateTime? CompletedAt,
    int ProcessingAttempts);

public sealed record OperationalAlert(
    string Id,
    string Severity,
    string Source,
    string Title,
    string Detail,
    DateTime OccurredAt);

public sealed record OperationsCounters(
    int AuditEvents24Hours,
    int ServerErrors24Hours,
    int FailedJobs7Days,
    int CriticalAlerts);

public sealed record OperationsSummary(
    DateTime GeneratedAt,
    OperationalHealthSnapshot Health,
    OperationsCounters Counters,
    IReadOnlyCollection<OperationalAlert> Alerts,
    BackupArtifact? LatestBackup);

public sealed record CreateBackupRequest([MaxLength(200)] string? Note);

public sealed record RestoreDrillRequest([Required] string Confirmation);