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

        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("团队不存在");

        // 验证：一次报名只能选择单个团队内的运动员
        if (input.MemberIds != null && input.MemberIds.Count > 0)
        {
            var teamMembers = await _db.Queryable<YD_Event.Core.Entities.TeamMember>()
                .Where(tm => input.MemberIds.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 = input.MemberIds.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 => 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));
        
        // 构建统一报名输入
        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 groupMembersList = members.Where(m => groupMember.MemberIds.Contains(m.Id)).ToList();
                if (!groupMembersList.Any()) continue;

                unifiedInput.Items.Add(new UnifiedRegistrationItemInput
                {
                    ProjectId = eventProjectGroup.EventProjectId,
                    GroupId = groupMember.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()
                });
            }
        }

        // 调用统一报名服务
        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("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;
            }
        }
        
        // 处理新旧两种数据结构
        List<GroupMemberAssignment> groupMembersList;
        if (input.GroupMembers != null && input.GroupMembers.Any())
        {
            // 新结构：使用 GroupMembers
            groupMembersList = input.GroupMembers;
        }
        else if (input.MemberIds != null && input.MemberIds.Any() && input.GroupIds != null && input.GroupIds.Any())
        {
            // 旧结构：将 MemberIds 和 GroupIds 转换为 GroupMembers
            // 旧结构假设所有队员分配到所有组别
            groupMembersList = input.GroupIds.Select(groupId => new GroupMemberAssignment
            {
                GroupId = groupId,
                MemberIds = input.MemberIds
            }).ToList();
        }
        else
        {
            throw Oops.Bah("请提供组别队员分配信息");
        }
        
        // 获取所有成员ID
        var allMemberIds = groupMembersList.SelectMany(gm => gm.MemberIds).Distinct().ToList();
        
        // 获取成员信息
        var members = await _userRepository.GetListAsync(x => allMemberIds.Contains(x.Id));
        
        // 获取组别信息
        var groupIds = groupMembersList.Select(gm => gm.GroupId).ToList();
        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 groupMembersList)
        {
            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 membersInGroup = members.Where(m => groupMember.MemberIds.Contains(m.Id)).ToList();
            
            // 构建人员列表
            var persons = membersInGroup.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(new UnifiedRegistrationItemInput
            {
                ProjectId = eventProject.Id,
                GroupId = groupMember.GroupId,
                GroupName = eventProjectGroup.GroupName,
                Persons = persons
            });
        }
        
        // 调用统一报名服务检查限制
        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 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 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 => "单价（项目）",
            _ => "未知模式"
        };
    }

}