YD_Event.Admin/YD_Event.Application/OrderBook/OrderBookService.cs

using System.Drawing;
using YD_Event.Application.Auth;
using YD_Event.Application.Common.Excel;
using YD_Event.Application.OrderBook.Dtos;
using YD_Event.Core.Domain.Export;

namespace YD_Event.Application.OrderBook;

/// <summary>
/// 秩序册导入接口（下载模板 / 同步解析 / 确认落库）
/// </summary>
[ApiDescriptionSettings("打分系统", Name = "order-book")]
[Route("api/orderbook")]
[Authorize]
public class OrderBookService : IDynamicApiController, ITransient
{
    private const string EntrySheetName = "出场秩序";
    private const string RefereeSheetName = "裁判名单";
    private const string DefaultGroupName = "公开组";
    private static readonly TimeSpan BatchTtl = TimeSpan.FromMinutes(30);

    private readonly ISqlSugarRepository<EventInfo> _eventRepository;
    private readonly ISqlSugarRepository<Core.Entities.Project> _projectRepository;
    private readonly ISqlSugarRepository<EventProject> _eventProjectRepository;
    private readonly ISqlSugarRepository<EventProjectGroup> _groupRepository;
    private readonly ISqlSugarRepository<EventVenue> _venueRepository;
    private readonly ISqlSugarRepository<EventSession> _sessionRepository;
    private readonly ISqlSugarRepository<EventSessionEntry> _entryRepository;
    private readonly ISqlSugarRepository<Core.Entities.ScoreRule> _scoreRuleRepository;
    private readonly ISqlSugarRepository<EventJudgeAssignment> _judgeAssignmentRepository;
    private readonly ISqlSugarRepository<Core.Entities.Referee> _refereeRepository;
    private readonly ISqlSugarRepository<EventReferee> _eventRefereeRepository;
    private readonly ISqlSugarRepository<Core.Entities.AppUser> _appUserRepository;
    private readonly IEasyCachingProvider _cache;
    private readonly IIdGenerator _idGenerator;
    private readonly AuthManager _authManager;

    public OrderBookService(
        ISqlSugarRepository<EventInfo> eventRepository,
        ISqlSugarRepository<Core.Entities.Project> projectRepository,
        ISqlSugarRepository<EventProject> eventProjectRepository,
        ISqlSugarRepository<EventProjectGroup> groupRepository,
        ISqlSugarRepository<EventVenue> venueRepository,
        ISqlSugarRepository<EventSession> sessionRepository,
        ISqlSugarRepository<EventSessionEntry> entryRepository,
        ISqlSugarRepository<Core.Entities.ScoreRule> scoreRuleRepository,
        ISqlSugarRepository<EventJudgeAssignment> judgeAssignmentRepository,
        ISqlSugarRepository<Core.Entities.Referee> refereeRepository,
        ISqlSugarRepository<EventReferee> eventRefereeRepository,
        ISqlSugarRepository<Core.Entities.AppUser> appUserRepository,
        IEasyCachingProvider cache,
        IIdGenerator idGenerator,
        AuthManager authManager)
    {
        _eventRepository = eventRepository;
        _projectRepository = projectRepository;
        _eventProjectRepository = eventProjectRepository;
        _groupRepository = groupRepository;
        _venueRepository = venueRepository;
        _sessionRepository = sessionRepository;
        _entryRepository = entryRepository;
        _scoreRuleRepository = scoreRuleRepository;
        _judgeAssignmentRepository = judgeAssignmentRepository;
        _refereeRepository = refereeRepository;
        _eventRefereeRepository = eventRefereeRepository;
        _appUserRepository = appUserRepository;
        _cache = cache;
        _idGenerator = idGenerator;
        _authManager = authManager;
    }

    #region 下载模板

    /// <summary>
    /// 下载秩序册导入模板
    /// </summary>
    /// <param name="projectMode"></param>
    /// <returns></returns>
    [DisplayName("下载秩序册导入模板")]
    [HttpGet("template")]
    public async Task<IActionResult> DownloadTemplate([FromQuery] string? projectMode)
    {
        var bytes = await new OrderBookTemplateExporter().ExportAsync();
        return new FileContentResult(bytes, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet")
        {
            FileDownloadName = "秩序册导入模板.xlsx"
        };
    }

    #endregion

    #region 同步解析

    /// <summary>
    /// 上传并同步解析秩序册（不产生业务数据，结果缓存待确认）
    /// </summary>
    /// <param name="eventId"></param>
    /// <param name="importMode"></param>
    /// <param name="file"></param>
    /// <returns></returns>
    [DisplayName("解析秩序册")]
    [HttpPost("import")]
    public async Task<OrderBookImportOutput> Import(long? eventId, string? importMode, IFormFile file)
    {
        if (file == null || file.Length == 0)
            throw Oops.Bah("请上传秩序册文件");

        var ext = Path.GetExtension(file.FileName)?.ToLowerInvariant();
        if (ext is not ".xlsx" and not ".xls")
            throw Oops.Bah("仅支持 .xls/.xlsx 格式的秩序册文件");

        if (eventId.HasValue && eventId.Value > 0 &&
            !await _eventRepository.IsAnyAsync(e => e.Id == eventId.Value && !e.DeleteMark))
            throw Oops.Bah("赛事不存在或已删除");

        var mode = string.IsNullOrWhiteSpace(importMode) ? "overwrite" : importMode.Trim().ToLowerInvariant();
        if (mode != "append" && mode != "overwrite")
            throw Oops.Bah("导入模式只能为 append（追加）或 overwrite（覆盖）");

        List<OrderBookEntryRow> entryRows;
        List<OrderBookRefereeRow> refereeRows;
        try
        {
            using var stream = file.OpenReadStream();
            // NPOI 统一读取，WorkbookFactory 按文件头自动识别 .xls/.xlsx
            using var workbook = NpoiExcelReader.CreateWorkbook(stream);
            entryRows = NpoiExcelReader.ReadSheet<OrderBookEntryRow>(workbook, EntrySheetName);
            refereeRows = NpoiExcelReader.ReadSheet<OrderBookRefereeRow>(workbook, RefereeSheetName);
        }
        catch (Exception ex)
        {
            throw Oops.Bah($"秩序册解析失败，请确认包含「{EntrySheetName}」「{RefereeSheetName}」两个工作表：{ex.Message}");
        }

        var issues = new List<OrderBookParseIssue>();
        var draftEntries = ParseEntryRows(entryRows, issues);
        var draftReferees = ParseRefereeRows(refereeRows, issues);
        await ValidateScoreRulesAsync(draftEntries, issues);
        await ValidateRefereesAsync(draftReferees, issues);

        var errorCount = issues.Count(i => i.Level == "error");
        var warningCount = issues.Count(i => i.Level == "warning");

        var draft = new OrderBookDraft
        {
            BatchId = _idGenerator.NextId(),
            CreatedUserId = _authManager.UserId,
            HasErrors = errorCount > 0,
            EventId = eventId,
            ImportMode = mode,
            CreatedAt = DateTime.Now,
            Entries = draftEntries,
            Referees = draftReferees
        };

        var preview = BuildPreview(draft);

        // 重传覆盖：同一赛事存在旧的未确认批次时移除，始终以最新一次上传为准
        if (eventId.HasValue)
        {
            var currentKey = CurrentKey(eventId.Value, _authManager.UserId);
            var oldBatch = await _cache.GetAsync<long>(currentKey);
            if (oldBatch.HasValue)
                await _cache.RemoveAsync(BatchKey(oldBatch.Value));
            await _cache.SetAsync(currentKey, draft.BatchId, BatchTtl);
        }
        await _cache.SetAsync(BatchKey(draft.BatchId), draft, BatchTtl);

        return new OrderBookImportOutput
        {
            BatchId = draft.BatchId,
            Status = errorCount > 0 ? 20 : 10,
            TotalRows = entryRows.Count + refereeRows.Count,
            ValidRows = draft.Entries.Count + draft.Referees.Count,
            ErrorCount = errorCount,
            WarningCount = warningCount,
            Preview = preview,
            Errors = issues
        };
    }

    private List<OrderBookDraftEntry> ParseEntryRows(List<OrderBookEntryRow> rows, List<OrderBookParseIssue> issues)
    {
        var result = new List<OrderBookDraftEntry>();
        for (var i = 0; i < rows.Count; i++)
        {
            var row = rows[i];
            var rowNo = i + 3; // 模板第 1 行为说明标题，第 2 行为表头

            // 整行为空直接跳过
            if (IsAllBlank(row.ProjectName, row.ScoreRuleName, row.GroupName, row.ParticipantName,
                    row.TeamName, row.UnitName, row.SessionName, row.VenueName))
                continue;

            var project = Trim(row.ProjectName);
            var scoreRule = Trim(row.ScoreRuleName);
            var group = Trim(row.GroupName);
            var participant = Trim(row.ParticipantName);
            var session = Trim(row.SessionName);
            var venue = Trim(row.VenueName);

            if (string.IsNullOrWhiteSpace(project))
                issues.Add(Issue(rowNo, "项目名称", "项目名称为必填项"));
            if (string.IsNullOrWhiteSpace(scoreRule))
                issues.Add(Issue(rowNo, "计分规则", "计分规则为必填项"));
            if (string.IsNullOrWhiteSpace(group))
                issues.Add(Issue(rowNo, "组别名称", "组别名称为必填项"));
            if (string.IsNullOrWhiteSpace(participant))
                issues.Add(Issue(rowNo, "姓名", "姓名为必填项"));
            if (string.IsNullOrWhiteSpace(session))
                issues.Add(Issue(rowNo, "场次", "场次为必填项"));
            if (string.IsNullOrWhiteSpace(venue))
                issues.Add(Issue(rowNo, "场地", "场地为必填项"));

            result.Add(new OrderBookDraftEntry
            {
                Row = rowNo,
                VenueName = venue,
                ProjectName = project,
                ScoreRuleName = scoreRule,
                GroupName = group,
                SessionName = session,
                ParticipantName = participant,
                TeamName = Trim(row.TeamName),
                UnitName = Trim(row.UnitName)
            });
        }
        return result;
    }

    private List<OrderBookDraftReferee> ParseRefereeRows(List<OrderBookRefereeRow> rows, List<OrderBookParseIssue> issues)
    {
        var result = new List<OrderBookDraftReferee>();
        var seenMobiles = new HashSet<string>();
        for (var i = 0; i < rows.Count; i++)
        {
            var row = rows[i];
            var rowNo = i + 3;

            if (IsAllBlank(row.Name, row.Mobile))
                continue;

            var name = Trim(row.Name);
            var mobile = Trim(row.Mobile);

            if (string.IsNullOrWhiteSpace(name))
                issues.Add(Issue(rowNo, "姓名", "裁判姓名为必填项"));
            if (string.IsNullOrWhiteSpace(mobile))
                issues.Add(Issue(rowNo, "手机号", "裁判手机号为必填项"));
            else if (!Regex.IsMatch(mobile, @"^1[3-9]\d{9}$"))
                issues.Add(Issue(rowNo, "手机号", $"裁判手机号「{mobile}」格式不正确"));
            else if (!seenMobiles.Add(mobile))
                issues.Add(Issue(rowNo, "手机号", $"裁判手机号「{mobile}」重复，已自动合并", "warning"));

            if (string.IsNullOrWhiteSpace(name) || string.IsNullOrWhiteSpace(mobile))
                continue;

            // 同手机号只保留第一条
            if (seenMobiles.Contains(mobile) && result.Any(r => r.Mobile == mobile))
                continue;

            result.Add(new OrderBookDraftReferee
            {
                Row = rowNo,
                Name = name!,
                Mobile = mobile!
            });
        }
        return result;
    }

    private static OrderBookPreview BuildPreview(OrderBookDraft draft)
    {
        return new OrderBookPreview
        {
            VenueCount = draft.Entries.Select(e => e.VenueName).Where(v => !string.IsNullOrWhiteSpace(v)).Distinct().Count(),
            SessionCount = draft.Entries
                .Select(e => SessionKey(e.ProjectName, e.GroupName, e.SessionName, e.VenueName))
                .Distinct().Count(),
            EntryCount = draft.Entries.Count,
            RefereeCount = draft.Referees.Select(r => r.Mobile).Distinct().Count()
        };
    }

    private async Task ValidateScoreRulesAsync(
        List<OrderBookDraftEntry> entries, List<OrderBookParseIssue> issues)
    {
        var inconsistentProjects = entries
            .Where(x => !string.IsNullOrWhiteSpace(x.ProjectName) && !string.IsNullOrWhiteSpace(x.ScoreRuleName))
            .GroupBy(x => x.ProjectName)
            .Where(x => x.Select(item => item.ScoreRuleName).Distinct().Count() > 1)
            .SelectMany(x => x)
            .ToList();
        foreach (var entry in inconsistentProjects)
            issues.Add(Issue(entry.Row, "计分规则", $"同一项目【{entry.ProjectName}】只能使用一种计分规则"));

        var ruleNames = entries.Select(x => x.ScoreRuleName)
            .Where(x => !string.IsNullOrWhiteSpace(x)).Distinct().ToList();
        if (ruleNames.Count == 0) return;

        var existingNames = await _scoreRuleRepository.AsQueryable()
            .Where(x => !x.DeleteMark && x.Status == AvailabilityStatus.Enable && ruleNames.Contains(x.RuleName))
            .Select(x => x.RuleName).ToListAsync();
        foreach (var entry in entries.Where(x => !string.IsNullOrWhiteSpace(x.ScoreRuleName)
                                                  && !existingNames.Contains(x.ScoreRuleName)))
            issues.Add(Issue(entry.Row, "计分规则", $"计分规则【{entry.ScoreRuleName}】不存在或已停用"));
    }

    private async Task ValidateRefereesAsync(
        List<OrderBookDraftReferee> referees, List<OrderBookParseIssue> issues)
    {
        var mobiles = referees.Select(x => x.Mobile).Where(x => !string.IsNullOrWhiteSpace(x)).Distinct().ToList();
        if (mobiles.Count == 0) return;

        var registeredMobiles = await _refereeRepository.AsQueryable()
            .Where(x => !x.DeleteMark && x.AuditStatus == AuditStatus.Pass && mobiles.Contains(x.Mobile))
            .Select(x => x.Mobile).ToListAsync();
        foreach (var referee in referees.Where(x => !registeredMobiles.Contains(x.Mobile)))
            issues.Add(Issue(referee.Row, "手机号", $"手机号【{referee.Mobile}】尚未完成裁判注册认证"));
    }

    #endregion

    #region 确认落库

    /// <summary>
    /// 确认导入：按解析结果生成场地、场次、出场及裁判名单（幂等，同一批次只生成一次）
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [UnitOfWork]
    [DisplayName("确认秩序册导入")]
    [HttpPost("confirm")]
    public async Task<OrderBookConfirmOutput> Confirm([FromBody] OrderBookConfirmInput input)
    {
        var cached = await _cache.GetAsync<OrderBookDraft>(BatchKey(input.BatchId));
        if (!cached.HasValue || cached.Value == null)
            throw Oops.Bah("导入批次不存在或已过期，请重新上传秩序册");

        var draft = cached.Value;

        var currentUserId = _authManager.UserId;
        if (draft.CreatedUserId != currentUserId)
            throw Oops.Bah("无权确认其他用户创建的导入批次");
        if (draft.HasErrors)
            throw Oops.Bah("导入文件仍存在校验错误，请修正后重新上传");

        var confirmedCache = await _cache.GetAsync<bool>(ConfirmedKey(input.BatchId));
        if (confirmedCache.HasValue && confirmedCache.Value)
            throw Oops.Bah("该批次已确认，请勿重复提交");

        if (!draft.Entries.Any())
            throw Oops.Bah("秩序册没有可导入的出场数据");
        if (!draft.EventId.HasValue || draft.EventId.Value <= 0)
            throw Oops.Bah("请先创建赛事，再导入秩序册");

        var eventId = draft.EventId.Value;
        var eventInfo = await _eventRepository.GetFirstAsync(e => e.Id == eventId && !e.DeleteMark)
            ?? throw Oops.Bah("赛事不存在或已删除");

        var now = DateTime.Now;

        // 覆盖模式：先软删该赛事既有编排（场地/场次/出场），与编排确认逻辑保持一致
        if (draft.ImportMode == "overwrite")
            await SoftDeleteArrangementAsync(eventId);

        // 1. 准备计分规则、项目、赛事项目及组别映射
        var scoreRuleContext = await GetScoreRuleContextAsync(draft);
        var projectContext = await EnsureProjectsAsync(draft, eventId, scoreRuleContext, currentUserId, now);

        // 2. 准备场地
        var venueContext = await EnsureVenuesAsync(draft, eventId, currentUserId, now);

        // 3. 生成场次
        var sessionContext = await EnsureSessionsAsync(draft, eventId, projectContext, venueContext, currentUserId, now);

        // 4. 生成出场
        var entryCount = await CreateEntriesAsync(draft, projectContext, venueContext, sessionContext, currentUserId, now);

        // 5. 裁判名单 + 可选打分账号
        var refereeCount = await EnsureRefereesAsync(draft, eventId, input, currentUserId, now);

        // 幂等标记 + 清理批次缓存
        await _cache.SetAsync(ConfirmedKey(input.BatchId), true, BatchTtl);
        await _cache.RemoveAsync(BatchKey(input.BatchId));
        if (await _cache.GetAsync<long>(CurrentKey(eventId, currentUserId)) is { HasValue: true } current && current.Value == input.BatchId)
            await _cache.RemoveAsync(CurrentKey(eventId, currentUserId));

        return new OrderBookConfirmOutput
        {
            OrderBookVersion = 1,
            VenueCount = venueContext.Count,
            SessionCount = sessionContext.Count,
            EntryCount = entryCount,
            RefereeCount = refereeCount
        };
    }

    private async Task SoftDeleteArrangementAsync(long eventId)
    {
        var sessionIds = await _sessionRepository.AsQueryable()
            .Where(s => !s.DeleteMark && s.EventId == eventId)
            .Select(s => s.Id).ToListAsync();

        if (sessionIds.Any())
        {
            // 场次被覆盖后，原裁判席位不再对应新场次，必须重新分配。
            await _judgeAssignmentRepository.SoftDeleteAsync(x => sessionIds.Contains(x.SessionId));
            await _entryRepository.SoftDeleteAsync(e => sessionIds.Contains(e.SessionId));
            await _sessionRepository.SoftDeleteAsync(s => sessionIds.Contains(s.Id));
        }
        await _venueRepository.SoftDeleteAsync(v => v.EventId == eventId);
    }

    // 项目（含赛事项目、组别）建档，返回 (项目名,组别名) -> 上下文 的映射
    private async Task<Dictionary<string, OrderBookProjectContext>> EnsureProjectsAsync(
        OrderBookDraft draft, long eventId, Dictionary<string, Core.Entities.ScoreRule> scoreRuleContext,
        long userId, DateTime now)
    {
        var projectNames = draft.Entries.Select(e => e.ProjectName).Where(n => !string.IsNullOrWhiteSpace(n)).Distinct().ToList();
        var result = new Dictionary<string, OrderBookProjectContext>();

        var existProjects = await _projectRepository.AsQueryable()
            .Where(p => !p.DeleteMark && projectNames.Contains(p.Name)).ToListAsync();
        var existEventProjects = await _eventProjectRepository.AsQueryable()
            .Where(ep => !ep.DeleteMark && ep.EventId == eventId).ToListAsync();
        var existGroups = await _groupRepository.AsQueryable()
            .Where(g => !g.DeleteMark && g.EventId == eventId).ToListAsync();

        var maxSort = existProjects.Count == 0 ? 0 : existProjects.Max(p => p.SortIndex);

        foreach (var projectName in projectNames)
        {
            var ruleName = draft.Entries.First(x => x.ProjectName == projectName).ScoreRuleName;
            var scoreRule = scoreRuleContext[ruleName];
            var project = existProjects.FirstOrDefault(p => p.Name == projectName);
            if (project == null)
            {
                project = new Core.Entities.Project
                {
                    Id = _idGenerator.NextId(),
                    Name = projectName,
                    ProjectType = 0,
                    ScoreRuleId = scoreRule.Id,
                    SortIndex = ++maxSort,
                    Status = AvailabilityStatus.Enable,
                    CreatedUserId = userId,
                    CreatedTime = now
                };
                await _projectRepository.InsertAsync(project);
                existProjects.Add(project);
            }

            var eventProject = existEventProjects.FirstOrDefault(ep => ep.ProjectId == project.Id);
            if (eventProject == null)
            {
                eventProject = new EventProject
                {
                    Id = _idGenerator.NextId(),
                    EventId = eventId,
                    ProjectId = project.Id,
                    GenderType = Gender.Unknown,
                    CreatedUserId = userId,
                    CreatedTime = now
                };
                await _eventProjectRepository.InsertAsync(eventProject);
                existEventProjects.Add(eventProject);
            }

            var groupNames = draft.Entries.Where(e => e.ProjectName == projectName).Select(e => e.GroupName).Distinct().ToList();
            var groupMap = new Dictionary<string, long?>();
            foreach (var groupName in groupNames)
            {
                if (groupName == DefaultGroupName)
                {
                    groupMap[groupName] = null;
                    continue;
                }

                var group = existGroups.FirstOrDefault(g => g.EventProjectId == eventProject.Id && g.GroupName == groupName);
                if (group == null)
                {
                    group = new EventProjectGroup
                    {
                        Id = _idGenerator.NextId(),
                        EventId = eventId,
                        EventProjectId = eventProject.Id,
                        ProjectId = project.Id,
                        ProjectGroupId = 0,
                        GroupName = groupName,
                        BirthDateStart = new DateTime(1900, 1, 1),
                        BirthDateEnd = now.AddYears(1),
                        Gender = Gender.Unknown,
                        CreatedUserId = userId,
                        CreatedTime = now
                    };
                    await _groupRepository.InsertAsync(group);
                    existGroups.Add(group);
                }
                groupMap[groupName] = group.Id;
            }

            result[projectName] = new OrderBookProjectContext
            {
                Project = project,
                EventProjectId = eventProject.Id,
                ScoreRuleId = scoreRule.Id,
                GroupMap = groupMap
            };
        }

        return result;
    }

    private async Task<Dictionary<string, Core.Entities.ScoreRule>> GetScoreRuleContextAsync(OrderBookDraft draft)
    {
        var names = draft.Entries.Select(x => x.ScoreRuleName).Distinct().ToList();
        var rules = await _scoreRuleRepository.AsQueryable()
            .Where(x => !x.DeleteMark && x.Status == AvailabilityStatus.Enable && names.Contains(x.RuleName))
            .ToListAsync();
        var result = rules.ToDictionary(x => x.RuleName);
        var missing = names.FirstOrDefault(x => !result.ContainsKey(x));
        if (missing != null) throw Oops.Bah($"计分规则【{missing}】不存在或已停用，请重新上传秩序册");
        return result;
    }

    // 场地建档（追加模式按名称复用），返回场地名 -> 场地上下文 的映射
    private async Task<Dictionary<string, OrderBookVenueContext>> EnsureVenuesAsync(
        OrderBookDraft draft, long eventId, long userId, DateTime now)
    {
        var venueNames = draft.Entries.Select(e => e.VenueName).Where(n => !string.IsNullOrWhiteSpace(n)).Distinct().ToList();
        var existVenues = await _venueRepository.AsQueryable()
            .Where(v => !v.DeleteMark && v.EventId == eventId).OrderBy(v => v.Sort).ToListAsync();

        var result = new Dictionary<string, OrderBookVenueContext>();
        foreach (var name in venueNames)
        {
            var venue = existVenues.FirstOrDefault(v => v.VenueName == name);
            int venueIndex;
            if (venue == null)
            {
                venueIndex = existVenues.Count + 1;
                venue = new EventVenue
                {
                    Id = _idGenerator.NextId(),
                    EventId = eventId,
                    VenueCode = $"V{venueIndex:00}",
                    VenueName = name,
                    Sort = venueIndex,
                    Status = AvailabilityStatus.Enable,
                    CreatedUserId = userId,
                    CreatedTime = now
                };
                await _venueRepository.InsertAsync(venue);
                existVenues.Add(venue);
            }
            else
            {
                venueIndex = venue.Sort <= 0 ? existVenues.IndexOf(venue) + 1 : venue.Sort;
            }
            result[name] = new OrderBookVenueContext { Venue = venue, Index = venueIndex };
        }
        return result;
    }

    // 按 项目×组别×场地 生成场次，返回组合键 -> 场次 的映射
    private async Task<Dictionary<string, EventSession>> EnsureSessionsAsync(
        OrderBookDraft draft, long eventId,
        Dictionary<string, OrderBookProjectContext> projectContext,
        Dictionary<string, OrderBookVenueContext> venueContext,
        long userId, DateTime now)
    {
        var combos = draft.Entries
            .Select(e => (e.ProjectName, e.GroupName, e.SessionName, e.VenueName))
            .Distinct()
            .ToList();

        var result = new Dictionary<string, EventSession>();
        var sessionSort = 0;
        foreach (var combo in combos)
        {
            var pc = projectContext[combo.ProjectName];
            var vc = venueContext[combo.VenueName];
            var groupId = pc.GroupMap.GetValueOrDefault(combo.GroupName);

            var exist = await _sessionRepository.GetFirstAsync(s =>
                !s.DeleteMark && s.EventId == eventId &&
                s.EventProjectId == pc.EventProjectId && s.VenueId == vc.Venue.Id &&
                s.SessionName == combo.SessionName &&
                (groupId == null ? s.EventProjectGroupId == null : s.EventProjectGroupId == groupId));
            if (exist != null)
            {
                result[SessionKey(combo.ProjectName, combo.GroupName, combo.SessionName, combo.VenueName)] = exist;
                continue;
            }

            sessionSort++;
            var session = new EventSession
            {
                Id = _idGenerator.NextId(),
                EventId = eventId,
                EventProjectId = pc.EventProjectId,
                EventProjectGroupId = groupId,
                VenueId = vc.Venue.Id,
                ScoreRuleId = pc.ScoreRuleId,
                SessionNo = $"EP{pc.EventProjectId}-V{vc.Index:00}-{sessionSort:000}",
                SessionName = combo.SessionName,
                SessionStatus = 0,
                Version = 1,
                Status = AvailabilityStatus.Enable,
                CreatedUserId = userId,
                CreatedTime = now
            };
            await _sessionRepository.InsertAsync(session);
            result[SessionKey(combo.ProjectName, combo.GroupName, combo.SessionName, combo.VenueName)] = session;
        }
        return result;
    }

    // 生成出场记录，返回数量
    private async Task<int> CreateEntriesAsync(
        OrderBookDraft draft,
        Dictionary<string, OrderBookProjectContext> projectContext,
        Dictionary<string, OrderBookVenueContext> venueContext,
        Dictionary<string, EventSession> sessionContext,
        long userId, DateTime now)
    {
        // 统计每个场次已有的最大出场顺序，追加模式在此基础上递增
        var sessionIds = sessionContext.Values.Select(s => s.Id).ToList();
        var existOrders = await _entryRepository.AsQueryable()
            .Where(e => !e.DeleteMark && sessionIds.Contains(e.SessionId))
            .GroupBy(e => e.SessionId)
            .Select(e => new { SessionId = e.SessionId, MaxOrder = SqlFunc.AggregateMax(e.PlayOrder) })
            .ToListAsync();
        var orderCounter = existOrders.ToDictionary(x => x.SessionId, x => x.MaxOrder);
        var usedEntryNos = (await _entryRepository.AsQueryable()
                .Where(e => !e.DeleteMark && sessionIds.Contains(e.SessionId))
                .Select(e => new { e.SessionId, e.EntryNo }).ToListAsync())
            .GroupBy(x => x.SessionId)
            .ToDictionary(g => g.Key, g => g.Select(x => x.EntryNo).ToHashSet());

        var toInsert = new List<EventSessionEntry>();
        foreach (var d in draft.Entries)
        {
            var session = sessionContext[SessionKey(d.ProjectName, d.GroupName, d.SessionName, d.VenueName)];
            var pc = projectContext[d.ProjectName];
            var vc = venueContext[d.VenueName];

            orderCounter.TryGetValue(session.Id, out var order);
            order++;
            orderCounter[session.Id] = order;

            var entryNo = $"{pc.Project.SortIndex:000}{vc.Index:00}{order:000}";
            if (!usedEntryNos.TryGetValue(session.Id, out var noSet))
            {
                noSet = new HashSet<string>();
                usedEntryNos[session.Id] = noSet;
            }
            // 自动编号撞号时追加顺序位，保证唯一
            while (!noSet.Add(entryNo))
                entryNo = $"{entryNo}-{order}";

            toInsert.Add(new EventSessionEntry
            {
                Id = _idGenerator.NextId(),
                SessionId = session.Id,
                ParticipationRecordId = null,
                RegistrationItemId = null,
                SourceType = 1, // 秩序册导入
                EntryNo = entryNo,
                PlayOrder = order,
                EntryStatus = 0,
                IsRematch = false,
                IsVoided = false,
                ParticipantName = d.ParticipantName,
                TeamName = d.TeamName,
                GroupName = d.GroupName,
                Version = 1,
                Status = AvailabilityStatus.Enable,
                CreatedUserId = userId,
                CreatedTime = now
            });
        }

        if (toInsert.Any())
            await _entryRepository.InsertRangeAsync(toInsert);
        return toInsert.Count;
    }

    // 裁判档案 / 赛事裁判关系 / 可选打分账号，返回纳入的裁判数量
    private async Task<int> EnsureRefereesAsync(
        OrderBookDraft draft, long eventId, OrderBookConfirmInput input, long userId, DateTime now)
    {
        if (!draft.Referees.Any())
            return 0;

        string? password = null;
        if (input.GenerateJudgeAccount)
        {
            password = input.DefaultPassword?.Trim();
            if (string.IsNullOrWhiteSpace(password))
                throw Oops.Bah("生成裁判账号时必须设置初始密码");
            if (password.Length is < 6 or > 32)
                throw Oops.Bah("裁判初始密码长度必须为6-32位");
        }

        var mobiles = draft.Referees.Select(r => r.Mobile).Distinct().ToList();
        var existReferees = await _refereeRepository.AsQueryable()
            .Where(r => !r.DeleteMark && r.AuditStatus == AuditStatus.Pass && mobiles.Contains(r.Mobile))
            .ToListAsync();
        var existEventReferees = await _eventRefereeRepository.AsQueryable()
            .Where(er => !er.DeleteMark && er.EventId == eventId).ToListAsync();
        var existAppUsers = await _appUserRepository.AsQueryable().Where(u => !u.DeleteMark && mobiles.Contains(u.Mobile)).ToListAsync();

        var newEventReferees = new List<EventReferee>();
        var count = 0;
        foreach (var d in draft.Referees)
        {
            var referee = existReferees.FirstOrDefault(r => r.Mobile == d.Mobile);
            if (referee == null)
                throw Oops.Bah($"裁判【{d.Name}】尚未完成注册认证，请重新上传秩序册");

            if (input.GenerateJudgeAccount)
            {
                var appUser = existAppUsers.FirstOrDefault(u => u.Mobile == d.Mobile);
                if (appUser == null)
                {
                    var appUserId = _idGenerator.NextId();
                    appUser = new Core.Entities.AppUser
                    {
                        Id = appUserId,
                        PersonType = PersonType.User,
                        MiniProgramRole = MiniProgramRole.Referee,
                        Name = d.Name,
                        Mobile = d.Mobile,
                        Gender = Gender.Unknown,
                        Password = MD5Encryption.Encrypt($"{_idGenerator.Encode(appUserId)}{password!}"),
                        AuditStatus = AuditStatus.Pass,
                        AuditUserId = userId,
                        AuditTime = now,
                        Status = AvailabilityStatus.Enable,
                        CreatedUserId = userId,
                        CreatedTime = now
                    };
                    await _appUserRepository.InsertAsync(appUser);
                    existAppUsers.Add(appUser);

                    referee.AppUserId = appUser.Id;
                    referee.UpdatedUserId = userId;
                    referee.UpdatedTime = now;
                    await _refereeRepository.UpdateAsync(referee);
                }
                else if (referee.AppUserId == null)
                {
                    referee.AppUserId = appUser.Id;
                    referee.UpdatedUserId = userId;
                    referee.UpdatedTime = now;
                    await _refereeRepository.UpdateAsync(referee);
                }
            }

            if (existEventReferees.All(er => er.RefereeId != referee.Id))
            {
                newEventReferees.Add(new EventReferee
                {
                    Id = _idGenerator.NextId(),
                    EventId = eventId,
                    RefereeId = referee.Id,
                    RefereeApplicationId = null,
                    SourceType = 3, // 秩序册导入
                    Status = AvailabilityStatus.Enable,
                    CreatedUserId = userId,
                    CreatedTime = now
                });
            }
            count++;
        }

        if (newEventReferees.Any())
            await _eventRefereeRepository.InsertRangeAsync(newEventReferees);
        return count;
    }

    #endregion

    #region 辅助

    private static string BatchKey(long batchId) => $"orderbook:batch:{batchId}";
    private static string CurrentKey(long eventId, long userId) => $"orderbook:current:{eventId}:{userId}";
    private static string ConfirmedKey(long batchId) => $"orderbook:confirmed:{batchId}";
    private static string SessionKey(string project, string group, string session, string venue)
        => $"{project}|{group}|{session}|{venue}";

    private static OrderBookParseIssue Issue(int row, string column, string message, string level = "error")
        => new() { Row = row, Column = column, Message = message, Level = level };

    private static string? Trim(string? value) => string.IsNullOrWhiteSpace(value) ? null : value.Trim();

    private static bool IsAllBlank(params string?[] values) => values.All(string.IsNullOrWhiteSpace);

    private sealed class OrderBookProjectContext
    {
        public Core.Entities.Project Project { get; set; } = null!;
        public long EventProjectId { get; set; }
        public long ScoreRuleId { get; set; }
        public Dictionary<string, long?> GroupMap { get; set; } = new();
    }

    private sealed class OrderBookVenueContext
    {
        public EventVenue Venue { get; set; } = null!;
        public int Index { get; set; }
    }

    #endregion
}

/// <summary>
/// 秩序册导入模板导出器：出场秩序 + 裁判名单 两个工作表
/// </summary>
internal sealed class OrderBookTemplateExporter : ExcelExportBase
{
    public override Task<byte[]> ExportAsync()
    {
        var headerColor = Color.FromArgb(217, 225, 242);

        #region 出场秩序
        CreateWorksheet("出场秩序");
        var entryHeaders = new[] { "项目名称*", "计分规则*", "组别名称*", "姓名*", "队伍名称", "单位", "场次*", "场地*" };
        SetMergeTitle("秩序册 - 出场秩序（带*为必填，队伍名称和单位可不填）", 1, 1, 1, entryHeaders.Length, headerColor, 12);
        SetHeaders(entryHeaders, 2, headerColor);
        var sample = new[] { "个人花样", "个人花样（精英级）", "B", "崔一，崔二", "", "某某单位", "个人花样-1号场地", "1号场地" };
        for (var c = 0; c < sample.Length; c++)
            Worksheet.Cells[3, c + 1].Value = sample[c];
        SetDataRowStyle(3, entryHeaders.Length);
        SetColumnWidths(new double[] { 18, 22, 14, 22, 18, 22, 22, 16 });
        FreezePanes(3, 1);
        #endregion

        #region 裁判名单
        CreateWorksheet("裁判名单");
        var refereeHeaders = new[] { "序号", "姓名*", "手机号*" };
        SetMergeTitle("秩序册 - 裁判名单（裁判须先完成注册认证；无裁判可不填本工作表）", 1, 1, 1, refereeHeaders.Length, headerColor, 12);
        SetHeaders(refereeHeaders, 2, headerColor);
        var refereeSample = new[] { "1", "李四", "13900000000" };
        for (var c = 0; c < refereeSample.Length; c++)
            Worksheet.Cells[3, c + 1].Value = refereeSample[c];
        SetDataRowStyle(3, refereeHeaders.Length);
        SetColumnWidths(new double[] { 8, 16, 18 });
        FreezePanes(3, 1);
        #endregion

        return GetAsByteArrayAsync();
    }
}