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 YD_Event.Core.Domain.Pricing.Models;
using YD_Event.Core.Domain;
using YD_Event.Core.Extensions;
using Easy.Core;
using SqlSugar;
using Mapster;
using YD_Event.Application.Auth;
using Furion.DynamicApiController;
using Microsoft.AspNetCore.Mvc;
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<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<PointsRuleDetail> _pointsRuleDetailRepository;
    private readonly ISqlSugarRepository<RefundConfig> _refundConfigRepository;
    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 ISqlSugarRepository<YD_Event.Core.Entities.CouponRedemptionCode> _redemptionCodeRepository;
    private readonly ISqlSugarRepository<EventRegistrationPayment> _paymentRepository;
    private readonly ILogger<UserEventRegistrationService> _logger;
    private readonly OrderNoGeneratorService _orderNoGeneratorService;
    private readonly UnifiedRegistrationService _unifiedRegistrationService;

    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<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<PointsRuleDetail> pointsRuleDetailRepository,
        ISqlSugarRepository<RefundConfig> refundConfigRepository,
        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,
        ISqlSugarRepository<YD_Event.Core.Entities.CouponRedemptionCode> redemptionCodeRepository,
        ISqlSugarRepository<EventRegistrationPayment> paymentRepository,
        ILogger<UserEventRegistrationService> logger,
        OrderNoGeneratorService orderNoGeneratorService,
        UnifiedRegistrationService unifiedRegistrationService)
    {
        _eventRepository = eventRepository;
        _unitRepository = unitRepository;
        _eventProjectRepository = eventProjectRepository;
        _eventProjectGroupRepository = eventProjectGroupRepository;
        _projectGroupRepository = projectGroupRepository;
        _projectLimitRepository = projectLimitRepository;
        _projectRepository = projectRepository;
        _registrationRepository = registrationRepository;
        _registrationItemRepository = registrationItemRepository;
        _registrationPersonRepository = registrationPersonRepository;
        _userRepository = userRepository;
        _sysUserRepository = sysUserRepository;
        _feeConfigRepository = feeConfigRepository;
        _limitRepository = limitRepository;
        _pointsRuleRepository = pointsRuleRepository;
        _pointsRuleDetailRepository = pointsRuleDetailRepository;
        _refundConfigRepository = refundConfigRepository;
        _orderRepository = orderRepository;
        _weChatPayConfigRepository = weChatPayConfigRepository;
        _merchantRepository = merchantRepository;
        _db = db;
        _authManager = authManager;
        _idGenerator = idGenerator;
        _weChatPayService = weChatPayService;
        _wechatTenpayClientOptionsMonitor = wechatTenpayClientOptionsMonitor;
        _httpContextAccessor = httpContextAccessor;
        _projectService = projectService;
        _couponRepository = couponRepository;
        _userCouponRepository = userCouponRepository;
        _redemptionCodeRepository = redemptionCodeRepository;
        _paymentRepository = paymentRepository;
        _logger = logger;
        _orderNoGeneratorService = orderNoGeneratorService;
        _unifiedRegistrationService = unifiedRegistrationService;
    }

    /// <summary>
    /// 根据出生日期计算年龄
    /// </summary>
    /// <param name="birthDate">出生日期</param>
    /// <returns>年龄</returns>
    private static int CalculateAge(DateTime? birthDate)
    {
        if (!birthDate.HasValue) return 0;
        var today = DateTime.Today;
        var age = today.Year - birthDate.Value.Year;
        if (birthDate.Value.Date > today.AddYears(-age)) age--;
        return age;
    }

    /// <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;
        
        // 直接赋值 int 类型
        output.Type = (int)eventInfo.EventType;
        output.RegistrationType = (int)eventInfo.RegistrationType;
        
        // 设置赛事状态
        output.EventStatus = eventInfo.EventStatus;
        
        output.IsNeedMaterial = eventInfo.IsNeedMaterial;
        output.MaterialRemark = eventInfo.MaterialRemark;
        output.MaterialUploadEndTime = eventInfo.MaterialUploadEndTime;

        // 查询省市区名称
        if (eventInfo.ProvinceId.HasValue)
        {
            var province = await _db.Queryable<SysProvince>().FirstAsync(x => x.Id == eventInfo.ProvinceId.Value && !x.DeleteMark);
            output.ProvinceName = province?.ProvinceName ?? "";
        }
        if (eventInfo.CityId.HasValue)
        {
            var city = await _db.Queryable<SysCity>().FirstAsync(x => x.Id == eventInfo.CityId.Value && !x.DeleteMark);
            output.CityName = city?.CityName ?? "";
        }
        if (eventInfo.DistrictId.HasValue)
        {
            var district = await _db.Queryable<SysDistrict>().FirstAsync(x => x.Id == eventInfo.DistrictId.Value && !x.DeleteMark);
            output.DistrictName = district?.DistrictName ?? "";
        }

        if (eventInfo.PointsRuleId.HasValue)
        {
            var rule = await _pointsRuleRepository.GetByIdAsync(eventInfo.PointsRuleId.Value);
            output.PointsRuleName = rule?.RuleName ?? "";
            
            if (rule != null)
            {
                var details = await _pointsRuleDetailRepository.AsQueryable()
                    .Where(d => d.PointsRuleId == rule.Id && !d.DeleteMark)
                    .OrderBy(d => d.StartRank)
                    .ToListAsync();
                
                output.PointsRuleDetail = new YD_Event.Application.Client.Dtos.PointsRuleDto
                {
                    RuleName = rule.RuleName,
                    ParticipationPoints = rule.ParticipationPoints,
                    Remark = rule.Remark,
                    Details = details.Select(d => new YD_Event.Application.Client.Dtos.PointsRuleDetailDto
                    {
                        StartRank = d.StartRank,
                        EndRank = d.EndRank,
                        Points = d.Points
                    }).ToList()
                };
            }
        }
        
        // 获取退款规则
        var refundConfigs = await _refundConfigRepository.AsQueryable()
            .Where(c => c.Status == AvailabilityStatus.Enable && !c.DeleteMark)
            .OrderBy(c => c.DayStart)
            .ToListAsync();
        
        output.RefundRules = refundConfigs.Select(c => new YD_Event.Application.Event.Dtos.RefundRuleDto
        {
            DayStart = c.DayStart,
            DayEnd = c.DayEnd,
            DeductPercentage = c.DeductPercentage,
            Remark = c.Remark
        }).ToList();

        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)
    {
        var feeConfig = new UserEventFeeOutput
        {
            ChargeMode = (int)fee.ChargeMode,
            Price = fee.Price
        };

        // 如果赛事有关联的商户ID，查询并填充商户信息
        if (eventInfo.MerchantId.HasValue)
        {
            var merchant = await _merchantRepository.GetByIdAsync(eventInfo.MerchantId.Value);
            if (merchant != null && merchant.Status == AvailabilityStatus.Enable)
            {
                feeConfig.MerchantName = merchant.MerchantName;
                feeConfig.CreditCode = merchant.CreditCode;
                feeConfig.BankName = merchant.BankName;
                feeConfig.AccountNumber = merchant.AccountNumber;
            }
        }

        output.FeeConfig = feeConfig;
    }

        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));

        output.Projects = eventProjects.Select(ep => 
        {
            var p = baseProjects.FirstOrDefault(b => b.Id == ep.ProjectId);

            var dto = new UserEventProjectListOutput
            {
                Id = ep.Id,
                Name = p?.Name ?? "",
                Fee = ep.Price,
                CompletionCount = p?.CompletionCount ?? 0
            };

            if (p != null)
            {
                dto.ProjectTypeName = p.ProjectType.Description();
            }

            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 = (int)eg.Gender
                };
            }).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 = GetPaymentStatusDesc(registration.PaymentStatus);
        }
        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));

        return eventProjects.Select(ep => 
        {
            var p = baseProjects.FirstOrDefault(b => b.Id == ep.ProjectId);

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

            if (p != null)
            {
                dto.ProjectTypeName = p.ProjectType.Description();
            }

            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 = (int)eg.Gender
                };
            }).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("赛事不存在");

        // 获取团队信息
        var team = await _db.Queryable<YD_Event.Core.Entities.Team>().FirstAsync(t => t.Id == input.TeamId && !t.DeleteMark);
        if (team == null) throw Oops.Bah("团队不存在");

        // 收集所有成员ID
        var allMemberIds = new List<long>();
        if (input.GroupMembers != null)
        {
            foreach (var gm in input.GroupMembers)
            {
                // 检查是否有多团队数据
                if (gm.Teams != null && gm.Teams.Count > 0)
                {
                    foreach (var t in gm.Teams)
                    {
                        allMemberIds.AddRange(t.MemberIds ?? new List<long>());
                    }
                }
                else
                {
                    // 向后兼容单团队模式
                    allMemberIds.AddRange(gm.MemberIds ?? new List<long>());
                }
            }
        }
        else if (input.MemberIds != null)
        {
            // 向后兼容旧结构
            allMemberIds.AddRange(input.MemberIds);
        }
        
        allMemberIds = allMemberIds.Distinct().ToList();

        // 验证：一次报名只能选择单个团队内的运动员
        if (allMemberIds.Count > 0)
        {
            var teamMembers = await _db.Queryable<YD_Event.Core.Entities.TeamMember>()
                .Where(tm => allMemberIds.Contains(tm.UserId))
                .Where(tm => !tm.DeleteMark)
                .ToListAsync();

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

            var userTeamMap = teamMembers
                .GroupBy(tm => tm.UserId)
                .ToDictionary(g => g.Key, g => g.Select(tm => tm.TeamId).ToList());

            var missingUsers = allMemberIds.Except(userTeamMap.Keys).ToList();
            if (missingUsers.Any())
            {
                throw Oops.Bah("部分队员未找到团队信息");
            }

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

        // 获取成员信息
        var members = await _userRepository.GetListAsync(x => allMemberIds.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));
        
        // 构建统一报名输入
        var unifiedInput = new UnifiedRegistrationInput
        {
            EventId = input.EventId,
            RegistrationMode = 2, // PC端只做团队报名
            TeamName = team.Name,
            ContactName = userName,
            ContactPhone = userMobile,
            Items = new List<UnifiedRegistrationItemInput>(),
            CreatedUserId = userId,
            IsDraft = input.IsDraft
        };

        // 填充项目和人员信息
        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 item = new UnifiedRegistrationItemInput
                {
                    ProjectId = eventProjectGroup.EventProjectId,
                    GroupId = groupMember.GroupId,
                    GroupName = eventProjectGroup.GroupName,
                    Teams = new List<UnifiedTeamInput>(),
                    Persons = new List<UnifiedPersonInput>()
                };
                
                // 检查是多团队模式还是单团队模式
                var hasMultipleTeams = groupMember.Teams != null && groupMember.Teams.Count > 0;
                
                if (hasMultipleTeams)
                {
                    // ========== 多团队模式 ==========
                    foreach (var t in groupMember.Teams)
                    {
                        var teamMembersList = members.Where(m => t.MemberIds != null && t.MemberIds.Contains(m.Id)).ToList();
                        item.Teams.Add(new UnifiedTeamInput
                        {
                            TeamIndex = t.TeamIndex,
                            Persons = teamMembersList.Select(m => new UnifiedPersonInput
                            {
                                UserId = m.Id,
                                Name = m.Name ?? "",
                                IdCardNumber = m.IdCardNumber ?? "",
                                Gender = m.Gender,
                                Mobile = m.Mobile,
                                BirthDate = m.BirthDate ?? DateTime.MinValue
                            }).ToList()
                        });
                    }
                }
                else
                {
                    // ========== 单团队模式（向后兼容） ==========
                    var groupMembersList = members.Where(m => groupMember.MemberIds != null && groupMember.MemberIds.Contains(m.Id)).ToList();
                    if (!groupMembersList.Any()) continue;
                    
                    item.Persons = groupMembersList.Select(m => new UnifiedPersonInput
                    {
                        UserId = m.Id,
                        Name = m.Name ?? "",
                        IdCardNumber = m.IdCardNumber ?? "",
                        Gender = m.Gender,
                        Mobile = m.Mobile,
                        BirthDate = m.BirthDate ?? DateTime.MinValue
                    }).ToList();
                }
                
                unifiedInput.Items.Add(item);
            }
        }

        // 调用统一报名服务
        var result = await _unifiedRegistrationService.ProcessRegistrationAsync(unifiedInput);
        return result.RegistrationId;
    }

    /// <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 userId = _authManager.UserId;
        
        // 获取报名信息和赛事信息
        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("赛事不存在");

        // 确定支付方式类型（优先使用新的 PaymentMethodType，如果没有则向后兼容旧的 PaymentMethod）
        PaymentMethodType paymentMethodType;
        if (input.PaymentMethodType != PaymentMethodType.None)
        {
            paymentMethodType = input.PaymentMethodType;
        }
        else if (input.PaymentMethod > 0)
        {
            // 向后兼容：将旧的 PaymentMethod 转换为 PaymentMethodType
            paymentMethodType = (PaymentMethodType)input.PaymentMethod;
        }
        else
        {
            throw Oops.Bah("请选择支付方式");
        }

        // 确定支付方式（线上/线下）
        int paymentMethod;
        if (paymentMethodType == PaymentMethodType.WeChatPay || paymentMethodType == PaymentMethodType.AliPay)
        {
            paymentMethod = 2; // 线上支付
        }
        else if (paymentMethodType == PaymentMethodType.BankTransfer)
        {
            paymentMethod = 1; // 线下支付
        }
        else
        {
            throw Oops.Bah("不支持的支付方式");
        }

        // 构建统一支付输入
        var unifiedInput = new UnifiedPaymentInput
        {
            RegistrationId = input.RegistrationId,
            PaymentMethod = paymentMethod,
            PaymentMethodType = paymentMethodType,
            CouponId = input.CouponId,
            OpenId = input.OpenId,
            OperatorUserId = userId
        };

        // 调用统一支付处理服务
        var unifiedResult = await _unifiedRegistrationService.ProcessPaymentAsync(unifiedInput);

        // 转换结果
        var result = new UserPaymentResultOutput
        {
            OrderNo = unifiedResult.OrderNo,
            Status = unifiedResult.PaymentStatus,
            IsFree = unifiedResult.IsFree,
            PayUrl = unifiedResult.QrcodeUrl ?? string.Empty,
            QrcodeUrl = unifiedResult.QrcodeUrl,
            WechatPayParams = unifiedResult.WechatPayParams,
            TradeType = unifiedResult.TradeType
        };

        // 如果是线下支付，获取收款商户信息
        if (paymentMethodType == PaymentMethodType.BankTransfer && eventInfo.MerchantId.HasValue)
        {
            var merchant = await _merchantRepository.GetByIdAsync(eventInfo.MerchantId.Value);
            if (merchant != null)
            {
                result.PayeeMerchantName = merchant.MerchantName;
                result.PayeeAccountInfo = !string.IsNullOrEmpty(merchant.BankName) && !string.IsNullOrEmpty(merchant.AccountNumber)
                    ? $"{merchant.BankName} {merchant.AccountNumber}"
                    : null;
            }
        }

        return result;
    }

    /// <summary>
    /// 确认银行转账
    /// </summary>
    [DisplayName("确认银行转账")]
    [HttpPost("bank-transfer/confirm")]
    [UnitOfWork]
    public async Task<ConfirmBankTransferOutput> ConfirmBankTransfer([FromBody] ConfirmBankTransferInput input)
    {
        var userId = _authManager.UserId;
        
        _logger.LogInformation("用户确认银行转账，报名ID：{RegistrationId}，用户ID：{UserId}", input.RegistrationId, userId);

        // 调用统一报名服务处理确认转账
        var result = await _unifiedRegistrationService.ConfirmBankTransferAsync(input, userId);

        return result;
    }

    /// <summary>
    /// 微信支付回调
    /// </summary>
    [DisplayName("微信支付回调")]
    [HttpPost("wechat/notify")]
    [AllowAnonymous]
    [UnitOfWork]
    [NonUnify]
    public async Task<IActionResult> WechatPayNotify()
    {
        try
        {
            _logger.LogInformation("========== 收到微信支付回调请求 ==========");
            
            using var reader = new StreamReader(_httpContextAccessor.HttpContext.Request.Body);
            var body = await reader.ReadToEndAsync();
            
            _logger.LogInformation("微信支付回调 - 请求Body: {Body}", body);
            
            var headers = _httpContextAccessor.HttpContext.Request.Headers;
            var timestamp = headers["Wechatpay-Timestamp"].FirstOrDefault();
            var nonce = headers["Wechatpay-Nonce"].FirstOrDefault();
            var signature = headers["Wechatpay-Signature"].FirstOrDefault();
            var serialNumber = headers["Wechatpay-Serial"].FirstOrDefault();

            _logger.LogInformation("微信支付回调 - 头部参数: Timestamp={Timestamp}, Nonce={Nonce}, SerialNumber={SerialNumber}",
                timestamp, nonce, serialNumber);

            if (string.IsNullOrEmpty(timestamp) || string.IsNullOrEmpty(nonce) || 
                string.IsNullOrEmpty(signature) || string.IsNullOrEmpty(serialNumber))
            {
                _logger.LogWarning("微信支付回调通知参数不完整");
                return new JsonResult(new { code = "FAIL", message = "参数不完整" });
            }

            var platformPayConfig = await _unifiedRegistrationService.GetPlatformWeChatPayConfigAsync();
            if (platformPayConfig == null)
            {
                _logger.LogError("未找到平台级别的微信支付配置");
                return new JsonResult(new { code = "FAIL", message = "支付配置未找到" });
            }

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

            _logger.LogInformation("微信支付回调 - 开始验证签名");
            var isValid = await _weChatPayService.VerifyPayNotifyAsync(platformPayConfig, notifyRequest);
            if (!isValid)
            {
                _logger.LogWarning("微信支付回调签名验证失败");
                return new JsonResult(new { code = "FAIL", message = "签名验证失败" });
            }
            _logger.LogInformation("微信支付回调 - 签名验证成功");

            _logger.LogInformation("微信支付回调 - 开始解密数据");
            var notifyData = await _weChatPayService.DecryptPayNotifyDataAsync(platformPayConfig, notifyRequest);
            
            if (notifyData == null)
            {
                _logger.LogWarning("微信支付回调数据解密失败或为空");
                return new JsonResult(new { code = "SUCCESS", message = "成功" });
            }

            _logger.LogInformation("微信支付回调 - 解密成功: OutTradeNo={OutTradeNo}, TradeState={TradeState}, TransactionId={TransactionId}",
                notifyData.OutTradeNo, notifyData.TradeState, notifyData.TransactionId);

            if (notifyData.TradeState != "SUCCESS")
            {
                _logger.LogWarning("微信支付回调交易未成功，TradeState={TradeState}", notifyData.TradeState);
                return new JsonResult(new { code = "SUCCESS", message = "成功" });
            }

            _logger.LogInformation("微信支付回调 - 开始处理支付成功逻辑，订单号：{OutTradeNo}", notifyData.OutTradeNo);
            
            // 调用统一支付成功处理方法
            await _unifiedRegistrationService.HandlePaymentSuccessAsync(
                notifyData.OutTradeNo, 
                notifyData.TransactionId, 
                notifyData.SuccessTime?.DateTime, 
                0);

            _logger.LogInformation("微信支付回调 - 支付成功处理完成，订单号：{OutTradeNo}", notifyData.OutTradeNo);
            _logger.LogInformation("========== 微信支付回调处理完成 ==========");
            
            return new JsonResult(new { code = "SUCCESS", message = "成功" });
        }
        catch (ArgumentException ex)
        {
            _logger.LogError(ex, "处理微信支付回调通知时参数验证失败");
            return new JsonResult(new { code = "FAIL", message = "业务验证失败" });
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "处理微信支付回调通知异常");
            return new JsonResult(new { code = "FAIL", message = "处理失败" });
        }
    }

    /// <summary>
    /// 查询订单支付状态
    /// </summary>
    [DisplayName("查询订单支付状态")]
    [HttpGet("order/status/{orderNo}")]
    public async Task<int> QueryOrderStatus([FromRoute] string orderNo)
    {
        var query = _orderRepository.AsQueryable()
            .LeftJoin<EventRegistration>((o, r) => o.RegistrationId == r.Id)
            .Where((o, r) => o.OrderNo == orderNo)
            .Select((o, r) => new { Order = o, Registration = r });
        
        var orderInfo = await query.FirstAsync();
        if (orderInfo == null || orderInfo.Order == null) throw Oops.Bah("订单不存在");

        if (orderInfo.Order.OrderStatus == OrderStatus.Paid)
        {
            _logger.LogInformation("查询订单支付状态 - 订单已支付，订单号：{OrderNo}", orderNo);
            return 1; // 已支付
        }

        // 检查是否是微信/支付宝支付（线上支付）
        bool isOnlinePayment = orderInfo.Registration?.PaymentMethod == 2 || 
                              orderInfo.Registration?.PaymentMethodType == PaymentMethodType.WeChatPay ||
                              orderInfo.Registration?.PaymentMethodType == PaymentMethodType.AliPay;

        _logger.LogInformation("查询订单支付状态 - 订单号：{OrderNo}，PaymentMethod={PaymentMethod}，PaymentMethodType={PaymentMethodType}，IsOnlinePayment={IsOnlinePayment}",
            orderNo, orderInfo.Registration?.PaymentMethod, orderInfo.Registration?.PaymentMethodType, isOnlinePayment);

        if (isOnlinePayment)
        {
            WeChatPayConfig? payConfig = null;
            if (orderInfo.Order.MerchantId.HasValue)
            {
                payConfig = await _weChatPayConfigRepository.GetFirstAsync(x => 
                    x.MerchantId == orderInfo.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)
            {
                _logger.LogInformation("查询订单支付状态 - 调用微信支付查询接口，订单号：{OrderNo}", orderNo);
                var queryResult = await _weChatPayService.QueryOrderAsync(payConfig, orderNo);
                _logger.LogInformation("查询订单支付状态 - 微信支付查询结果，订单号：{OrderNo}，Success={Success}，TradeState={TradeState}",
                    orderNo, queryResult.Success, queryResult.TradeState);

                if (queryResult.Success && queryResult.TradeState == "SUCCESS")
                {
                    orderInfo.Order.OrderStatus = OrderStatus.Paid;
                    orderInfo.Order.PaymentTime = queryResult.SuccessTime?.DateTime;
                    if (queryResult.PayerAmount.HasValue)
                    {
                        orderInfo.Order.ActualAmount = queryResult.PayerAmount.Value / 100m;
                    }
                    await _orderRepository.UpdateAsync(orderInfo.Order);

                    var registration = await _registrationRepository.GetByIdAsync(orderInfo.Order.RegistrationId);
                    if (registration != null && registration.PaymentStatus != 1)
                    {
                        registration.PaymentStatus = 1;
                        await _registrationRepository.UpdateAsync(registration);
                    }
                    _logger.LogInformation("查询订单支付状态 - 订单已更新为已支付，订单号：{OrderNo}", orderNo);
                    return 1;
                }
            }
            else
            {
                _logger.LogWarning("查询订单支付状态 - 未找到微信支付配置，订单号：{OrderNo}", orderNo);
            }
        }

        return 0; // 未支付
    }

    /// <summary>
    /// 验证优惠券
    /// </summary>
    [DisplayName("验证优惠券")]
    [HttpPost("coupon/validate")]
    public async Task<ValidateCouponOutput> ValidateCoupon([FromBody] ValidateCouponInput input)
    {
        var userId = _authManager.UserId;

        return await _unifiedRegistrationService.ValidateAndUseCouponAsync(input, userId);
    }

    private string GetPaymentStatusDesc(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 eventProject = await _eventProjectRepository.GetByIdAsync(eventProjectGroup.EventProjectId);
            var baseProject = eventProject != null ? await _projectRepository.GetByIdAsync(eventProject.ProjectId) : null;
            var isTeamProject = baseProject?.IsTeamProject() ?? false;

            // 创建单个队员的验证输入
            var persons = new List<UnifiedPersonInput>
            {
                new UnifiedPersonInput
                {
                    UserId = member.Id,
                    Name = member.Name ?? "",
                    IdCardNumber = member.IdCardNumber ?? "",
                    Gender = member.Gender,
                    Mobile = member.Mobile,
                    BirthDate = member.BirthDate.Value
                }
            };

            // 使用统一的验证方法进行验证
            var validationResult = _unifiedRegistrationService.ValidatePersonQualifications(persons, eventProjectGroup, isTeamProject);
            
            if (!validationResult.IsValid)
            {
                result.IsValid = false;
                result.Message = validationResult.ErrorMessage ?? "验证失败";
                
                // 根据验证详情设置具体的验证状态
                var ageDetail = validationResult.Details?.FirstOrDefault(d => d.ItemName == "年龄验证" || d.ItemName == "年龄跨组验证");
                var genderDetail = validationResult.Details?.FirstOrDefault(d => d.ItemName == "性别验证");
                
                if (ageDetail != null && !ageDetail.IsPassed)
                {
                    result.AgeValid = false;
                }
                
                if (genderDetail != null && !genderDetail.IsPassed)
                {
                    result.GenderValid = false;
                }
            }
        }

        return result;
    }

    /// <summary>
    /// 检查报名限制
    /// </summary>
    [DisplayName("检查报名限制")]
    [HttpPost("registration-limit/check")]
    public async Task<RegistrationLimitCheckOutput> CheckRegistrationLimit([FromBody] RegistrationLimitCheckInput 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 ?? "";
        
        // 获取团队信息 - 优先使用新结构的 TeamId
        string teamName = "临时团队";
        if (input.TeamId.HasValue)
        {
            var team = await _db.Queryable<YD_Event.Core.Entities.Team>().FirstAsync(t => t.Id == input.TeamId.Value && !t.DeleteMark);
            if (team != null)
            {
                teamName = team.Name;
            }
        }
        
        // 获取所有成员信息
        var allMemberIds = new List<long>();
        if (input.GroupMembers != null)
        {
            foreach (var gm in input.GroupMembers)
            {
                // 检查是否有多团队数据
                if (gm.Teams != null && gm.Teams.Count > 0)
                {
                    foreach (var team in gm.Teams)
                    {
                        allMemberIds.AddRange(team.MemberIds ?? new List<long>());
                    }
                }
                else
                {
                    // 向后兼容单团队模式
                    allMemberIds.AddRange(gm.MemberIds ?? new List<long>());
                }
            }
        }
        else if (input.MemberIds != null)
        {
            // 向后兼容旧结构
            allMemberIds.AddRange(input.MemberIds);
        }
        
        allMemberIds = allMemberIds.Distinct().ToList();
        
        // 获取成员信息
        var members = await _userRepository.GetListAsync(x => allMemberIds.Contains(x.Id));
        
        // 获取组别信息
        var groupIds = input.GroupMembers?.Select(g => g.GroupId).ToList() ?? input.GroupIds ?? new List<long>();
        var eventProjectGroups = await _eventProjectGroupRepository.GetListAsync(x => groupIds.Contains(x.Id));
        
        // 获取项目信息
        var eventProjectIds = eventProjectGroups.Select(epg => epg.EventProjectId).Distinct().ToList();
        var eventProjects = await _eventProjectRepository.GetListAsync(x => eventProjectIds.Contains(x.Id));
        
        // 构建统一报名输入
        var unifiedInput = new UnifiedRegistrationInput
        {
            EventId = input.EventId,
            RegistrationMode = 2, // PC端团队报名
            TeamName = teamName,
            ContactName = userName,
            ContactPhone = userMobile,
            CreatedUserId = userId,
            IsDraft = false,
            Items = new List<UnifiedRegistrationItemInput>()
        };
        
        // 为每个组别添加项目项
        foreach (var groupMember in input.GroupMembers ?? new List<GroupMemberAssignment>())
        {
            var eventProjectGroup = eventProjectGroups.FirstOrDefault(epg => epg.Id == groupMember.GroupId);
            if (eventProjectGroup == null) continue;
            
            var eventProject = eventProjects.FirstOrDefault(ep => ep.Id == eventProjectGroup.EventProjectId);
            if (eventProject == null) continue;
            
            var item = new UnifiedRegistrationItemInput
            {
                ProjectId = eventProject.Id,
                GroupId = groupMember.GroupId,
                GroupName = eventProjectGroup.GroupName,
                Teams = new List<UnifiedTeamInput>(),
                Persons = new List<UnifiedPersonInput>()
            };
            
            // 检查是多团队模式还是单团队模式
            var hasMultipleTeams = groupMember.Teams != null && groupMember.Teams.Count > 0;
            
            if (hasMultipleTeams)
            {
                // ========== 多团队模式 ==========
                foreach (var team in groupMember.Teams)
                {
                    var teamMembers = members.Where(m => team.MemberIds != null && team.MemberIds.Contains(m.Id)).ToList();
                    item.Teams.Add(new UnifiedTeamInput
                    {
                        TeamIndex = team.TeamIndex,
                        Persons = teamMembers.Select(m => new UnifiedPersonInput
                        {
                            UserId = m.Id,
                            Name = m.Name ?? "",
                            IdCardNumber = m.IdCardNumber ?? "",
                            Gender = m.Gender,
                            Mobile = m.Mobile,
                            BirthDate = m.BirthDate ?? DateTime.MinValue
                        }).ToList()
                    });
                }
            }
            else
            {
                // ========== 单团队模式（向后兼容） ==========
                var groupMembersList = members.Where(m => groupMember.MemberIds != null && groupMember.MemberIds.Contains(m.Id)).ToList();
                item.Persons = groupMembersList.Select(m => new UnifiedPersonInput
                {
                    UserId = m.Id,
                    Name = m.Name ?? "",
                    IdCardNumber = m.IdCardNumber ?? "",
                    Gender = m.Gender,
                    Mobile = m.Mobile,
                    BirthDate = m.BirthDate ?? DateTime.MinValue
                }).ToList();
            }
            
            unifiedInput.Items.Add(item);
        }
        
        // 处理旧结构（向后兼容）
        if ((input.GroupMembers == null || !input.GroupMembers.Any()) && input.GroupIds != null && input.MemberIds != null)
        {
            foreach (var groupId in input.GroupIds)
            {
                var eventProjectGroup = eventProjectGroups.FirstOrDefault(epg => epg.Id == groupId);
                if (eventProjectGroup == null) continue;
                
                var eventProject = eventProjects.FirstOrDefault(ep => ep.Id == eventProjectGroup.EventProjectId);
                if (eventProject == null) continue;
                
                var groupMembersList = members.Where(m => input.MemberIds.Contains(m.Id)).ToList();
                
                unifiedInput.Items.Add(new UnifiedRegistrationItemInput
                {
                    ProjectId = eventProject.Id,
                    GroupId = groupId,
                    GroupName = eventProjectGroup.GroupName,
                    Persons = groupMembersList.Select(m => new UnifiedPersonInput
                    {
                        UserId = m.Id,
                        Name = m.Name ?? "",
                        IdCardNumber = m.IdCardNumber ?? "",
                        Gender = m.Gender,
                        Mobile = m.Mobile,
                        BirthDate = m.BirthDate ?? DateTime.MinValue
                    }).ToList()
                });
            }
        }
        
        // 调用统一报名服务检查限制
        return await _unifiedRegistrationService.CheckRegistrationLimitAsync(unifiedInput);
    }

    /// <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);
        
        // 获取该赛事的项目级限报配置
        var projectLimits = await _projectLimitRepository.GetListAsync(x => x.EventId == eventId && !x.DeleteMark);
        
        // 获取所有赛事项目，用于关联 ProjectId
        var eventProjects = await _eventProjectRepository.GetListAsync(x => x.EventId == eventId);

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

            // 查找该组别的项目限报配置
            var eventProject = eventProjects.FirstOrDefault(ep => ep.Id == eventProjectGroup.EventProjectId);
            var projectLimit = projectLimits.FirstOrDefault(pl => pl.ProjectId == eventProject?.Id);
            var maxTeams = projectLimit?.LimitCount ?? 2; // 默认2队

            result.Add(new GroupTeamLimitOutput
            {
                GroupId = eventProjectGroup.Id,
                MaxTeams = maxTeams,
                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 isTeamProject = project.IsTeamProject();
            
            // 对每个分配的组别进行独立验证
            foreach (var assignedGroup in assignedProjectGroups)
            {
                // 找到该组别的队员分配
                var groupMemberAssignment = input.GroupMembers.FirstOrDefault(gm => gm.GroupId == assignedGroup.Id);
                if (groupMemberAssignment == null) continue;

                // ========== 关键修改：支持多团队模式 ==========
                // 检查是多团队模式还是单团队模式
                var hasMultipleTeams = groupMemberAssignment.Teams != null && groupMemberAssignment.Teams.Count > 0;
                
                if (hasMultipleTeams && isTeamProject)
                {
                    // ========== 多团队模式验证 ==========
                    // 验证每个团队的人数是否等于 CompletionCount
                    foreach (var team in groupMemberAssignment.Teams)
                    {
                        var teamMemberCount = team.MemberIds?.Distinct().Count() ?? 0;
                        
                        // 如果该团队没有选择任何人员，跳过验证
                        if (teamMemberCount == 0) continue;
                        
                        // 验证该团队的人数是否等于 CompletionCount
                        if (project.CompletionCount > 0 && teamMemberCount != project.CompletionCount)
                        {
                            string errorMessage;
                            if (teamMemberCount < project.CompletionCount)
                            {
                                errorMessage = $"团队{team.TeamIndex}参赛人数错误（少{project.CompletionCount - teamMemberCount}人）";
                            }
                            else
                            {
                                errorMessage = $"团队{team.TeamIndex}参赛人数错误（多{teamMemberCount - project.CompletionCount}人）";
                            }

                            result.HasError = true;
                            result.Errors.Add(new ProjectCompletionError
                            {
                                ProjectId = eventProject.Id,
                                ProjectName = project.Name ?? "未知项目",
                                ErrorType = teamMemberCount < project.CompletionCount ? "Insufficient" : "Excessive",
                                ErrorMessage = errorMessage
                            });
                        }
                    }
                }
                else
                {
                    // ========== 单团队模式验证（向后兼容） ==========
                    // 计算该组别的分配人数
                    var assignedCount = groupMemberAssignment.MemberIds?.Distinct().Count() ?? 0;
                    
                    // 如果该组别没有选择任何人员，跳过验证
                    if (assignedCount == 0) continue;

                    // 只对团队项目进行完成人数验证
                    if (isTeamProject && project.CompletionCount > 0 && assignedCount != project.CompletionCount)
                    {
                        string errorMessage;
                        if (assignedCount < project.CompletionCount)
                        {
                            errorMessage = $"{project.Name}参赛人数错误（少{project.CompletionCount - assignedCount}人）";
                        }
                        else
                        {
                            errorMessage = $"{project.Name}参赛人数错误（多{assignedCount - project.CompletionCount}人）";
                        }

                        result.HasError = true;
                        result.Errors.Add(new ProjectCompletionError
                        {
                            ProjectId = eventProject.Id,
                            ProjectName = project.Name ?? "未知项目",
                            ErrorType = assignedCount < project.CompletionCount ? "Insufficient" : "Excessive",
                            ErrorMessage = errorMessage
                        });
                    }
                }
            }
        }

        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 PricingInput
        {
            ChargeMode = feeConfig.ChargeMode,
            ParticipantCount = input.ParticipantCount,
            EventPrice = feeConfig.Price
        };

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

        // 使用统一计算服务计算费用
        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 => "单价（项目）",
            _ => "未知模式"
        };
    }

    /// <summary>
    /// 检查组别选择限制
    /// </summary>
    [DisplayName("检查组别选择限制")]
    [HttpPost("check-group-selection-limit")]
    public async Task<CheckGroupSelectionLimitOutput> CheckGroupSelectionLimit([FromBody] CheckGroupSelectionLimitInput input)
    {
        var result = new CheckGroupSelectionLimitOutput
        {
            CanSelect = true
        };

        // 获取组别信息
        var group = await _eventProjectGroupRepository.GetByIdAsync(input.GroupId);
        if (group == null)
        {
            result.CanSelect = false;
            result.LimitMessage = "组别不存在";
            return result;
        }

        // 获取项目信息
        var eventProject = await _eventProjectRepository.GetByIdAsync(group.EventProjectId);
        if (eventProject == null)
        {
            result.CanSelect = false;
            result.LimitMessage = "项目不存在";
            return result;
        }

        // 获取基础项目信息
        var baseProject = await _projectRepository.GetByIdAsync(eventProject.ProjectId);

        // 获取赛事信息获取报名限制
        var eventInfo = await _eventRepository.GetByIdAsync(input.EventId);
        var registrationLimit = eventInfo != null
            ? await _limitRepository.GetFirstAsync(x => x.EventId == input.EventId && !x.DeleteMark)
            : null;

        // 1. 检查组别自身限制（这里暂不实现，因为 EventProjectGroup 实体没有 GroupLimitCount 字段）
        // 后续可以根据实际需求添加相关的限制配置表

        // 2. 检查项目限制
        var selectedGroupIds = input.SelectedGroupIds ?? new List<long>();
        var otherSelectedGroups = await _eventProjectGroupRepository.GetListAsync(x => selectedGroupIds.Contains(x.Id));
        var projectGroups = otherSelectedGroups.Where(g => g.EventProjectId == eventProject.Id).ToList();
        
        // 计算该项目已选的组别数量（排除当前组别）
        var selectedCountForProject = projectGroups.Count;

        // 获取该项目的限报配置
        var projectLimit = await _projectLimitRepository.GetFirstAsync(x =>
            x.EventId == input.EventId && x.ProjectId == eventProject.ProjectId && !x.DeleteMark);

        if (projectLimit != null)
        {
            result.ProjectLimit = new ProjectLimitDetail
            {
                ProjectLimitCount = projectLimit.LimitCount,
                CurrentSelectedCount = selectedCountForProject,
                IsLimitReached = selectedCountForProject >= projectLimit.LimitCount
            };

            if (result.ProjectLimit.IsLimitReached && !selectedGroupIds.Contains(input.GroupId))
            {
                result.CanSelect = false;
                result.LimitMessage = $"该项目最多可报名{projectLimit.LimitCount}个组别";
                return result;
            }
        }

        // 3. 检查团队/个人项目限制
        if (registrationLimit != null && baseProject != null)
        {
            var isTeamProject = baseProject.IsTeamProject();
            var isIndividualProject = baseProject.IsIndividualProject();

            // 计算已选的团队项目和个人项目数量
            var allSelectedEventProjectIds = otherSelectedGroups
                .Where(g => g.Id != input.GroupId)
                .Select(g => g.EventProjectId)
                .Distinct()
                .ToList();

            var allSelectedEventProjects = await _eventProjectRepository.GetListAsync(x => allSelectedEventProjectIds.Contains(x.Id));
            var allSelectedProjectIds = allSelectedEventProjects.Select(ep => ep.ProjectId).Distinct().ToList();
            var allSelectedProjects = await _projectRepository.GetListAsync(x => allSelectedProjectIds.Contains(x.Id));

            var selectedTeamCount = 0;
            var selectedIndividualCount = 0;

            foreach (var selectedProject in allSelectedProjects)
            {
                if (selectedProject.IsTeamProject()) selectedTeamCount++;
                if (selectedProject.IsIndividualProject()) selectedIndividualCount++;
            }

            // 团队项目限制
            if (isTeamProject)
            {
                result.TeamProjectLimit = new EventLimitDetail
                {
                    LimitCount = registrationLimit.TeamProjectLimit,
                    CurrentSelectedCount = selectedTeamCount,
                    IsLimitReached = selectedTeamCount >= registrationLimit.TeamProjectLimit
                };

                if (result.TeamProjectLimit.IsLimitReached && !selectedGroupIds.Contains(input.GroupId))
                {
                    result.CanSelect = false;
                    result.LimitMessage = $"团队项目最多可报名{registrationLimit.TeamProjectLimit}个";
                    return result;
                }
            }

            // 个人项目限制
            if (isIndividualProject)
            {
                result.IndividualProjectLimit = new EventLimitDetail
                {
                    LimitCount = registrationLimit.IndividualProjectLimit,
                    CurrentSelectedCount = selectedIndividualCount,
                    IsLimitReached = selectedIndividualCount >= registrationLimit.IndividualProjectLimit
                };

                if (result.IndividualProjectLimit.IsLimitReached && !selectedGroupIds.Contains(input.GroupId))
                {
                    result.CanSelect = false;
                    result.LimitMessage = $"个人项目最多可报名{registrationLimit.IndividualProjectLimit}个";
                    return result;
                }
            }
        }

        return result;
    }

    /// <summary>
    /// 验证用户是否已报名该赛事
    /// </summary>
    [DisplayName("验证用户报名状态")]
    [HttpPost("registration-status/check")]
    public async Task<CheckRegistrationStatusOutput> CheckRegistrationStatus([FromBody] CheckRegistrationStatusInput input)
    {
        var userId = _authManager.UserId;
        var result = new CheckRegistrationStatusOutput();

        // 查询用户是否已报名该赛事
        var registration = await _registrationRepository.GetFirstAsync(x =>
            x.EventId == input.EventId &&
            x.CreatedUserId == userId &&
            !x.DeleteMark &&
            (
                (x.PaymentMethod == 1 && (x.PaymentStatus == 0 || x.PaymentStatus == 1)) ||
                (x.PaymentMethod == 2 && x.PaymentStatus == 1)
            ));

        if (registration != null)
        {
            result.IsRegistered = true;
            result.RegistrationId = registration.Id;
            result.RegistrationStatus = GetPaymentStatusDesc(registration.PaymentStatus);
            result.Message = "您已报名该赛事，请先取消报名后再重新报名";
        }
        else
        {
            result.IsRegistered = false;
            result.Message = "可以报名";
        }

        return result;
    }

    /// <summary>
    /// 验证用户报名状态输入
    /// </summary>
    public class CheckRegistrationStatusInput
    {
        /// <summary>
        /// 赛事ID
        /// </summary>
        [Required]
        public long EventId { get; set; }
    }

    /// <summary>
    /// 验证用户报名状态输出
    /// </summary>
    public class CheckRegistrationStatusOutput
    {
        /// <summary>
        /// 是否已报名
        /// </summary>
        public bool IsRegistered { get; set; }

        /// <summary>
        /// 报名ID (如果已报名)
        /// </summary>
        public long? RegistrationId { get; set; }

        /// <summary>
        /// 报名状态描述
        /// </summary>
        public string? RegistrationStatus { get; set; }

        /// <summary>
        /// 提示消息
        /// </summary>
        public string? Message { get; set; }
    }
}