using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using YD_Event.Application.Event.Dtos;
using YD_Event.Core.Entities;
using YD_Event.Core.Enum;
using YD_Event.Core.Domain.Export;
using MiniExcelLibs;
using SqlSugar;
using OfficeOpenXml;
using OfficeOpenXml.Style;
using System.Drawing;
using static SKIT.FlurlHttpClient.Wechat.TenpayV3.Models.DepositMarketingMemberCardOpenCardCodesResponse.Types;
using YD_Event.Application.AppUser.Dtos;

namespace YD_Event.Application.Event;

/// <summary>
/// 成绩与证书管理
/// </summary>
public class EventScoreService : BaseService<EventResult>, ITransient
{
    private static readonly string[] ChineseNumbers = { "零", "一", "二", "三", "四", "五", "六", "七", "八", "九", "十" };
    
    /// <summary>
    /// 将数字名次转换为汉字形式
    /// </summary>
    private static string ConvertRankToChinese(int rank)
    {
        if (rank <= 0)
            return string.Empty;
            
        if (rank <= 10)
            return $"第{ChineseNumbers[rank]}名";
            
        if (rank < 20)
            return $"第十{ChineseNumbers[rank % 10]}名";
            
        if (rank % 10 == 0)
            return $"第{ChineseNumbers[rank / 10]}十名";
            
        return $"第{ChineseNumbers[rank / 10]}十{ChineseNumbers[rank % 10]}名";
    }
    
    private readonly ISqlSugarRepository<EventRegistrationPerson> _personRepository;
    private readonly ISqlSugarRepository<EventResult> _resultRepository;
    private readonly ISqlSugarRepository<EventCertificate> _certificateRepository;
    private readonly ISqlSugarRepository<EventRegistration> _registrationRepository;
    private readonly ISqlSugarRepository<CertificateTemplate> _templateRepository;
    private readonly ISqlSugarRepository<YD_Event.Core.Entities.Certificate> _certificateMasterRepository;
    private readonly ISqlSugarRepository<YD_Event.Core.Entities.Project> _projectRepository;
    private readonly ISqlSugarRepository<TeamMember> _teamMemberRepository;
    private readonly ISqlSugarRepository<EventInfo> _eventRepository;
    private readonly ISqlSugarRepository<PointsRule> _pointsRuleRepository;
    private readonly ISqlSugarRepository<PointsRuleDetail> _pointsRuleDetailRepository;
    private readonly ISqlSugarRepository<PointsRecord> _pointsRecordRepository;
    private readonly ISqlSugarRepository<YD_Event.Core.Entities.AppUser> _appUserRepository;
    private readonly CertificateGenerateService _certificateGenerateService;
    private readonly IIdGenerator _idGenerator;
    private readonly ILogger<EventScoreService> _logger;

    public EventScoreService(
        ISqlSugarRepository<EventRegistrationPerson> personRepository,
        ISqlSugarRepository<EventResult> resultRepository,
        ISqlSugarRepository<EventCertificate> certificateRepository,
        ISqlSugarRepository<EventRegistration> registrationRepository,
        ISqlSugarRepository<CertificateTemplate> templateRepository,
        ISqlSugarRepository<YD_Event.Core.Entities.Certificate> certificateMasterRepository,
        ISqlSugarRepository<YD_Event.Core.Entities.Project> projectRepository,
        ISqlSugarRepository<TeamMember> teamMemberRepository,
        ISqlSugarRepository<EventInfo> eventRepository,
        ISqlSugarRepository<PointsRule> pointsRuleRepository,
        ISqlSugarRepository<PointsRuleDetail> pointsRuleDetailRepository,
        ISqlSugarRepository<PointsRecord> pointsRecordRepository,
        ISqlSugarRepository<YD_Event.Core.Entities.AppUser> appUserRepository,
        CertificateGenerateService certificateGenerateService,
        IIdGenerator idGenerator,
        ILogger<EventScoreService> logger) : base(resultRepository)
    {
        _personRepository = personRepository;
        _resultRepository = resultRepository;
        _certificateRepository = certificateRepository;
        _registrationRepository = registrationRepository;
        _templateRepository = templateRepository;
        _certificateMasterRepository = certificateMasterRepository;
        _projectRepository = projectRepository;
        _teamMemberRepository = teamMemberRepository;
        _eventRepository = eventRepository;
        _pointsRuleRepository = pointsRuleRepository;
        _pointsRuleDetailRepository = pointsRuleDetailRepository;
        _pointsRecordRepository = pointsRecordRepository;
        _appUserRepository = appUserRepository;
        _certificateGenerateService = certificateGenerateService;
        _idGenerator = idGenerator;
        _logger = logger;
    }

    /// <summary>
    /// 运动员成绩列表
    /// </summary>
    [DisplayName("运动员成绩列表")]
    public async Task<PageResult<ScoreListOutput>> PageAthlete(ScoreQueryInput input)
    {
        _logger.LogInformation("开始查询运动员成绩列表，赛事ID={EventId}, 项目ID={ProjectId}, 赛事项目组别ID={EventProjectGroupId}, 组别名称={GroupName}", 
            input.EventId, input.ProjectId, input.EventProjectGroupId, input.GroupName);

        var query = _personRepository.AsQueryable()
            .LeftJoin<EventRegistration>((p, r) => p.RegistrationId == r.Id)
            .LeftJoin<EventResult>((p, r, res) => p.Id == res.RegistrationPersonId)
            .LeftJoin<EventCertificate>((p, r, res, c) => res.Id == c.ResultId)
            .Where((p, r, res, c) => r.EventId == input.EventId && (p.PersonType == PersonType.Athlete || p.PersonType == PersonType.User));
        
        // 应用筛选条件
        if (input.ProjectId.HasValue)
        {
            query = query.Where(p => p.ProjectId == input.ProjectId.Value);
        }
        
        // 优先使用 EventProjectGroupId，如果没有则使用 GroupName
        if (input.EventProjectGroupId.HasValue)
        {
            query = query.Where(p => p.EventProjectGroupId == input.EventProjectGroupId.Value);
        }
        else if (!string.IsNullOrWhiteSpace(input.GroupName))
        {
            query = query.Where(p => p.GroupName == input.GroupName);
        }
        
        if (!string.IsNullOrWhiteSpace(input.Name))
        {
            query = query.Where(p => p.Name.Contains(input.Name));
        }
        
        if (!string.IsNullOrWhiteSpace(input.UnitName))
        {
            query = query.Where((p, r) => r.TeamName.Contains(input.UnitName));
        }
        
        if (input.Gender.HasValue)
        {
            query = query.Where(p => p.Gender == input.Gender.Value);
        }

        var pageResult = await query
            .Select((p, r, res, c) => new ScoreListOutput
            {
                Id = p.Id,
                Name = p.Name,
                UnitName = r.TeamName,
                Gender = p.Gender.ToString(),
                Score = res.Score,
                Rank = res.Rank,
                ResultId = res.Id,
                CertificateId = c.Id
            })
            .ToPagedListAsync(input);
        
        foreach (var item in pageResult.Rows)
        {
            item.RankText = ConvertRankToChinese(item.Rank);
        }
        
        _logger.LogInformation("查询运动员成绩列表完成，共{Count}条记录", pageResult.Total);
        return pageResult;
    }

    /// <summary>
    /// 教练/领队列表
    /// </summary>
    /// <remarks>
    /// 通过运动员所在的团队关联获取教练和领队人员信息
    /// </remarks>
    [DisplayName("教练领队列表")]
    public async Task<PageResult<CoachLeaderListOutput>> PageCoachLeader(CoachLeaderQueryInput input)
    {
        // 步骤1：获取该赛事的所有运动员的 UserId
        var athleteUserIds = await _personRepository.AsQueryable()
            .InnerJoin<EventRegistration>((p, r) => p.RegistrationId == r.Id)
            .Where((p, r) => r.EventId == input.EventId && p.PersonType == PersonType.Athlete)
            .Select(p => p.UserId)
            .ToListAsync();

        if (!athleteUserIds.Any())
        {
            return new PageResult<CoachLeaderListOutput>();
        }

        // 步骤2：通过运动员的 UserId 找到对应的 TeamId
        var teamIds = await _teamMemberRepository.AsQueryable()
            .Where(tm => athleteUserIds.Contains(tm.UserId) && !tm.DeleteMark)
            .Select(tm => tm.TeamId)
            .Distinct()
            .ToListAsync();

        if (!teamIds.Any())
        {
            return new PageResult<CoachLeaderListOutput>();
        }

        // 步骤3：通过 TeamId 获取同团队的教练/领队的 UserId
        var coachLeaderUserIds = await _teamMemberRepository.AsQueryable()
            .Where(tm => teamIds.Contains(tm.TeamId) && tm.PersonType == input.PersonType && !tm.DeleteMark)
            .Select(tm => tm.UserId)
            .Distinct()
            .ToListAsync();

        if (!coachLeaderUserIds.Any())
        {
            return new PageResult<CoachLeaderListOutput>();
        }

        // 步骤4：从 AppUser 表获取教练/领队的详细信息（需要关联查询）
        var userQuery = _appUserRepository.AsQueryable()
            .Where(p => coachLeaderUserIds.Contains(p.Id))
            .Where(p=> p.PersonType == input.PersonType);

        var pageResult = await userQuery
            .Select(p => new CoachLeaderListOutput
            {
                Id = p.Id,
                Name = p.Name,
                Age = p.Age,
                IdCardNumber = p.IdCardImageUrl,
                Mobile = p.Mobile,
                CertificateId = 0 // 需要单独查询，此处先设为0
            })
            .ToPagedListAsync(input);

        foreach (var item in pageResult.Rows)
        {
            if (item.Age.HasValue)
            {
                continue;
            }
            if (item.BirthDate.HasValue)
            {
                item.Age = MemberOutput.CalculateAgeFromBirthDate(item.BirthDate);
            }
        }

        return pageResult;
    }

    /// <summary>
    /// 导入成绩（性能优化版）
    /// </summary>
    /// <remarks>
    /// 性能优化策略：
    /// 1. 批量预加载所有人员数据到内存
    /// 2. 使用字典建立索引，避免循环内数据库查询
    /// 3. 批量收集需要插入/更新的记录
    /// 4. 最后一次性执行批量操作
    /// 性能指标：导入10000条成绩数据时，响应时间 < 30秒，内存占用 < 512MB
    /// </remarks>
    [UnitOfWork]
    [DisplayName("导入成绩")]
    public async Task ImportScore(long eventId, IFormFile file)
    {
        _logger.LogInformation("开始导入成绩：赛事ID={EventId}", eventId);
        var startTime = DateTime.Now;

        using var stream = file.OpenReadStream();
        var rows = stream.Query<ScoreImportDto>().ToList();
        _logger.LogInformation("解析Excel完成，共 {RowCount} 条记录", rows.Count);

        if (!rows.Any())
        {
            throw Oops.Bah("Excel文件中没有数据");
        }

        // 验证导入数据
        var validationResult = await ValidateImportDataAsync(rows, eventId);
        if (!validationResult.IsValid)
        {
            var errorMessage = string.Join("\n", validationResult.Errors);
            throw Oops.Bah($"数据验证失败：\n{errorMessage}");
        }

        // 步骤1：批量预加载该赛事的所有人员数据
        var allPersons = await _personRepository.AsQueryable()
            .InnerJoin<EventRegistration>((p, r) => p.RegistrationId == r.Id)
            .Where((p, r) => r.EventId == eventId)
            .Select((p, r) => new 
            { 
                p.Id, 
                p.Name, 
                p.ProjectName, 
                p.GroupName, 
                p.RegistrationId, 
                p.ProjectId
            })
            .ToListAsync();

        _logger.LogInformation("预加载人员数据完成，共 {PersonCount} 人", allPersons.Count);

        // 步骤2：使用字典建立人员索引（Name_ProjectName_GroupName -> Person）
        var personDict = allPersons
            .GroupBy(p => $"{p.Name}_{p.ProjectName}_{p.GroupName}")
            .ToDictionary(g => g.Key, g => g.First());
        
        // 预加载项目信息，用于获取项目类型名称
        var projectIds = allPersons.Select(p => p.ProjectId).Distinct().ToList();
        var projects = await _projectRepository.GetListAsync(x => projectIds.Contains(x.Id));
        var projectDict = projects.ToDictionary(p => p.Id, p => p.ProjectType.Description());

        // 步骤3：预加载该赛事的所有成绩记录
        var personIds = allPersons.Select(p => p.Id).ToList();
        var existingResults = await _resultRepository.GetListAsync(x => 
            x.EventId == eventId && personIds.Contains(x.RegistrationPersonId));

        var resultDict = existingResults.ToDictionary(r => r.RegistrationPersonId);

        // 步骤4：批量处理数据，收集需要插入/更新的记录
        var resultsToInsert = new List<EventResult>();
        var resultsToUpdate = new List<EventResult>();
        var now = DateTime.Now;
        var notFoundPersons = new List<string>();

        foreach(var row in validationResult.ValidRows)
        {
            // 使用内存字典查找，避免数据库查询
            var key = $"{row.Name}_{row.ProjectName}_{row.GroupName}";
            if (!personDict.TryGetValue(key, out var person))
            {
                notFoundPersons.Add($"姓名:{row.Name}, 项目:{row.ProjectName}, 组别:{row.GroupName}");
                continue;
            }

            if (resultDict.TryGetValue(person.Id, out var existingResult))
            {
                // 更新现有记录
                existingResult.Score = row.Score;
                existingResult.Rank = row.Rank;
                existingResult.Remark = row.RankText;
                existingResult.ProjectTypeName = projectDict.TryGetValue(person.ProjectId, out var projectTypeName) ? projectTypeName : string.Empty;
                existingResult.UpdatedTime = now;
                resultsToUpdate.Add(existingResult);
            }
            else
            {
                // 插入新记录
                var newResult = new EventResult
                {
                    Id = _idGenerator.NewLong(),
                    EventId = eventId,
                    RegistrationPersonId = person.Id,
                    RegistrationId = person.RegistrationId,
                    ProjectId = person.ProjectId,
                    ParticipantName = person.Name,
                    GroupName = person.GroupName,
                    ProjectTypeName = projectDict.TryGetValue(person.ProjectId, out var projectTypeName) ? projectTypeName : string.Empty,
                    Score = row.Score,
                    Rank = row.Rank,
                    Remark = row.RankText,
                    CreatedTime = now,
                    UpdatedTime = now
                };
                resultsToInsert.Add(newResult);
            }
        }

        if (notFoundPersons.Any())
        {
            _logger.LogWarning("未找到匹配的参赛人员：{Count} 条", notFoundPersons.Count);
        }

        _logger.LogInformation("数据处理完成：新增 {InsertCount} 条，更新 {UpdateCount} 条，未找到 {NotFoundCount} 条", 
            resultsToInsert.Count, resultsToUpdate.Count, notFoundPersons.Count);

        // 步骤5：批量操作数据库
        if (resultsToInsert.Any())
        {
            await _resultRepository.InsertRangeAsync(resultsToInsert);
            _logger.LogInformation("批量插入成绩记录完成，共 {Count} 条", resultsToInsert.Count);
        }

        if (resultsToUpdate.Any())
        {
            await _resultRepository.UpdateRangeAsync(resultsToUpdate);
            _logger.LogInformation("批量更新成绩记录完成，共 {Count} 条", resultsToUpdate.Count);
        }

        var duration = (DateTime.Now - startTime).TotalSeconds;
        _logger.LogInformation("导入成绩完成：赛事ID={EventId}，总耗时={Duration}秒", eventId, duration);
    }

    /// <summary>
    /// 发放证书（支持模板选择和批量发放）
    /// </summary>
    [UnitOfWork]
    [DisplayName("发放证书")]
    public async Task<IssueCertificateResult> IssueCertificate(IssueCertificateInput input)
    {
        var result = new IssueCertificateResult();
        var now = DateTime.Now;

        // 验证证书是否存在并获取证书信息
        var certificate = await _certificateMasterRepository.GetFirstAsync(x => 
            x.Id == input.CertificateId && 
            x.Status == AvailabilityStatus.Enable && 
            !x.DeleteMark);
        if (certificate == null)
        {
            throw Oops.Bah("指定的证书不存在或不可用");
        }

        // 根据证书获取对应的模板ID
        var templateId = certificate.TemplateId;

        // 验证模板是否存在
        var template = await _templateRepository.GetFirstAsync(x => 
            x.Id == templateId && 
            x.Status == AvailabilityStatus.Enable && 
            !x.DeleteMark);
        if (template == null)
        {
            throw Oops.Bah("证书关联的模板不存在或不可用");
        }

        // 批量预加载所有需要的数据
        var persons = await _personRepository.GetListAsync(x => input.PersonIds.Contains(x.Id));
        var personDict = persons.ToDictionary(p => p.Id);

        var personIds = persons.Select(p => p.Id).ToList();
        var existingResults = await _resultRepository.GetListAsync(x => personIds.Contains(x.RegistrationPersonId));
        var resultDict = existingResults.ToDictionary(r => r.RegistrationPersonId);

        var existingCerts = await _certificateRepository.GetListAsync(x => 
            personIds.Contains(x.ParticipationRecordId));
        var certDict = existingCerts.ToDictionary(c => c.ParticipationRecordId);

        var certsToInsert = new List<EventCertificate>();

        foreach (var personId in input.PersonIds)
        {
            if (!personDict.TryGetValue(personId, out var person))
            {
                result.FailCount++;
                result.FailDetails.Add($"人员ID {personId} 不存在");
                continue;
            }

            EventCertificate? cert = null;

            if (person.PersonType == PersonType.Athlete || person.PersonType == PersonType.User)
            {
                if (!resultDict.TryGetValue(person.Id, out var resultRecord))
                {
                    result.FailCount++;
                    result.FailDetails.Add($"人员 {person.Name} 没有成绩记录");
                    continue;
                }

                if (certDict.TryGetValue(person.Id, out var existingCert))
                {
                    cert = existingCert;
                }
                else
                {
                    cert = new EventCertificate
                    {
                        Id = _idGenerator.NewLong(),
                        EventId = input.EventId,
                        ResultId = resultRecord.Id,
                        RegistrationId = person.RegistrationId,
                        ParticipationRecordId = person.Id,
                        ParticipantName = person.Name,
                        GroupName = person.GroupName,
                        CertificateStatus = 1,
                        GeneratedTime = now,
                        CertificateNo = $"C{now:yyyyMMdd}{person.Id}",
                        CreatedTime = now,
                        TemplateId = templateId,
                        CertificateUrl = string.Empty  // 暂时设置为空字符串，避免 null
                    };
                    certsToInsert.Add(cert);
                }
            }
            else
            {
                if (certDict.TryGetValue(person.Id, out var existingCert))
                {
                    cert = existingCert;
                }
                else
                {
                    cert = new EventCertificate
                    {
                        Id = _idGenerator.NewLong(),
                        EventId = input.EventId,
                        RegistrationId = person.RegistrationId,
                        ParticipationRecordId = person.Id,
                        ParticipantName = person.Name,
                        GroupName = person.GroupName,
                        CertificateStatus = 1,
                        GeneratedTime = now,
                        CertificateNo = $"CC{now:yyyyMMdd}{person.Id}",
                        CreatedTime = now,
                        TemplateId = templateId,
                        CertificateUrl = string.Empty  // 暂时设置为空字符串，避免 null
                    };
                    certsToInsert.Add(cert);
                }
            }

            // 更新证书状态为已发放
            cert.CertificateStatus = 2;
            cert.IssuedTime = now;
            cert.UpdatedTime = now;
            // 确保 CertificateUrl 不为 null
            if (string.IsNullOrEmpty(cert.CertificateUrl))
            {
                cert.CertificateUrl = string.Empty;
            }

            result.SuccessCount++;
        }

        if (certsToInsert.Any())
        {
            await _certificateRepository.InsertRangeAsync(certsToInsert);
        }

        // 更新已有证书的发放状态
        var existingCertsToUpdate = existingCerts.Where(c => 
            input.PersonIds.Contains(c.ParticipationRecordId)).ToList();
        if (existingCertsToUpdate.Any())
        {
            await _certificateRepository.UpdateRangeAsync(existingCertsToUpdate);
        }

        _logger.LogInformation("发放证书完成：成功 {SuccessCount} 条，失败 {FailCount} 条", 
            result.SuccessCount, result.FailCount);

        return result;
    }
    
    /// <summary>
    /// 查看证书接口
    /// </summary>
    /// <param name="input">输入参数</param>
    /// <returns>证书详情</returns>
    [DisplayName("查看证书")]
    public async Task<object> GetCertificateDetail(YD_Event.Application.Certificate.Dtos.IdInput input)
    {
        if (input.Id <= 0)
        {
            throw Oops.Bah("无效的 ID");
        }

        var personExists = await _personRepository.IsAnyAsync(x => x.Id == input.Id);
        if (!personExists)
        {
            throw Oops.Bah("人员记录不存在");
        }

        var cert = await _certificateRepository.GetFirstAsync(x => x.ParticipationRecordId == input.Id);
        if (cert == null)
        {
            throw Oops.Bah("未找到对应的证书信息");
        }

        return new { Url = cert.CertificateUrl };
    }

    /// <summary>
    /// 验证证书真伪
    /// </summary>
    [DisplayName("验证证书真伪")]
    public async Task<object> VerifyCertificate(string certificateNo)
    {
        if (string.IsNullOrWhiteSpace(certificateNo))
        {
            throw Oops.Bah("证书编号不能为空");
        }

        var cert = await _certificateRepository.GetFirstAsync(x => 
            x.CertificateNo == certificateNo && !x.DeleteMark);

        if (cert == null)
        {
            return new
            {
                IsValid = false,
                Message = "证书不存在"
            };
        }

        return new
        {
            IsValid = true,
            CertificateNo = cert.CertificateNo,
            ParticipantName = cert.ParticipantName,
            GroupName = cert.GroupName,
            IssuedTime = cert.IssuedTime,
            CertificateStatus = cert.CertificateStatus
        };
    }

    /// <summary>
    /// 下载模板
    /// </summary>
    [DisplayName("下载模板")]
    [HttpGet]
    public IActionResult DownloadTemplate()
    {
        var exporter = new ScoreTemplateExporter();
        var bytes = exporter.ExportAsync().GetAwaiter().GetResult();
        
        return new FileContentResult(bytes, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet") 
        { 
            FileDownloadName = "成绩导入模板.xlsx" 
        };
    }
    
    /// <summary>
    /// 成绩模板导出器
    /// </summary>
    private class ScoreTemplateExporter : ExcelExportBase
    {
        public override async Task<byte[]> ExportAsync()
        {
            CreateWorksheet("成绩导入模板");

            var headers = new string[] { 
                "赛事地址", 
                "项目", 
                "组别", 
                "姓名", 
                "联系方式", 
                "单位", 
                "成绩", 
                "名次（汉字）",
                "名次（数字）"
            };
            
            var headerColor = Color.FromArgb(204, 255, 204);
            SetHeaders(headers, 1, headerColor, 11);

            var widths = new double[] { 15, 15, 15, 12, 15, 20, 15, 15, 15 };
            SetColumnWidths(widths);

            SetRowHeight(1, 25);

            return await GetAsByteArrayAsync();
        }
    }

    /// <summary>
    /// 导出证书
    /// </summary>
    [DisplayName("导出证书")]
    public async Task<string> ExportCertificate(ScoreQueryInput input)
    {
        var list = await _certificateRepository.AsQueryable()
            .LeftJoin<EventResult>((c, r) => c.ResultId == r.Id)
            .LeftJoin<EventRegistration>((c, r, reg) => c.RegistrationId == reg.Id)
            .LeftJoin<YD_Event.Core.Entities.Project>((c, r, reg, p) => c.ProjectId == p.Id)
            .Where((c, r, reg, p) => c.EventId == input.EventId)
            .WhereIF(input.ProjectId.HasValue, (c, r, reg, p) => c.ProjectId == input.ProjectId)
            .WhereIF(!string.IsNullOrWhiteSpace(input.GroupName), (c, r, reg, p) => c.GroupName == input.GroupName)
            .WhereIF(!string.IsNullOrWhiteSpace(input.Name), (c, r, reg, p) => c.ParticipantName.Contains(input.Name))
            .Select((c, r, reg, p) => new CertificateExportDto
            {
                CertificateNo = c.CertificateNo,
                ParticipantName = c.ParticipantName,
                ProjectName = p.Name,
                GroupName = c.GroupName,
                UnitName = reg.TeamName,
                Score = r.Score,
                Rank = r.Rank,
                CertificateType = c.CertificateType == 1 ? "冠军证书" :
                                  c.CertificateType == 2 ? "亚军证书" :
                                  c.CertificateType == 3 ? "季军证书" :
                                  c.CertificateType == 4 ? "优胜证书" : "参与证书",
                IssuedTime = c.IssuedTime
            })
            .ToListAsync();

        using var stream = new MemoryStream();
        stream.SaveAs(list);
        return Convert.ToBase64String(stream.ToArray());
    }

    /// <summary>
    /// 导入成绩验证结果
    /// </summary>
    public class ImportScoreValidationResult
    {
        public bool IsValid { get; set; }
        public List<string> Errors { get; set; } = new List<string>();
        public List<ScoreImportDto> ValidRows { get; set; } = new List<ScoreImportDto>();
    }

    /// <summary>
    /// 验证导入数据
    /// </summary>
    private async Task<ImportScoreValidationResult> ValidateImportDataAsync(List<ScoreImportDto> rows, long eventId)
    {
        var result = new ImportScoreValidationResult();
        var errors = new List<string>();

        for (int i = 0; i < rows.Count; i++)
        {
            var row = rows[i];
            var rowErrors = new List<string>();
            var rowNumber = i + 2;

            if (string.IsNullOrWhiteSpace(row.Name))
                rowErrors.Add("姓名不能为空");
            
            if (string.IsNullOrWhiteSpace(row.ProjectName))
                rowErrors.Add("项目不能为空");
            
            if (string.IsNullOrWhiteSpace(row.GroupName))
                rowErrors.Add("组别不能为空");
            
            if (string.IsNullOrWhiteSpace(row.Score))
                rowErrors.Add("成绩不能为空");
            
            if (row.Rank <= 0)
                rowErrors.Add("名次必须为正整数");

            if (rowErrors.Any())
            {
                errors.Add($"第 {rowNumber} 行：{string.Join("，", rowErrors)}");
            }
            else
            {
                result.ValidRows.Add(row);
            }
        }

        if (errors.Any())
        {
            result.IsValid = false;
            result.Errors = errors;
        }
        else
        {
            result.IsValid = true;
        }

        return result;
    }

    /// <summary>
    /// 发放积分输入模型
    /// </summary>
    public class IssuePointsInput
    {
        public long EventId { get; set; }
    }

    /// <summary>
    /// 发放积分
    /// </summary>
    [DisplayName("发放积分")]
    [HttpPost("issuePoints")]
    [UnitOfWork]
    public async Task<object> IssuePoints([FromBody] IssuePointsInput input)
    {
        _logger.LogInformation("开始发放积分，赛事ID={EventId}", input.EventId);
        
        var eventInfo = await _eventRepository.GetByIdAsync(input.EventId);
        if (eventInfo == null)
        {
            throw Oops.Bah("赛事不存在");
        }

        if (!eventInfo.PointsRuleId.HasValue)
        {
            throw Oops.Bah("该赛事未配置积分规则");
        }

        var pointsRule = await _pointsRuleRepository.GetByIdAsync(eventInfo.PointsRuleId.Value);
        if (pointsRule == null)
        {
            throw Oops.Bah("积分规则不存在");
        }

        if (pointsRule.Status != AvailabilityStatus.Enable)
        {
            throw Oops.Bah("积分规则未启用");
        }

        var ruleDetails = await _pointsRuleDetailRepository.AsQueryable()
            .Where(x => x.PointsRuleId == pointsRule.Id)
            .OrderBy(x => x.StartRank)
            .ToListAsync();

        var results = await _resultRepository.AsQueryable()
            .InnerJoin<EventRegistrationPerson>((r, p) => r.RegistrationPersonId == p.Id)
            .Where((r, p) => r.EventId == input.EventId && r.Rank > 0)
            .Select((r, p) => new 
            { 
                ResultId = r.Id, 
                UserId = p.UserId, 
                ProjectId = r.ProjectId, 
                GroupName = r.GroupName, 
                Rank = r.Rank, 
                ParticipantName = r.ParticipantName,
                ProjectIdForRecord = r.ProjectId
            })
            .ToListAsync();

        if (!results.Any())
        {
            throw Oops.Bah("没有可发放积分的成绩记录");
        }

        var processedResultIdsList = await _pointsRecordRepository.AsQueryable()
            .Where(x => x.EventId == input.EventId && x.ResultId.HasValue)
            .Select(x => x.ResultId.Value)
            .ToListAsync();
        var processedResultIds = new HashSet<long>(processedResultIdsList);

        int successCount = 0;
        int skipCount = 0;
        var pointsRecords = new List<PointsRecord>();

        foreach (var result in results)
        {
            if (processedResultIds.Contains(result.ResultId))
            {
                skipCount++;
                continue;
            }

            int pointsToAward = 0;

            if (pointsRule.ParticipationPoints.HasValue && pointsRule.ParticipationPoints.Value > 0)
            {
                pointsToAward += pointsRule.ParticipationPoints.Value;
            }

            var matchingDetail = ruleDetails.FirstOrDefault(d => result.Rank >= d.StartRank && result.Rank <= d.EndRank);
            if (matchingDetail != null)
            {
                pointsToAward += matchingDetail.Points;
            }

            if (pointsToAward > 0)
            {
                var record = new PointsRecord
                {
                    Id = _idGenerator.NextId(),
                    UserId = result.UserId,
                    Type = PointsOperationType.Acquire,
                    EventId = input.EventId,
                    ProjectId = result.ProjectIdForRecord,
                    ResultId = result.ResultId,
                    Points = pointsToAward,
                    Remark = eventInfo.EventName,
                    Status = AvailabilityStatus.Enable,
                    CreatedTime = DateTime.Now
                };
                pointsRecords.Add(record);
                successCount++;
            }
        }

        if (pointsRecords.Any())
        {
            await _pointsRecordRepository.InsertRangeAsync(pointsRecords);
        }

        _logger.LogInformation("积分发放完成：赛事ID={EventId}，成功发放={SuccessCount}，跳过={SkipCount}", 
            input.EventId, successCount, skipCount);

        return new 
        { 
            Success = true, 
            Message = $"积分发放成功！已发放 {successCount} 条积分记录，跳过 {skipCount} 条已发放记录" 
        };
    }
}