YD_Event.Admin/YD_Event.Application/Event/UserEventRegistrationService.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using YD_Event.Application.Event.Dtos;
using YD_Event.Application.Project;
using YD_Event.Core.Entities;
using YD_Event.Core.Enum;
using YD_Event.Core.Domain.Pricing;
using SqlSugar;
using Mapster;
using YD_Event.Application.Auth;
using Furion.DynamicApiController;
using Microsoft.AspNetCore.Mvc;
using YD_Event.Application.File;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Authorization;
using System.ComponentModel;
using Furion.FriendlyException;
using Furion.DatabaseAccessor;
using Furion.DependencyInjection;
using Microsoft.Extensions.Options;
using YD_Event.Core.Infrastructure.WeChat;
using YD_Event.Core.Infrastructure.WeChat.Dto;
using System.IO;
using Microsoft.Extensions.Logging;

namespace YD_Event.Application.Event;

/// <summary>
/// 用户端报名管理服务
/// </summary>
public class UserEventRegistrationService : IDynamicApiController, ITransient
{
    private readonly ISqlSugarRepository<EventInfo> _eventRepository;
    private readonly ISqlSugarRepository<EventUnit> _unitRepository;
    private readonly ISqlSugarRepository<EventProject> _eventProjectRepository;
    private readonly ISqlSugarRepository<EventProjectGroup> _eventProjectGroupRepository;
    private readonly ISqlSugarRepository<ProjectGroup> _projectGroupRepository;
    private readonly ISqlSugarRepository<EventProjectRegistrationLimit> _projectLimitRepository;
    private readonly ISqlSugarRepository<YD_Event.Core.Entities.Project> _projectRepository;
    private readonly ISqlSugarRepository<ProjectType> _projectTypeRepository;
    private readonly ISqlSugarRepository<EventRegistration> _registrationRepository;
    private readonly ISqlSugarRepository<EventRegistrationItem> _registrationItemRepository;
    private readonly ISqlSugarRepository<EventRegistrationPerson> _registrationPersonRepository;
    private readonly ISqlSugarRepository<YD_Event.Core.Entities.AppUser> _userRepository;
    private readonly ISqlSugarRepository<SysUser> _sysUserRepository;
    private readonly ISqlSugarRepository<EventFeeConfig> _feeConfigRepository;
    private readonly ISqlSugarRepository<EventRegistrationLimit> _limitRepository;
    private readonly ISqlSugarRepository<PointsRule> _pointsRuleRepository;
    private readonly ISqlSugarRepository<YD_Event.Core.Entities.Order> _orderRepository;
    private readonly ISqlSugarRepository<WeChatPayConfig> _weChatPayConfigRepository;
    private readonly ISqlSugarRepository<YD_Event.Core.Entities.Merchant> _merchantRepository;
    private readonly ISqlSugarClient _db;
    private readonly AuthManager _authManager;
    private readonly IIdGenerator _idGenerator;
    private readonly WeChatPayService _weChatPayService;
    private readonly IOptionsMonitor<YD_Event.Core.Options.WechatTenpayClientOptions> _wechatTenpayClientOptionsMonitor;
    private readonly IHttpContextAccessor _httpContextAccessor;
    private readonly ProjectService _projectService;
    private readonly ISqlSugarRepository<YD_Event.Core.Entities.Coupon> _couponRepository;
    private readonly ISqlSugarRepository<YD_Event.Core.Entities.UserCoupon> _userCouponRepository;
    private readonly ILogger<UserEventRegistrationService> _logger;

    public UserEventRegistrationService(
        ISqlSugarRepository<EventInfo> eventRepository,
        ISqlSugarRepository<EventUnit> unitRepository,
        ISqlSugarRepository<EventProject> eventProjectRepository,
        ISqlSugarRepository<EventProjectGroup> eventProjectGroupRepository,
        ISqlSugarRepository<ProjectGroup> projectGroupRepository,
        ISqlSugarRepository<EventProjectRegistrationLimit> projectLimitRepository,
        ISqlSugarRepository<YD_Event.Core.Entities.Project> projectRepository,
        ISqlSugarRepository<ProjectType> projectTypeRepository,
        ISqlSugarRepository<EventRegistration> registrationRepository,
        ISqlSugarRepository<EventRegistrationItem> registrationItemRepository,
        ISqlSugarRepository<EventRegistrationPerson> registrationPersonRepository,
        ISqlSugarRepository<YD_Event.Core.Entities.AppUser> userRepository,
        ISqlSugarRepository<SysUser> sysUserRepository,
        ISqlSugarRepository<EventFeeConfig> feeConfigRepository,
        ISqlSugarRepository<EventRegistrationLimit> limitRepository,
        ISqlSugarRepository<PointsRule> pointsRuleRepository,
        ISqlSugarRepository<YD_Event.Core.Entities.Order> orderRepository,
        ISqlSugarRepository<WeChatPayConfig> weChatPayConfigRepository,
        ISqlSugarRepository<YD_Event.Core.Entities.Merchant> merchantRepository,
        ISqlSugarClient db,
        AuthManager authManager,
        IIdGenerator idGenerator,
        WeChatPayService weChatPayService,
        IOptionsMonitor<YD_Event.Core.Options.WechatTenpayClientOptions> wechatTenpayClientOptionsMonitor,
        IHttpContextAccessor httpContextAccessor,
        ProjectService projectService,
        ISqlSugarRepository<YD_Event.Core.Entities.Coupon> couponRepository,
        ISqlSugarRepository<YD_Event.Core.Entities.UserCoupon> userCouponRepository,
        ILogger<UserEventRegistrationService> logger)
    {
        _eventRepository = eventRepository;
        _unitRepository = unitRepository;
        _eventProjectRepository = eventProjectRepository;
        _eventProjectGroupRepository = eventProjectGroupRepository;
        _projectGroupRepository = projectGroupRepository;
        _projectLimitRepository = projectLimitRepository;
        _projectRepository = projectRepository;
        _projectTypeRepository = projectTypeRepository;
        _registrationRepository = registrationRepository;
        _registrationItemRepository = registrationItemRepository;
        _registrationPersonRepository = registrationPersonRepository;
        _userRepository = userRepository;
        _sysUserRepository = sysUserRepository;
        _feeConfigRepository = feeConfigRepository;
        _limitRepository = limitRepository;
        _pointsRuleRepository = pointsRuleRepository;
        _orderRepository = orderRepository;
        _weChatPayConfigRepository = weChatPayConfigRepository;
        _merchantRepository = merchantRepository;
        _db = db;
        _authManager = authManager;
        _idGenerator = idGenerator;
        _weChatPayService = weChatPayService;
        _wechatTenpayClientOptionsMonitor = wechatTenpayClientOptionsMonitor;
        _httpContextAccessor = httpContextAccessor;
        _projectService = projectService;
        _couponRepository = couponRepository;
        _userCouponRepository = userCouponRepository;
        _logger = logger;
    }

    /// <summary>
    /// 1. 赛事列表展示接口
    /// </summary>
    [DisplayName("赛事列表展示")]
    [HttpGet("list")]
    public async Task<PageResult<UserEventListOutput>> Page([FromQuery] UserEventQueryInput input)
    {
        var pageResult = await _eventRepository.AsQueryable()
            .Where(x => x.Status == AvailabilityStatus.Enable)
            .WhereIF(!string.IsNullOrWhiteSpace(input.Keyword), x => x.EventName.Contains(input.Keyword))
            .WhereIF(input.Status.HasValue && input.Status != 0, x => x.EventStatus == input.Status)
            .WhereIF(input.Type.HasValue, x => x.EventType == input.Type)
            .WhereIF(input.StartTime.HasValue, x => x.MatchStartTime >= input.StartTime)
            .WhereIF(input.EndTime.HasValue, x => x.MatchEndTime <= input.EndTime)
            .LeftJoin<EventFeeConfig>((e, fc) => e.Id == fc.EventId)
            .OrderByDescending((e, fc) => e.CreatedTime)
            .Select((e, fc) => new UserEventListOutput
            {
                Id = e.Id,
                Name = e.EventName,
                CoverImage = e.CoverImage,
                Status = e.EventStatus.ToString(), 
                Type = e.EventType.ToString(),
                RegistrationType = e.RegistrationType.ToString(),
                ChargeMode = fc.ChargeMode.ToString(),
                RegistrationStartTime = e.RegistrationStartTime,
                RegistrationEndTime = e.RegistrationEndTime,
                MatchStartTime = e.MatchStartTime,
                MatchEndTime = e.MatchEndTime
            }).ToPagedListAsync(input);

        var userId = _authManager.UserId;
        var certification = await _db.Queryable<MerchantCertification>()
            .FirstAsync(c => c.UserId == userId && c.AuditStatus == AuditStatus.Pass && !c.DeleteMark);
        var canRegister = certification != null;

        foreach (var item in pageResult.Rows)
        {
            item.CanRegister = canRegister;
        }

        return pageResult;
    }

    /// <summary>
    /// 2. 赛事详情查看接口
    /// </summary>
    [DisplayName("赛事详情查看")]
    [HttpGet("detail/{id}")]
    public async Task<UserEventDetailOutput> Detail([FromRoute] long id)
    {
        var eventInfo = await _eventRepository.GetByIdAsync(id);
        if (eventInfo == null) throw Oops.Bah("赛事不存在");

        var output = eventInfo.Adapt<UserEventDetailOutput>();
        output.Name = eventInfo.EventName;
        output.Description = eventInfo.EventIntroduction; 
        output.Address = eventInfo.DetailAddress;
        output.EventVideo = eventInfo.EventVideo;
        output.RegistrationType = eventInfo.RegistrationType.ToString();
        output.IsNeedMaterial = eventInfo.IsNeedMaterial;
        output.MaterialRemark = eventInfo.MaterialRemark;
        output.MaterialUploadEndTime = eventInfo.MaterialUploadEndTime;

        if (eventInfo.PointsRuleId.HasValue)
        {
            var rule = await _pointsRuleRepository.GetByIdAsync(eventInfo.PointsRuleId.Value);
            output.PointsRuleName = rule?.RuleName ?? "";
        }

        var units = await _unitRepository.GetListAsync(x => x.EventId == id);
        output.Units = units.OrderBy(x => x.Sort).Select(x => x.Adapt<EventUnitDto>()).ToList();

        var limit = await _limitRepository.GetFirstAsync(x => x.EventId == id);
        if (limit != null)
        {
            output.LimitConfig = new UserEventLimitOutput
            {
                IndividualProjectLimit = limit.IndividualProjectLimit,
                TeamProjectLimit = limit.TeamProjectLimit
            };
        }

        var fee = await _feeConfigRepository.GetFirstAsync(x => x.EventId == id);
        if (fee != null)
        {
            output.FeeConfig = new UserEventFeeOutput
            {
                ChargeMode = fee.ChargeMode.ToString(),
                Price = fee.Price
            };
        }

        var eventProjects = await _eventProjectRepository.GetListAsync(x => x.EventId == id);
        var eventProjectIds = eventProjects.Select(x => x.Id).ToList();
        var eventProjectGroups = await _eventProjectGroupRepository.GetListAsync(x => eventProjectIds.Contains(x.EventProjectId));
        var projectLimits = await _projectLimitRepository.GetListAsync(x => eventProjectIds.Contains(x.ProjectId));

        var projectIds = eventProjects.Select(x => x.ProjectId).Distinct().ToList();
        var baseProjects = await _projectRepository.GetListAsync(x => projectIds.Contains(x.Id) && x.Status == AvailabilityStatus.Enable);
        var baseProjectGroups = await _projectGroupRepository.GetListAsync(x => projectIds.Contains(x.ProjectId));
        
        // 获取所有项目类型
        var typeIds = baseProjects.Select(x => x.ProjectTypeId).Distinct().ToList();
        var types = await _projectTypeRepository.GetListAsync(x => typeIds.Contains(x.Id));

        var allProjectTypes = await _projectTypeRepository.AsQueryable()
            .Where(t => !t.DeleteMark && t.Status == AvailabilityStatus.Enable)
            .ToListAsync();

        var completionStats = await _projectService.GetProjectStatisticsBatchAsync(
            projectIds, 
            ProjectService.ProjectStatisticType.CompletionCount);

        output.Projects = eventProjects.Select(ep => 
        {
            var p = baseProjects.FirstOrDefault(b => b.Id == ep.ProjectId);
            var completionCount = 0;
            if (p != null && completionStats.TryGetValue(p.Id, out var count))
            {
                completionCount = count;
            }

            var dto = new UserEventProjectListOutput
            {
                Id = ep.Id,
                Name = p?.Name ?? "",
                Fee = ep.Price / 100m,
                CompletionCount = completionCount
            };

            if (p != null)
            {
                var type = types.FirstOrDefault(x => x.Id == p.ProjectTypeId);
                if (type != null)
                {
                    dto.ProjectTypeName = type.Name;
                    
                    // 为每个项目单独设置上级项目类型名称
                    if (type.ParentId > 0)
                    {
                        var parentProjectType = allProjectTypes.FirstOrDefault(t => t.Id == type.ParentId);
                        dto.ParentProjectTypeName = parentProjectType?.Name;
                    }
                }
            }

            var epGroups = eventProjectGroups.Where(g => g.EventProjectId == ep.Id).ToList();
            dto.Groups = epGroups.Select(eg => 
            {
                var baseGroup = baseProjectGroups.FirstOrDefault(bg => bg.Id == eg.ProjectGroupId);
                return new UserEventProjectGroupOutput
                {
                    Id = eg.Id,
                    GroupName = eg.GroupName ?? baseGroup?.GroupName,
                    BirthDateStart = eg.BirthDateStart != DateTime.MinValue ? eg.BirthDateStart : baseGroup?.BirthDateStart,
                    BirthDateEnd = eg.BirthDateEnd != DateTime.MinValue ? eg.BirthDateEnd : baseGroup?.BirthDateEnd,
                    Gender = eg.Gender.ToString()
                };
            }).ToList();

            var projLimit = projectLimits.FirstOrDefault(l => l.ProjectId == ep.Id);
            if (projLimit != null) dto.LimitCount = projLimit.LimitCount;

            return dto;
        }).Where(x => !string.IsNullOrEmpty(x.Name)).ToList();

        var userId = _authManager.UserId;
        var registration = await _registrationRepository.GetFirstAsync(x => x.EventId == id && x.CreatedUserId == userId && !x.DeleteMark);
        
        if (registration != null)
        {
            output.RegistrationId = registration.Id;
            output.UserRegistrationStatus = GetRegistrationStatusDesc(registration.RegistrationStatus);
        }
        else
        {
            output.UserRegistrationStatus = "未报名";
        }

        return output;
    }

    /// <summary>
    /// 3.1 选择报名项目接口
    /// </summary>
    [DisplayName("选择报名项目")]
    [HttpGet("projects/{eventId}")]
    public async Task<List<UserEventProjectListOutput>> GetProjects([FromRoute] long eventId)
    {
        var eventProjects = await _eventProjectRepository.GetListAsync(x => x.EventId == eventId);
        var eventProjectIds = eventProjects.Select(x => x.Id).ToList();
        var eventProjectGroups = await _eventProjectGroupRepository.GetListAsync(x => eventProjectIds.Contains(x.EventProjectId));
        var projectLimits = await _projectLimitRepository.GetListAsync(x => eventProjectIds.Contains(x.ProjectId));

        var projectIds = eventProjects.Select(x => x.ProjectId).Distinct().ToList();
        var baseProjects = await _projectRepository.GetListAsync(x => projectIds.Contains(x.Id) && x.Status == AvailabilityStatus.Enable);
        var baseProjectGroups = await _projectGroupRepository.GetListAsync(x => projectIds.Contains(x.ProjectId));

        var typeIds = baseProjects.Select(x => x.ProjectTypeId).Distinct().ToList();
        var types = await _projectTypeRepository.GetListAsync(x => typeIds.Contains(x.Id));

        var allProjectTypes = await _projectTypeRepository.AsQueryable()
            .Where(t => !t.DeleteMark && t.Status == AvailabilityStatus.Enable)
            .ToListAsync();

        var completionStats = await _projectService.GetProjectStatisticsBatchAsync(
            projectIds, 
            ProjectService.ProjectStatisticType.CompletionCount);

        return eventProjects.Select(ep => 
        {
            var p = baseProjects.FirstOrDefault(b => b.Id == ep.ProjectId);
            var completionCount = 0;
            if (p != null && completionStats.TryGetValue(p.Id, out var count))
            {
                completionCount = count;
            }

            var dto = new UserEventProjectListOutput
            {
                Id = ep.Id,
                Name = p?.Name ?? "",
                Fee = ep.Price / 100m,
                TeamSize = 1, 
                CompletionCount = completionCount
            };

            if (p != null)
            {
                var type = types.FirstOrDefault(x => x.Id == p.ProjectTypeId);
                if (type != null)
                {
                    dto.ProjectTypeName = type.Name;
                    
                    // 为每个项目单独设置上级项目类型名称
                    if (type.ParentId > 0)
                    {
                        var parentProjectType = allProjectTypes.FirstOrDefault(t => t.Id == type.ParentId);
                        dto.ParentProjectTypeName = parentProjectType?.Name;
                    }
                }
            }

            var epGroups = eventProjectGroups.Where(g => g.EventProjectId == ep.Id).ToList();
            dto.Groups = epGroups.Select(eg => 
            {
                var baseGroup = baseProjectGroups.FirstOrDefault(bg => bg.Id == eg.ProjectGroupId);
                return new UserEventProjectGroupOutput
                {
                    Id = eg.Id,
                    GroupName = eg.GroupName ?? baseGroup?.GroupName,
                    BirthDateStart = eg.BirthDateStart != DateTime.MinValue ? eg.BirthDateStart : baseGroup?.BirthDateStart,
                    BirthDateEnd = eg.BirthDateEnd != DateTime.MinValue ? eg.BirthDateEnd : baseGroup?.BirthDateEnd,
                    Gender = eg.Gender.ToString()
                };
            }).ToList();

            var projLimit = projectLimits.FirstOrDefault(l => l.ProjectId == ep.Id);
            if (projLimit != null) dto.LimitCount = projLimit.LimitCount;

            return dto;
        }).Where(x => !string.IsNullOrEmpty(x.Name)).ToList();
    }

    /// <summary>
    /// 3.2 分配队员接口 - 搜索队员
    /// </summary>
    [DisplayName("搜索队员")]
    [HttpGet("members/search")]
    public async Task<List<UserTeamMemberOutput>> SearchMembers([FromQuery] string keyword)
    {
        if (string.IsNullOrWhiteSpace(keyword)) return new List<UserTeamMemberOutput>();

        var users = await _userRepository.AsQueryable()
            .Where(x => (x.Mobile.Contains(keyword) || x.Id.ToString() == keyword) && !x.DeleteMark)
            .Take(10)
            .ToListAsync();

        return users.Select(u => new UserTeamMemberOutput
        {
            UserId = u.Id,
            Name = u.Name,
            Mobile = u.Mobile,
            IdCardNumber = MaskIdCard(u.IdCardNumber),
            Gender = u.Gender.ToString(),
            IsEligible = true,
            IneligibilityReason = ""
        }).ToList();
    }

    private string MaskIdCard(string idCard)
    {
        if (string.IsNullOrEmpty(idCard) || idCard.Length < 10) return idCard;
        return idCard.Substring(0, 6) + "********" + idCard.Substring(idCard.Length - 4);
    }

    /// <summary>
    /// 3.2 分配队员接口 - 提交报名（含保存草稿）
    /// </summary>
    [DisplayName("提交报名")]
    [HttpPost("submit")]
    [UnitOfWork]
    public async Task<long> SubmitRegistration([FromBody] UserSubmitRegistrationInput input)
    {
        var userId = _authManager.UserId;
        var sysUser = await _sysUserRepository.GetByIdAsync(userId);
        if (sysUser == null) throw Oops.Bah("用户不存在");
        string userName = sysUser.Name;
        string userMobile = sysUser.Mobile ?? "";
        
        var eventInfo = await _eventRepository.GetByIdAsync(input.EventId);
        if (eventInfo == null) throw Oops.Bah("赛事不存在");
        
        // 验证1：一次报名只能选择一个项目
        if (input.ProjectIds != null && input.ProjectIds.Count > 1)
        {
            throw Oops.Bah("一次报名只能选择一个项目");
        }

        // 验证2：一次报名只能选择单个团队内的运动员
        if (input.MemberIds != null && input.MemberIds.Count > 0)
        {
            // 获取所有队员的团队关系
            var teamMembers = await _db.Queryable<TeamMember>()
                .Where(tm => input.MemberIds.Contains(tm.UserId))
                .Where(tm => !tm.DeleteMark)
                .ToListAsync();

            if (teamMembers == null || teamMembers.Count == 0)
            {
                throw Oops.Bah("未找到队员信息");
            }

            // 按用户ID分组，获取每个用户所属的所有团队
            var userTeamMap = teamMembers
                .GroupBy(tm => tm.UserId)
                .ToDictionary(g => g.Key, g => g.Select(tm => tm.TeamId).ToList());

            // 检查是否所有用户都有团队信息
            var missingUsers = input.MemberIds.Except(userTeamMap.Keys).ToList();
            if (missingUsers.Any())
            {
                throw Oops.Bah("部分队员未找到团队信息");
            }

            // 验证所有队员是否都属于指定的 TeamId
            var allBelongToTeam = userTeamMap.All(ut => ut.Value.Contains(input.TeamId));
            if (!allBelongToTeam)
            {
                throw Oops.Bah("所有选择的运动员必须隶属于同一个团队");
            }
        }

        var registration = await _registrationRepository.GetFirstAsync(x => x.EventId == input.EventId && x.CreatedUserId == userId && !x.DeleteMark);
        
        if (registration == null)
        {
            registration = new EventRegistration
            {
                Id = _idGenerator.NewLong(),
                EventId = input.EventId,
                CreatedUserId = userId,
                CreatedTime = DateTime.Now,
                Status = AvailabilityStatus.Enable,
                RegistrationStatus = input.IsDraft ? 0 : 1, // 0-待提交(草稿), 1-待审核
                ContactName = userName,
                ContactPhone = userMobile,
                OrderNo = "",
                RegistrationMode = 1
            };
            await _registrationRepository.InsertAsync(registration);
        }
        else
        {
            registration.RegistrationStatus = input.IsDraft ? 0 : 1;
            registration.ContactName = userName;
            registration.ContactPhone = userMobile;
            registration.UpdatedTime = DateTime.Now;
            registration.UpdatedUserId = userId;
            await _registrationRepository.UpdateAsync(registration);
        }

        await _registrationItemRepository.DeleteAsync(x => x.RegistrationId == registration.Id);
        await _registrationPersonRepository.DeleteAsync(x => x.RegistrationId == registration.Id);
        
        var members = await _userRepository.GetListAsync(x => input.MemberIds.Contains(x.Id));
        
        var groupIds = input.GroupMembers?.Select(g => g.GroupId).Distinct().ToList() ?? new List<long>();
        var eventProjectGroups = await _eventProjectGroupRepository.GetListAsync(x => groupIds.Contains(x.Id));
        
        // 通过EventProjectGroup获取对应的EventProject
        var eventProjectIds = eventProjectGroups.Select(x => x.EventProjectId).Distinct().ToList();
        var eventProjects = await _eventProjectRepository.GetListAsync(x => eventProjectIds.Contains(x.Id));
        
        var baseProjectIds = eventProjects.Select(x => x.ProjectId).Distinct().ToList();
        var baseProjects = await _projectRepository.GetListAsync(x => baseProjectIds.Contains(x.Id));
        
        // 获取项目类型信息
        var projectTypeIds = baseProjects.Select(x => x.ProjectTypeId).Distinct().ToList();
        var projectTypes = await _projectTypeRepository.GetListAsync(x => projectTypeIds.Contains(x.Id));
        
        var baseProjectGroupIds = eventProjectGroups.Select(x => x.ProjectGroupId).Distinct().ToList();
        var baseProjectGroups = await _projectGroupRepository.GetListAsync(x => baseProjectGroupIds.Contains(x.Id));

        int totalPersonCount = 0;
        FeeCalculationResult? feeCalculationResult = null;

        if (input.GroupMembers != null && input.GroupMembers.Any())
        {
            foreach (var groupMember in input.GroupMembers)
            {
                var eventProjectGroup = eventProjectGroups.FirstOrDefault(g => g.Id == groupMember.GroupId);
                if (eventProjectGroup == null) continue;

                var eventProject = eventProjects.FirstOrDefault(p => p.Id == eventProjectGroup.EventProjectId);
                if (eventProject == null) continue;

                var baseProject = baseProjects.FirstOrDefault(x => x.Id == eventProject.ProjectId);
                var baseProjectGroup = baseProjectGroups.FirstOrDefault(bg => bg.Id == eventProjectGroup.ProjectGroupId);
                var projectType = projectTypes.FirstOrDefault(pt => pt.Id == baseProject?.ProjectTypeId);

                var groupMembers = members.Where(m => groupMember.MemberIds.Contains(m.Id)).ToList();
                if (!groupMembers.Any()) continue;

                var item = new EventRegistrationItem
                {
                    Id = _idGenerator.NewLong(),
                    RegistrationId = registration.Id,
                    ProjectId = eventProject.Id,
                    EventProjectGroupId = eventProjectGroup.Id,
                    ProjectName = baseProject?.Name ?? "",
                    GroupName = baseProjectGroup?.GroupName ?? "",
                    ProjectTypeName = projectType?.Name ?? "",
                    UnitPrice = eventProject.Price / 100m,
                    PersonCount = groupMembers.Count(),
                    TotalPrice = (eventProject.Price / 100m) * groupMembers.Count(),
                    CreatedUserId = userId,
                    CreatedTime = DateTime.Now
                };
                await _registrationItemRepository.InsertAsync(item);
                
                totalPersonCount += item.PersonCount;

                foreach (var member in groupMembers)
                {
                    var person = new EventRegistrationPerson
                    {
                        Id = _idGenerator.NewLong(),
                        RegistrationId = registration.Id,
                        RegistrationItemId = item.Id,
                        ProjectId = eventProject.Id,
                        EventProjectGroupId = eventProjectGroup.Id,
                        GroupName = baseProjectGroup?.GroupName ?? "",
                        ProjectName = baseProject?.Name ?? "",
                        Name = member.Name,
                        Gender = member.Gender,
                        IdCard = member.IdCardNumber,
                        Phone = member.Mobile,
                        Age = member.Age ?? 0, 
                        BirthDate = member.BirthDate ?? DateTime.MinValue,
                        PersonType = PersonType.Athlete,
                        CreatedUserId = userId,
                        CreatedTime = DateTime.Now
                    };
                    await _registrationPersonRepository.InsertAsync(person);
                }
            }
        }
        else
        {
            foreach (var eventProject in eventProjects)
            {
                var baseProject = baseProjects.FirstOrDefault(x => x.Id == eventProject.ProjectId);
                var projectType = projectTypes.FirstOrDefault(pt => pt.Id == baseProject?.ProjectTypeId);
                var item = new EventRegistrationItem
                {
                    Id = _idGenerator.NewLong(),
                    RegistrationId = registration.Id,
                    ProjectId = eventProject.Id,
                    ProjectName = baseProject?.Name ?? "",
                    ProjectTypeName = projectType?.Name ?? "",
                    UnitPrice = eventProject.Price / 100m,
                    PersonCount = members.Count(),
                    TotalPrice = (eventProject.Price / 100m) * members.Count(),
                    CreatedUserId = userId,
                    CreatedTime = DateTime.Now
                };
                await _registrationItemRepository.InsertAsync(item);
                
                totalPersonCount += item.PersonCount;

                foreach (var member in members)
                {
                    var person = new EventRegistrationPerson
                    {
                        Id = _idGenerator.NewLong(),
                        RegistrationId = registration.Id,
                        RegistrationItemId = item.Id,
                        ProjectId = eventProject.Id,
                        GroupName = baseProject?.Name ?? "",
                        ProjectName = baseProject?.Name ?? "",
                        Name = member.Name,
                        Gender = member.Gender,
                        IdCard = member.IdCardNumber,
                        Phone = member.Mobile,
                        Age = member.Age ?? 0, 
                        BirthDate = member.BirthDate ?? DateTime.MinValue,
                        PersonType = PersonType.Athlete,
                        CreatedUserId = userId,
                        CreatedTime = DateTime.Now
                    };
                    await _registrationPersonRepository.InsertAsync(person);
                }
            }
        }

        if (totalPersonCount > 0)
        {
            var feeInput = new FeeCalculationInput
            {
                EventId = input.EventId,
                EventProjectIds = eventProjectIds,
                ParticipantCount = totalPersonCount
            };
            feeCalculationResult = await CalculateFeeAsync(feeInput);
            registration.TotalAmount = feeCalculationResult.TotalAmount;
        }

        registration.TotalPersonCount = totalPersonCount;
        await _registrationRepository.UpdateAsync(registration);

        return registration.Id;
    }

    /// <summary>
    /// 3.3 预览支付接口
    /// </summary>
    [DisplayName("预览支付")]
    [HttpGet("preview/{registrationId}")]
    public async Task<UserOrderPreviewOutput> PreviewOrder([FromRoute] long registrationId)
    {
        var registration = await _registrationRepository.GetByIdAsync(registrationId);
        if (registration == null) throw Oops.Bah("报名信息不存在");

        var eventInfo = await _eventRepository.GetByIdAsync(registration.EventId);
        var items = await _registrationItemRepository.GetListAsync(x => x.RegistrationId == registrationId);
        var persons = await _registrationPersonRepository.GetListAsync(x => x.RegistrationId == registrationId);

        var projectOutputs = items.Select(i =>
        {
            // 获取该项目的队员
            var itemMembers = persons
                .Where(p => p.RegistrationItemId == i.Id)
                .Select(p => new UserTeamMemberOutput
                {
                    UserId = p.Id,
                    Name = p.Name,
                    Mobile = p.Phone,
                    IdCardNumber = MaskIdCard(p.IdCard),
                    Gender = p.Gender.ToString(),
                    IsEligible = true,
                    IneligibilityReason = ""
                })
                .ToList();

            return new UserEventProjectListOutput
            {
                Id = i.ProjectId,
                Name = i.ProjectName,
                GroupName = i.GroupName,
                ProjectTypeName = i.ProjectTypeName,
                Fee = i.UnitPrice,
                RegisteredCount = i.PersonCount,
                CompletionCount = i.PersonCount,
                Members = itemMembers
            };
        }).ToList();

        var memberOutputs = persons.DistinctBy(p => p.IdCard).Select(p => new UserTeamMemberOutput
        {
            UserId = p.Id,
            Name = p.Name,
            Mobile = p.Phone,
            IdCardNumber = MaskIdCard(p.IdCard),
            Gender = p.Gender.ToString(),
            IsEligible = true,
            IneligibilityReason = ""
        }).ToList();

        return new UserOrderPreviewOutput
        {
            EventId = eventInfo.Id,
            EventName = eventInfo.EventName,
            Projects = projectOutputs,
            Members = memberOutputs,
            TotalAmount = registration.TotalAmount,
            FeeDetails = new Dictionary<string, decimal> { { "报名费", registration.TotalAmount } }
        };
    }

    /// <summary>
    /// 创建支付订单
    /// </summary>
    [DisplayName("创建支付订单")]
    [HttpPost("order/create")]
    [UnitOfWork]
    public async Task<UserPaymentResultOutput> CreateOrder([FromBody] UserCreateOrderInput input)
    {
        var registration = await _registrationRepository.GetByIdAsync(input.RegistrationId);
        if (registration == null) throw Oops.Bah("报名信息不存在");
        
        var eventInfo = await _eventRepository.GetByIdAsync(registration.EventId);
        if (eventInfo == null) throw Oops.Bah("赛事信息不存在");

        var result = new UserPaymentResultOutput();
        
        // 计算最终支付金额
        decimal originalAmount = registration.TotalAmount;
        decimal finalAmount = originalAmount;
        decimal discountAmount = 0;
        YD_Event.Core.Entities.Coupon? coupon = null;
        YD_Event.Core.Entities.UserCoupon? userCoupon = null;
        
        // 处理优惠券
        if (input.CouponId.HasValue)
        {
            var userId = _authManager.UserId;
            coupon = await _couponRepository.GetFirstAsync(c => 
                c.Id == input.CouponId.Value && 
                c.Status == AvailabilityStatus.Enable && 
                !c.DeleteMark);
            
            if (coupon != null)
            {
                userCoupon = await _userCouponRepository.GetFirstAsync(uc => 
                    uc.CouponId == coupon.Id && 
                    uc.UserId == userId && 
                    uc.Status == 0 && // 0-未使用
                    !uc.DeleteMark);
                
                if (userCoupon != null)
                {
                    // 计算折扣金额
                    if (coupon.Type == 0) // 折扣
                    {
                        discountAmount = originalAmount * (1 - coupon.Value / 100);
                    }
                    else if (coupon.Type == 1) // 定额
                    {
                        discountAmount = Math.Min(coupon.Value, originalAmount);
                    }
                    
                    finalAmount = originalAmount - discountAmount;
                    finalAmount = Math.Max(0, finalAmount);
                }
            }
        }

        // 如果最终金额为0，直接完成报名，无需支付
        if (finalAmount <= 0)
        {
            // 如果使用了优惠券，标记为已使用
            if (userCoupon != null)
            {
                userCoupon.Status = 1; // 1-已使用
                userCoupon.UseTime = DateTime.Now;
                await _userCouponRepository.UpdateAsync(userCoupon);
            }
            
            registration.PaymentStatus = 1; // 已支付
            registration.RegistrationStatus = 1; // 待审核
            registration.PaymentTime = DateTime.Now;
            await _registrationRepository.UpdateAsync(registration);

            result.Status = 1;
            result.IsFree = true;
            return result;
        }

        // 获取当前用户的单位认证ID
        var certification = await _db.Queryable<MerchantCertification>()
            .FirstAsync(c => c.UserId == registration.CreatedUserId && c.AuditStatus == AuditStatus.Pass && !c.DeleteMark);

        var orderNo = _idGenerator.NewLong().ToString();
        registration.OrderNo = orderNo;
        registration.PaymentMethod = input.PaymentMethod;
        registration.PaymentStatus = 0; // 未支付
        await _registrationRepository.UpdateAsync(registration);

        // 创建内部订单记录
        var order = new YD_Event.Core.Entities.Order
        {
            Id = _idGenerator.NewLong(),
            OrderNo = orderNo,
            OrderType = 1, // Income
            PaymentMethod = input.PaymentMethod,
            RegistrationMode = registration.RegistrationMode,
            MerchantId = eventInfo.MerchantId,
            MerchantCertificationId = certification?.Id, // 设置单位认证ID
            EventId = registration.EventId,
            RegistrationId = registration.Id,
            OriginalAmount = originalAmount,
            ActualAmount = finalAmount, 
            DiscountAmount = discountAmount,
            CouponId = input.CouponId,
            OrderStatus = OrderStatus.Pending,
            CreatedTime = DateTime.Now,
            CreatedUserId = registration.CreatedUserId
        };
        await _orderRepository.InsertAsync(order);

        result.OrderNo = orderNo;
        result.Status = 0;
        result.IsFree = false;

        // 如果是微信支付 (假设 1 是微信支付)
        if (input.PaymentMethod == 1)
        {
            WeChatPayConfig? payConfig = null;
            if (eventInfo.MerchantId.HasValue)
            {
                payConfig = await _weChatPayConfigRepository.GetFirstAsync(x => 
                    x.MerchantId == eventInfo.MerchantId.Value && 
                    x.Status == AvailabilityStatus.Enable && 
                    !x.DeleteMark);
            }

            if (payConfig == null)
            {
                throw Oops.Bah("商户微信支付配置不存在");
            }

            var configOptions = _wechatTenpayClientOptionsMonitor.CurrentValue;
            var nativeRequest = new CreateNativePayRequest
            {
                OutTradeNo = orderNo,
                AppId = configOptions.AppId,
                Description = $"{eventInfo.EventName} - 报名费",
                NotifyUrl = configOptions.NotifyUrl,
                TotalAmount = (int)(finalAmount * 100), // 单位为分，使用优惠后的金额
                ExpireTime = DateTimeOffset.Now.AddMinutes(5)
            };

            var payResult = await _weChatPayService.CreateNativePayAsync(payConfig, nativeRequest);
            if (payResult.Success)
            {
                result.PayUrl = payResult.QrcodeUrl ?? string.Empty;
                result.QrcodeUrl = payResult.QrcodeUrl;
                result.TradeType = payResult.TradeType;
            }
            else
            {
                throw Oops.Bah($"微信统一下单失败：{payResult.Message}");
            }
        }
        else
        {
            result.PayUrl = "http://mock-pay-url.com/" + orderNo;
            result.TradeType = "MOCK";
        }

        return result;
    }

    /// <summary>
    /// 微信支付回调
    /// </summary>
    [DisplayName("微信支付回调")]
    [HttpPost("wechat/notify")]
    [AllowAnonymous]
    [NonUnify]
    public async Task<IActionResult> WechatPayNotify()
    {
        var request = _httpContextAccessor.HttpContext.Request;
        using var reader = new StreamReader(request.Body);
        var body = await reader.ReadToEndAsync();

        var signature = request.Headers["Wechatpay-Signature"].ToString();
        var timestamp = request.Headers["Wechatpay-Timestamp"].ToString();
        var nonce = request.Headers["Wechatpay-Nonce"].ToString();
        var serialNumber = request.Headers["Wechatpay-Serial"].ToString();

        var notifyRequest = new WeChatPayNotifyRequest
        {
            Body = body,
            Signature = signature,
            Timestamp = timestamp,
            Nonce = nonce,
            SerialNumber = serialNumber
        };

        var payConfig = await _weChatPayConfigRepository.GetFirstAsync(x => 
            x.Status == AvailabilityStatus.Enable && !x.DeleteMark);

        if (payConfig == null)
        {
            return new BadRequestObjectResult(new { code = "FAIL", message = "支付配置不存在" });
        }

        bool valid = await _weChatPayService.VerifyPayNotifyAsync(payConfig, notifyRequest);
        if (!valid)
        {
            return new BadRequestResult();
        }

        var notifyData = await _weChatPayService.DecryptPayNotifyDataAsync(payConfig, notifyRequest);
        if (notifyData != null && notifyData.EventType == "TRANSACTION.SUCCESS")
        {
            var orderNo = notifyData.OutTradeNo;
            var transactionId = notifyData.TransactionId;

            var order = await _orderRepository.GetFirstAsync(x => x.OrderNo == orderNo);
            if (order != null && order.OrderStatus == OrderStatus.Pending)
            {
                order.OrderStatus = OrderStatus.Paid;
                order.PaymentTime = DateTime.Now;
                if (notifyData.PayerAmount.HasValue)
                {
                    order.ActualAmount = notifyData.PayerAmount.Value / 100m;
                }
                order.Remark = $"微信支付单号: {transactionId}";
                await _orderRepository.UpdateAsync(order);

                var registration = await _registrationRepository.GetByIdAsync(order.RegistrationId);
                if (registration != null && registration.PaymentStatus != 1)
                {
                    registration.PaymentStatus = 1;
                    registration.RegistrationStatus = 1;
                    await _registrationRepository.UpdateAsync(registration);
                }
            }
        }

        return new OkObjectResult(new { code = "SUCCESS", message = "成功" });
    }

    /// <summary>
    /// 查询订单支付状态
    /// </summary>
    [DisplayName("查询订单支付状态")]
    [HttpGet("order/status/{orderNo}")]
    public async Task<int> QueryOrderStatus([FromRoute] string orderNo)
    {
        var order = await _orderRepository.GetFirstAsync(x => x.OrderNo == orderNo);
        if (order == null) throw Oops.Bah("订单不存在");

        if (order.OrderStatus == OrderStatus.Paid)
            return 1; // 已支付

        if (order.PaymentMethod == 1)
        {
            WeChatPayConfig? payConfig = null;
            if (order.MerchantId.HasValue)
            {
                payConfig = await _weChatPayConfigRepository.GetFirstAsync(x => 
                    x.MerchantId == order.MerchantId.Value && 
                    x.Status == AvailabilityStatus.Enable && 
                    !x.DeleteMark);
            }

            if (payConfig == null)
            {
                payConfig = await _weChatPayConfigRepository.GetFirstAsync(x => 
                    x.Status == AvailabilityStatus.Enable && !x.DeleteMark);
            }

            if (payConfig != null)
            {
                var queryResult = await _weChatPayService.QueryOrderAsync(payConfig, orderNo);
                if (queryResult.Success && queryResult.TradeState == "SUCCESS")
                {
                    order.OrderStatus = OrderStatus.Paid;
                    order.PaymentTime = queryResult.SuccessTime?.DateTime;
                    if (queryResult.PayerAmount.HasValue)
                    {
                        order.ActualAmount = queryResult.PayerAmount.Value / 100m;
                    }
                    await _orderRepository.UpdateAsync(order);

                    var registration = await _registrationRepository.GetByIdAsync(order.RegistrationId);
                    if (registration != null && registration.PaymentStatus != 1)
                    {
                        registration.PaymentStatus = 1;
                        registration.RegistrationStatus = 1;
                        await _registrationRepository.UpdateAsync(registration);
                    }
                    return 1;
                }
            }
        }

        return 0; // 未支付
    }

    /// <summary>
    /// 验证优惠券
    /// </summary>
    [DisplayName("验证优惠券")]
    [HttpPost("coupon/validate")]
    public async Task<ValidateCouponOutput> ValidateCoupon([FromBody] ValidateCouponInput input)
    {
        var result = new ValidateCouponOutput
        {
            IsValid = false,
            InvalidReason = ""
        };

        // 查找优惠券（通过兑换码）
        var coupon = await _couponRepository.GetFirstAsync(c => 
            c.RedemptionCode == input.CouponCode && 
            c.Status == AvailabilityStatus.Enable && 
            !c.DeleteMark);

        if (coupon == null)
        {
            result.InvalidReason = "优惠券不存在或已失效";
            return result;
        }

        // 检查优惠券是否已过期
        if (coupon.EndTime.HasValue && coupon.EndTime.Value < DateTime.Now)
        {
            result.InvalidReason = "优惠券已过期";
            return result;
        }

        // 检查优惠券是否已开始
        if (coupon.StartTime.HasValue && coupon.StartTime.Value > DateTime.Now)
        {
            result.InvalidReason = "优惠券尚未生效";
            return result;
        }

        // 检查库存
        if (coupon.TotalQuantity > 0 && coupon.ClaimedQuantity >= coupon.TotalQuantity)
        {
            result.InvalidReason = "优惠券已被领完";
            return result;
        }

        // 检查优惠券是否适用于该赛事
        if (!string.IsNullOrEmpty(coupon.EventIds))
        {
            var eventIds = coupon.EventIds.Split(',').Select(long.Parse).ToList();
            if (!eventIds.Contains(input.EventId))
            {
                result.InvalidReason = "该优惠券不适用于当前赛事";
                return result;
            }
        }

        // 检查当前用户是否拥有该优惠券且未使用，或者可以直接领取
        var userId = _authManager.UserId;
        var userCoupon = await _userCouponRepository.GetFirstAsync(uc => 
            uc.CouponId == coupon.Id && 
            uc.UserId == userId && 
            uc.Status == 0 && // 0-未使用
            !uc.DeleteMark);

        // 如果用户没有该优惠券，检查是否可以直接领取（假设可以直接通过兑换码领取）
        if (userCoupon == null)
        {
            // 创建用户优惠券记录
            userCoupon = new YD_Event.Core.Entities.UserCoupon
            {
                Id = _idGenerator.NewLong(),
                UserId = userId,
                CouponId = coupon.Id,
                ClaimTime = DateTime.Now,
                Status = 0, // 未使用
                CreatedUserId = userId,
                CreatedTime = DateTime.Now,
                DeleteMark = false
            };
            await _userCouponRepository.InsertAsync(userCoupon);

            // 更新优惠券已领取数量
            coupon.ClaimedQuantity += 1;
            await _couponRepository.UpdateAsync(coupon);
        }

        // 计算优惠金额
        decimal discountAmount = 0;
        decimal finalAmount = input.OriginalAmount;

        // Type: 0-折扣, 1-定额
        if (coupon.Type == 0) // 折扣
        {
            discountAmount = input.OriginalAmount * (1 - coupon.Value / 100);
        }
        else if (coupon.Type == 1) // 定额
        {
            discountAmount = Math.Min(coupon.Value, input.OriginalAmount);
        }

        finalAmount = input.OriginalAmount - discountAmount;
        finalAmount = Math.Max(0, finalAmount); // 确保不小于0

        result.IsValid = true;
        result.CouponId = coupon.Id;
        result.CouponName = coupon.Name ?? "优惠券";
        result.DiscountType = coupon.Type;
        result.DiscountValue = coupon.Value;
        result.DiscountAmount = discountAmount;
        result.FinalAmount = finalAmount;

        return result;
    }

    private string GetRegistrationStatusDesc(int status)
    {
        return status switch
        {
            0 => "待提交",
            1 => "审核中",
            2 => "已报名",
            3 => "审核拒绝",
            4 => "已取消",
            _ => "未知"
        };
    }

    /// <summary>
    /// 验证队员是否符合报名条件
    /// </summary>
    [DisplayName("验证队员")]
    [HttpPost("member/validate")]
    public async Task<MemberValidateOutput> ValidateMember([FromBody] MemberValidateInput input)
    {
        var result = new MemberValidateOutput
        {
            IsValid = true,
            AgeValid = true,
            GenderValid = true,
            RegistrationLimitValid = true,
            Message = "验证通过"
        };

        var member = await _userRepository.GetByIdAsync(input.MemberId);
        if (member == null)
        {
            result.IsValid = false;
            result.Message = "队员不存在";
            return result;
        }

        if (!member.BirthDate.HasValue)
        {
            result.IsValid = false;
            result.AgeValid = false;
            result.Message = "队员缺少出生日期信息";
            return result;
        }

        var eventProjectGroup = await _eventProjectGroupRepository.GetByIdAsync(input.GroupId);
        if (eventProjectGroup != null)
        {
            var projectGroup = await _projectGroupRepository.GetByIdAsync(eventProjectGroup.ProjectGroupId);
            
            // 优先使用EventProjectGroup中保存的信息，如果没有则使用原始ProjectGroup的信息
            var birthDateStart = eventProjectGroup.BirthDateStart != DateTime.MinValue ? eventProjectGroup.BirthDateStart : (projectGroup?.BirthDateStart ?? DateTime.MinValue);
            var birthDateEnd = eventProjectGroup.BirthDateEnd != DateTime.MinValue ? eventProjectGroup.BirthDateEnd : (projectGroup?.BirthDateEnd ?? DateTime.MaxValue);
            var gender = eventProjectGroup.Gender;
            
            var birthDate = member.BirthDate.Value;
            if (birthDate < birthDateStart || birthDate > birthDateEnd)
            {
                result.AgeValid = false;
                result.IsValid = false;
                result.Message = "队员年龄不符合组别要求";
            }

            if (gender != member.Gender && gender != Gender.Unknown && gender != Gender.All)
            {
                result.GenderValid = false;
                result.IsValid = false;
                result.Message = "队员性别不符合组别要求";
            }
        }

        return result;
    }

    /// <summary>
    /// 检查报名限制
    /// </summary>
    [DisplayName("检查报名限制")]
    [HttpPost("registration-limit/check")]
    public async Task<RegistrationLimitCheckOutput> CheckRegistrationLimit([FromBody] RegistrationLimitCheckInput input)
    {
        var result = new RegistrationLimitCheckOutput
        {
            HasLimit = false,
            LimitDetails = new List<RegistrationLimitDetail>()
        };

        var limit = await _limitRepository.GetFirstAsync(x => x.EventId == input.EventId);
        if (limit != null)
        {
            var members = await _userRepository.GetListAsync(x => input.MemberIds.Contains(x.Id));
            foreach (var member in members)
            {
                var registrationPersons = await _registrationPersonRepository.GetListAsync(x => 
                    !x.DeleteMark);

                var matchedPersons = registrationPersons.Where(x => x.IdCard == member.IdCardNumber && !string.IsNullOrEmpty(x.IdCard)).ToList();

                var registrationIds = matchedPersons.Select(x => x.RegistrationId).Distinct().ToList();
                var registrations = await _registrationRepository.GetListAsync(x => 
                    registrationIds.Contains(x.Id) && 
                    x.EventId == input.EventId && 
                    x.RegistrationStatus != 4 &&
                    !x.DeleteMark);

                if (registrations.Count() >= limit.IndividualProjectLimit)
                {
                    result.HasLimit = true;
                    result.LimitDetails.Add(new RegistrationLimitDetail
                    {
                        MemberId = member.Id,
                        MemberName = member.Name ?? member.NickName ?? "未知",
                        LimitType = "IndividualLimit",
                        LimitMessage = $"该队员已报名{registrations.Count()}个项目，达到个人报名限制{limit.IndividualProjectLimit}个"
                    });
                }
            }
        }

        return result;
    }

    /// <summary>
    /// 获取组别可报队伍数量配置
    /// </summary>
    [DisplayName("获取组别队伍限制")]
    [HttpGet("group-team-limit/{eventId}")]
    public async Task<List<GroupTeamLimitOutput>> GetGroupTeamLimit([FromRoute] long eventId)
    {
        var result = new List<GroupTeamLimitOutput>();

        var eventProjectGroups = await _eventProjectGroupRepository.GetListAsync(x => x.EventId == eventId && !x.DeleteMark);

        foreach (var eventProjectGroup in eventProjectGroups)
        {
            var currentTeams = await _registrationItemRepository.AsQueryable()
                .Where(x => x.EventProjectGroupId == eventProjectGroup.Id && !x.DeleteMark)
                .Select(x => x.RegistrationId)
                .Distinct()
                .CountAsync();

            result.Add(new GroupTeamLimitOutput
            {
                GroupId = eventProjectGroup.Id,
                MaxTeams = 2,
                CurrentTeams = currentTeams
            });
        }

        return result;
    }

    /// <summary>
    /// 检查项目完成人数
    /// </summary>
    [DisplayName("检查项目完成人数")]
    [HttpPost("project-completion/check")]
    public async Task<ProjectCompletionCheckOutput> CheckProjectCompletion([FromBody] ProjectCompletionCheckInput input)
    {
        var result = new ProjectCompletionCheckOutput
        {
            HasError = false,
            Errors = new List<ProjectCompletionError>()
        };

        var eventProjects = await _eventProjectRepository.GetListAsync(x => x.EventId == input.EventId);
        var eventProjectGroups = await _eventProjectGroupRepository.GetListAsync(x => x.EventId == input.EventId && !x.DeleteMark);
        var projects = await _projectRepository.GetListAsync(x => eventProjects.Select(ep => ep.ProjectId).Contains(x.Id) && !x.DeleteMark);

        foreach (var eventProject in eventProjects)
        {
            var project = projects.FirstOrDefault(p => p.Id == eventProject.ProjectId);
            if (project == null) continue;

            var projectGroups = eventProjectGroups.Where(g => g.EventProjectId == eventProject.Id).ToList();
            var assignedGroupIds = input.GroupMembers.Select(g => g.GroupId).ToList();
            var assignedProjectGroups = projectGroups.Where(g => assignedGroupIds.Contains(g.Id)).ToList();

            if (assignedProjectGroups.Count == 0)
            {
                continue;
            }

            var totalAssignedMembers = input.GroupMembers
                .Where(g => assignedProjectGroups.Select(pg => pg.Id).Contains(g.GroupId))
                .SelectMany(g => g.MemberIds)
                .Distinct()
                .Count();

            if (project.CompletionCount > 0)
            {
                if (totalAssignedMembers < project.CompletionCount)
                {
                    result.HasError = true;
                    result.Errors.Add(new ProjectCompletionError
                    {
                        ProjectId = eventProject.Id,
                        ProjectName = project.Name ?? "未知项目",
                        ErrorType = "Insufficient",
                        ErrorMessage = $"项目\"{project.Name}\"要求完成人数为{project.CompletionCount}人，当前只分配了{totalAssignedMembers}人"
                    });
                }
                else if (totalAssignedMembers > project.CompletionCount)
                {
                    result.HasError = true;
                    result.Errors.Add(new ProjectCompletionError
                    {
                        ProjectId = eventProject.Id,
                        ProjectName = project.Name ?? "未知项目",
                        ErrorType = "Excessive",
                        ErrorMessage = $"项目\"{project.Name}\"要求完成人数为{project.CompletionCount}人，当前分配了{totalAssignedMembers}人，人数超额"
                    });
                }
            }
        }

        return result;
    }

    /// <summary>
    /// 计算赛事报名费用
    /// </summary>
    /// <param name="input">费用计算输入</param>
    /// <returns>费用计算结果</returns>
    private async Task<FeeCalculationResult> CalculateFeeAsync(FeeCalculationInput input)
    {
        _logger.LogInformation("开始计算费用，赛事ID: {EventId}, 项目数: {ProjectCount}, 人数: {ParticipantCount}",
            input.EventId, input.EventProjectIds.Count, input.ParticipantCount);

        // 获取赛事费用配置
        var feeConfig = await _feeConfigRepository.GetFirstAsync(x => x.EventId == input.EventId);
        if (feeConfig == null)
        {
            _logger.LogWarning("未找到赛事费用配置，赛事ID: {EventId}", input.EventId);
            var freeResult = new FeeCalculationResult
            {
                ChargeMode = "免费",
                TotalAmount = 0,
                TotalPersonCount = input.ParticipantCount
            };
            freeResult.CalculationLogs.Add($"[{DateTime.Now:yyyy-MM-dd HH:mm:ss}] 未找到费用配置，默认免费");
            return freeResult;
        }

        // 获取项目信息（用于单价项目模式）
        var eventProjects = await _eventProjectRepository.GetListAsync(x => input.EventProjectIds.Contains(x.Id));
        var projectIds = eventProjects.Select(x => x.ProjectId).Distinct().ToList();
        var baseProjects = await _projectRepository.GetListAsync(x => projectIds.Contains(x.Id));

        // 构建统一计算服务的输入参数
        var pricingInput = new EventPricingService.PricingInput
        {
            ChargeMode = feeConfig.ChargeMode,
            ParticipantCount = input.ParticipantCount
        };

        // 添加项目信息
        foreach (var eventProject in eventProjects)
        {
            var baseProject = baseProjects.FirstOrDefault(p => p.Id == eventProject.ProjectId);
            pricingInput.Projects.Add(new EventPricingService.ProjectPricingInfo
            {
                ProjectId = eventProject.ProjectId,
                ProjectName = baseProject?.Name ?? "未知项目",
                UnitPrice = eventProject.Price / 100m
            });
        }

        // 使用统一计算服务计算费用
        var pricingResult = EventPricingService.Calculate(pricingInput);

        // 转换为现有格式的结果
        var result = new FeeCalculationResult
        {
            ChargeMode = GetChargeModeDescription(feeConfig.ChargeMode),
            TotalAmount = pricingResult.TotalAmount,
            TotalPersonCount = pricingResult.TotalPersonCount,
            CalculationLogs = pricingResult.CalculationLogs
        };

        // 转换费用明细
        foreach (var detail in pricingResult.Details)
        {
            result.FeeDetails.Add(new FeeDetailItem
            {
                ItemName = detail.ItemName,
                UnitPrice = detail.UnitPrice,
                Quantity = detail.Quantity,
                Subtotal = detail.Subtotal,
                Remark = detail.Remark
            });
        }

        _logger.LogInformation("费用计算完成，总金额: {TotalAmount:F2} 元", result.TotalAmount);
        return result;
    }

    /// <summary>
    /// 获取收费模式描述
    /// </summary>
    private string GetChargeModeDescription(ChargeMode mode)
    {
        return mode switch
        {
            ChargeMode.Free => "免费",
            ChargeMode.FixedPrice => "定价（赛事）",
            ChargeMode.UnitPriceEvent => "单价（赛事）",
            ChargeMode.UnitPriceProject => "单价（项目）",
            _ => "未知模式"
        };
    }

}