using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using AdminService.GameConfigs;
using AdminService.User;
using AdminService.User.Param;
using AdminService.User.Response;
using Common;
using Common.Utils;
using CommonDomain;
using CommonDomain.BaseModel;
using CommonDomain.Enum;
using CommonInfrastructure;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using RedisService;
using UserDomain.Entity;

namespace AdminApi.AdminUser
{
    [ApiController, Route("adminapi/[controller]")]
    [Authorize]
    public class AdminUserController : BaseController
    {
        private readonly IAdminUserService _userService;
        private readonly IRedisService _redisService;

        public AdminUserController(IAdminUserService userService, IRedisService redisService)
        {
            _userService = userService;
            _redisService = redisService;
        }

        /// <summary>
        /// 获取用户列表（管理员专用，增强版）
        /// </summary>
        [HttpPost("GetUserList")]
        public async Task<PageResponse<UserListItemDto>> GetUserList(AdminUserListParam param)
        {
            var result = await _userService.GetAdminUserList(param);
            var onlineUserIds = _redisService.GetAllLoginUserIds().ToHashSet(StringComparer.Ordinal);
            var dtos = (result.list ?? new List<UserEntity>()).Select(u =>
            {
                var dto = MapToUserListItemDto(u);
                dto.IsOnline = onlineUserIds.Contains(u.Id);
                if (dto.CurrentGameType != 3)
                {
                    var session = _redisService.GetRedisUserCId(u.Id);
                    if (session == null || string.IsNullOrWhiteSpace(session.RoomId))
                    {
                        dto.CurrentGameType = 0;
                        dto.RoomNumber = "";
                    }
                }
                return dto;
            }).ToList();
            return this.ToPageResult(dtos, result.count);
        }

        /// <summary>
        /// 获取用户详情
        /// </summary>
        [HttpGet("GetUserDetail")]
        public async Task<BaseResponse<UserEntity>> GetUserDetail(string userId)
        {
            var result = await _userService.GetUser(userId);
            if (result == null)
                return this.ToFailResult<UserEntity>("用户不存在");

            return this.ToResult(result);
        }

        /// <summary>
        /// 修改用户资产
        /// </summary>
        [HttpPost("UpdateUserAssets")]
        public async Task<BaseResponse<string>> UpdateUserAssets(UpdateUserAssetsParam param)
        {
            var result = await _userService.UpdateUserAssets(param);
            if (result.isok)
                return this.ToResult(result.msg);
            else
                return this.ToFailResult<string>(result.msg);
        }

        /// <summary>
        /// 获取用户统计数据
        /// </summary>
        [HttpGet("GetUserStatistics")]
        public async Task<BaseResponse<UserStatisticsDto>> GetUserStatistics()
        {
            var result = await _userService.GetUserStatistics();
            return this.ToResult(MapToUserStatisticsDto(result));
        }

        /// <summary>
        /// 获取邮件统计数据
        /// </summary>
        [HttpGet("GetEmailStatistics")]
        public async Task<BaseResponse<EmailStatisticsDto>> GetEmailStatistics()
        {
            var result = await _userService.GetEmailStatistics();
            return this.ToResult(MapToEmailStatisticsDto(result));
        }

        /// <summary>
        /// 批量封号
        /// </summary>
        [HttpPost("BatchBanUser")]
        public async Task<BaseResponse<string>> BatchBanUser(BatchBanUserParam param)
        {
            var result = await _userService.BatchBanUser(param);
            if (result.isok)
                return this.ToResult(result.msg);
            else
                return this.ToFailResult<string>(result.msg);
        }

        /// <summary>
        /// 解封用户
        /// </summary>
        [HttpGet("UnbanUser")]
        public async Task<BaseResponse<string>> UnbanUser(string userId)
        {
            var result = await _userService.UnbanUser(userId);
            if (result.isok)
                return this.ToResult(result.msg);
            else
                return this.ToFailResult<string>(result.msg);
        }

        /// <summary>
        /// 批量发送邮件
        /// </summary>
        [HttpPost("BatchSendEmail")]
        public async Task<BaseResponse<string>> BatchSendEmail(BatchSendEmailParam param)
        {
            var result = await _userService.BatchSendEmail(param);
            if (result.isok)
                return this.ToResult(result.msg);
            else
                return this.ToFailResult<string>(result.msg);
        }

        /// <summary>
        /// 注销用户
        /// </summary>
        [HttpGet("CancelUser")]
        [Authorize]
        public async Task<BaseResponse<string>> CancelUser()
        {
            var result = await _userService.CancelUser(loginUser);
            if (result.isok)
                return this.ToResult(result.msg);
            else
                return this.ToFailResult<string>(result.msg);
        }

        /// <summary>
        /// 删除用户
        /// </summary>
        [HttpGet("DeleteUser")]
        [Authorize]
        public async Task<BaseResponse<string>> DeleteUser(string id)
        {
            var result = await _userService.DeleteUser(id);
            if (result.isok)
                return this.ToResult(result.msg);
            else
                return this.ToFailResult<string>(result.msg);
        }

        /// <summary>
        /// 批量删除用户
        /// </summary>
        [HttpPost("BatchDeleteUser")]
        [Authorize]
        public async Task<BaseResponse<string>> BatchDeleteUser([FromBody] BatchDeleteUserParam param)
        {
            var result = await _userService.BatchDeleteUser(param.UserIds);
            if (result.isok)
                return this.ToResult(result.msg);
            else
                return this.ToFailResult<string>(result.msg);
        }

        /// <summary>
        /// 封号
        /// </summary>
        [HttpPost("BanUser")]
        [Authorize]
        public async Task<BaseResponse<string>> BanUser([FromBody] BanUserParam param)
        {
            var result = await _userService.BanUser(param.UserId, param.Reason, param.Days);
            if (result.isok)
                return this.ToResult(result.msg);
            else
                return this.ToFailResult<string>(result.msg);
        }

        /// <summary>
        /// 更新用户信息
        /// </summary>
        [HttpPost("UpdateUser")]
        [Authorize]
        public async Task<BaseResponse<string>> UpdateUser(UpdateUserDataParam param)
        {
            var result = await _userService.UpdateUser(param);
            if (result.isok)
                return this.ToResult(result.msg);
            else
                return this.ToFailResult<string>(result.msg);
        }

        /// <summary>
        /// 发送邮件
        /// </summary>
        [HttpPost("SendEmail")]
        [Authorize]
        public async Task<BaseResponse<string>> SendEmail(SendEmailParam param)
        {
            var result = await _userService.SendEmail(param, loginUser);
            if (result.isok)
                return this.ToResult(result.msg);
            else
                return this.ToFailResult<string>(result.msg);
        }

        /// <summary>
        /// 分页查询邮件列表
        /// </summary>
        [HttpPost("GetEmailList")]
        [Authorize]
        public async Task<PageResponse<EmailListItemDto>> GetEmailList([FromBody] EmailListQueryParam param)
        {
            var (list, count) = await _userService.GetEmailList(param);
            var userIds = list.Where(e => !string.IsNullOrWhiteSpace(e.UserId))
                .Select(e => e.UserId).Distinct().ToList();
            var userNames = await _userService.GetEmailUserNamesAsync(userIds);
            var dtos = list.Select(e =>
            {
                userNames.TryGetValue(e.UserId ?? "", out var info);
                return new EmailListItemDto
                {
                    Id = e.Id,
                    UserId = e.UserId ?? "",
                    UserName = info.UserName,
                    UserNumber = info.UserNumber,
                    Title = e.Title ?? "",
                    IsRead = e.IsRead,
                    IsReward = e.IsReward,
                    RewardGold = e.RewardGold,
                    RewardDiamond = e.RewardDiamond,
                    SendTime = e.SendTime,
                    ReadTime = e.ReadTime,
                    ExpireTime = e.ExpireTime,
                    RewardText = BuildRewardText(e)
                };
            }).ToList();
            return this.ToPageResult(dtos, (int)count);
        }

        /// <summary>
        /// 删除邮件
        /// </summary>
        [HttpGet("DeleteEmail")]
        [Authorize]
        public async Task<BaseResponse<string>> DeleteEmail(string id)
        {
            var result = await _userService.DeleteEmail(id);
            if (result.ok)
                return this.ToResult("删除成功");
            else
                return this.ToFailResult<string>(result.message ?? "删除失败");
        }

        /// <summary>
        /// 批量删除邮件
        /// </summary>
        [HttpPost("BatchDeleteEmail")]
        [Authorize]
        public async Task<BaseResponse<string>> BatchDeleteEmail([FromBody] List<string> ids)
        {
            var (success, fail) = await _userService.BatchDeleteEmail(ids);
            if (fail == 0)
                return this.ToResult($"成功删除 {success} 条");
            return this.ToResult($"删除完成：成功 {success} 条，失败 {fail} 条");
        }

        /// <summary>
        /// 设置用户类型
        /// </summary>
        [HttpPost("SetUserType")]
        public async Task<BaseResponse<string>> SetUserType(string userId, int userType)
        {
            var result = await _userService.SetUserType(userId, userType);
            if (result.isok)
                return this.ToResult(result.msg);
            else
                return this.ToFailResult<string>(result.msg);
        }

        /// <summary>
        /// 批量设置用户类型
        /// </summary>
        [HttpPost("BatchSetUserType")]
        public async Task<BaseResponse<string>> BatchSetUserType([FromBody] BatchSetUserTypeParam param)
        {
            var result = await _userService.BatchSetUserType(param.UserIds, param.UserType);
            if (result.isok)
                return this.ToResult(result.msg);
            else
                return this.ToFailResult<string>(result.msg);
        }

        /// <summary>
        /// 设置屏蔽状态
        /// </summary>
        [HttpPost("SetBlackUser")]
        public async Task<BaseResponse<string>> SetBlackUser(string userId, bool isBlack)
        {
            var result = await _userService.SetBlackUser(userId, isBlack);
            if (result.isok)
                return this.ToResult(result.msg);
            else
                return this.ToFailResult<string>(result.msg);
        }

        /// <summary>
        /// 批量设置屏蔽状态
        /// </summary>
        [HttpPost("BatchSetBlackUser")]
        public async Task<BaseResponse<string>> BatchSetBlackUser([FromBody] BatchSetBlackUserParam param)
        {
            var result = await _userService.BatchSetBlackUser(param.UserIds, param.IsBlack);
            if (result.isok)
                return this.ToResult(result.msg);
            else
                return this.ToFailResult<string>(result.msg);
        }

        /// <summary>
        /// 更新用户因子
        /// </summary>
        [HttpPost("UpdateUserFactor")]
        public async Task<BaseResponse<string>> UpdateUserFactor([FromBody] UpdateUserFactorFlatParam param)
        {
            var factor = new PlayerFactor
            {
                ViolateValue = param.ViolateValue,
                MissRate = param.MissRate,
                CompensateQuota = param.CompensateQuota,
                PenaltyQuota = param.PenaltyQuota,
                CompensateRate = param.CompensateRate,
                PenaltyRate = param.PenaltyRate,
                AdditionalFactor = param.AdditionalFactor
            };
            var result = await _userService.UpdateUserFactor(param.UserId, factor);
            if (result.isok)
                return this.ToResult(result.msg);
            else
                return this.ToFailResult<string>(result.msg);
        }

        /// <summary>
        /// 获取屏蔽用户因子配置
        /// </summary>
        [HttpGet("GetBlackFactorConfig")]
        public async Task<BaseResponse<PlayerFactorDto>> GetBlackFactorConfig()
        {
            var result = await _userService.GetBlackFactorConfig();
            return this.ToResult(MapToPlayerFactorDto(result));
        }

        /// <summary>
        /// 重置用户因子为默认值
        /// </summary>
        [HttpPost("ResetUserFactor")]
        public async Task<BaseResponse<string>> ResetUserFactor(string userId)
        {
            var result = await _userService.ResetUserFactor(userId);
            if (result.isok)
                return this.ToResult(result.msg);
            else
                return this.ToFailResult<string>(result.msg);
        }

        /// <summary>
        /// 初始化用户密码为123456
        /// </summary>
        [HttpGet("InitUserPassword")]
        public async Task<BaseResponse<string>> InitUserPassword([FromQuery] string userId)
        {
            var result = await _userService.InitUserPassword(userId);
            if (result.isok)
                return this.ToResult(result.msg);
            else
                return this.ToFailResult<string>(result.msg);
        }

        /// <summary>
        /// 初始化保险箱密码为123456
        /// </summary>
        [HttpGet("InitSafeBoxPassword")]
        public async Task<BaseResponse<string>> InitSafeBoxPassword([FromQuery] string userId)
        {
            var result = await _userService.InitSafeBoxPassword(userId);
            if (result.isok)
                return this.ToResult(result.msg);
            else
                return this.ToFailResult<string>(result.msg);
        }

        /// <summary>
        /// 获取用户因子列表
        /// </summary>
        [HttpPost("GetUserFactorList")]
        public async Task<PageResponse<UserFactorListItemDto>> GetUserFactorList([FromBody] UserFactorListParam param)
        {
            var result = await _userService.GetUserFactorList(param);

            var pageIps = (result.list ?? new List<UserEntity>())
                .Where(u => !string.IsNullOrEmpty(u.RegisterIp))
                .Select(u => u.RegisterIp!)
                .Distinct()
                .ToList();

            Dictionary<string, int> ipCounts = new Dictionary<string, int>();
            if (pageIps.Count > 0)
            {
                var allUsersWithSameIp = await _userService.GetUsersByRegisterIps(pageIps);
                ipCounts = allUsersWithSameIp
                    .GroupBy(u => u.RegisterIp)
                    .ToDictionary(g => g.Key, g => g.Count());
            }

            var dtos = (result.list ?? new List<UserEntity>()).Select(u => new UserFactorListItemDto
            {
                Id = u.Id,
                Number = u.BaseInfo?.Number ?? "",
                UserName = u.BaseInfo?.UserName ?? "",
                Mobile = u.BaseInfo?.Mobile ?? "",
                UserType = u.UserType,
                RegisterIp = u.RegisterIp ?? "",
                LoginIp = u.Static?.LastLoginIp ?? "",
                IpCount = !string.IsNullOrEmpty(u.RegisterIp) && ipCounts.ContainsKey(u.RegisterIp) ? ipCounts[u.RegisterIp] : 1,
                IsBlack = u.PlayerFactor?.IsBlack ?? false,
                ViolateValue = u.PlayerFactor?.ViolateValue ?? 0.2,
                MissRate = u.PlayerFactor?.MissRate ?? 0,
                CompensateQuota = u.PlayerFactor?.CompensateQuota ?? 0,
                PenaltyQuota = u.PlayerFactor?.PenaltyQuota ?? 0,
                CompensateRate = u.PlayerFactor?.CompensateRate != null ? new CompensateRateDto
                {
                    BossRate = u.PlayerFactor.CompensateRate.BossRate,
                    GoldRate = u.PlayerFactor.CompensateRate.GoldRate,
                    SpecialRate = u.PlayerFactor.CompensateRate.SpecialRate,
                    Ordinary = u.PlayerFactor.CompensateRate.Ordinary
                } : new CompensateRateDto(),
                PenaltyRate = u.PlayerFactor?.PenaltyRate != null ? new PenaltyRateDto
                {
                    BossRate = u.PlayerFactor.PenaltyRate.BossRate,
                    GoldRate = u.PlayerFactor.PenaltyRate.GoldRate,
                    SpecialRate = u.PlayerFactor.PenaltyRate.SpecialRate,
                    Ordinary = u.PlayerFactor.PenaltyRate.Ordinary
                } : new PenaltyRateDto(),
                CreateTime = u.CreateTime,
                TotalRecharge = u.Static?.TotalRecharge ?? 0,
                TotalRechargeGold = u.Static?.TotalRechargeGold ?? 0,
                TotalConsumeGold = u.Static?.TotalConsumeGold ?? 0,
                CurrentGold = u.Assets?.Gold ?? 0,
                Profit = (u.Assets?.Gold ?? 0) - ((u.Static?.TotalRechargeGold ?? 0) + (u.PlayerFactor?.StartingBonus ?? 0)),
                AdditionalFactor = u.PlayerFactor?.AdditionalFactor ?? 0,
                StartingBonus = u.PlayerFactor?.StartingBonus ?? 0
            });
            return this.ToPageResult(dtos, result.count);
        }


        private static UserListItemDto MapToUserListItemDto(UserEntity entity)
        {
            return new UserListItemDto
            {
                Id = entity.Id,
                Number = entity.BaseInfo?.Number ?? "",
                NickName = entity.BaseInfo?.UserName ?? "",
                Avatar = entity.BaseInfo?.AvatarUrl ?? "",
                Mobile = entity.BaseInfo?.Mobile ?? "",
                Diamond = entity.Assets?.Diamond ?? 0,
                Gold = entity.Assets?.Gold ?? 0,
                SafeBoxGold = entity.SafeBox?.Amount ?? 0,
                VipLevel = entity.Assets?.VipLevel ?? 0,
                UserType = entity.UserType,
                IsBan = entity.BanInfo?.IsBan ?? false,
                BanReason = entity.BanInfo?.BanReason,
                BanEndTime = entity.BanInfo?.BanEndTime ?? 0,
                IsBlack = entity.PlayerFactor?.IsBlack ?? false,
                RegisterTime = entity.CreateTime,
                RegisterIp = entity.RegisterIp ?? "",
                LastLoginIp = entity.Static?.LastLoginIp ?? "",
                LastLoginTime = entity.Static?.LastLoginTime ?? 0,
                RoomNumber = entity.Static?.RoomNumber ?? "",
                CurrentGameType = entity.Static?.CurrentGameType ?? 0,
                Channel = entity.BaseInfo?.Channel ?? "",
                TotalRecharge = (long)(entity.Static?.TotalRecharge ?? 0)
            };
        }

        private static UserStatisticsDto MapToUserStatisticsDto(UserStatistics stat)
        {
            return new UserStatisticsDto
            {
                TotalUsers = stat.TotalUsers,
                TodayRegisteredUsers = stat.TodayRegisteredUsers,
                MonthRegisteredUsers = stat.MonthRegisteredUsers,
                OnlineUsers = stat.OnlineUsers,
                BannedUsers = stat.BannedUsers,
                VipUsers = stat.VipUsers,
                VipLevelCount = stat.VipLevelCount ?? new Dictionary<int, long>(),
                TotalGold = stat.TotalGold,
                TotalDiamond = stat.TotalDiamond
            };
        }

        private static EmailStatisticsDto MapToEmailStatisticsDto(EmailStatistics stat)
        {
            return new EmailStatisticsDto
            {
                TotalEmails = stat.TotalEmails,
                RewardEmails = stat.RewardEmails,
                UnclaimedEmails = stat.UnclaimedEmails,
                TodayEmails = stat.TodayEmails,
                MonthEmails = stat.MonthEmails
            };
        }

        private static PlayerFactorDto MapToPlayerFactorDto(PlayerFactor factor)
        {
            if (factor == null)
                return new PlayerFactorDto();

            return new PlayerFactorDto
            {
                IsBlack = factor.IsBlack,
                IsIgnore = factor.IsIgnore,
                ViolateValue = factor.ViolateValue,
                CompensateRate = factor.CompensateRate?.BossRate ?? 1,
                PenaltyRate = factor.PenaltyRate?.BossRate ?? 0,
                CompensateQuota = factor.CompensateQuota,
                PenaltyQuota = factor.PenaltyQuota,
                StartingBonus = factor.StartingBonus
            };
        }

        private static string BuildRewardText(UserEmail email)
        {
            var parts = new List<string>();
            if (email.RewardGold > 0)
                parts.Add($"金币{email.RewardGold:N0}");
            if (email.RewardDiamond > 0)
                parts.Add($"钻石{email.RewardDiamond}");
            if (email.RewardItems != null)
            {
                foreach (var item in email.RewardItems)
                {
                    if (item != null && !string.IsNullOrWhiteSpace(item.Name))
                        parts.Add($"{item.Name}*{item.Count}");
                }
            }
            return parts.Count > 0 ? string.Join(" ", parts) : "无";
        }



        /// <summary>
        /// 获取用户背包道具
        /// </summary>
        [HttpGet("GetUserProps")]
        public async Task<BaseResponse<List<BaseProductCount>>> GetUserProps(string userId)
        {
            var result = await _userService.GetUserProps(userId);
            return this.ToResult(result);
        }

        /// <summary>
        /// 添加用户背包道具
        /// </summary>
        [HttpPost("AddUserProp")]
        public async Task<BaseResponse<string>> AddUserProp(string userId, string propNumber, int count)
        {
            var res = await _userService.AddUserProp(userId, propNumber, count);
            if (res.isok) return this.ToResult(res.msg);
            return this.ToFailResult<string>(res.msg);
        }

        /// <summary>
        /// 修改用户道具数量（数量设为0则删除）
        /// </summary>
        [HttpPost("UpdateUserPropCount")]
        public async Task<BaseResponse<string>> UpdateUserPropCount(string userId, string propNumber, int count)
        {
            var res = await _userService.UpdateUserPropCount(userId, propNumber, count);
            if (res.isok) return this.ToResult(res.msg);
            return this.ToFailResult<string>(res.msg);
        }

        /// <summary>
        /// 删除用户道具
        /// </summary>
        [HttpPost("DeleteUserProp")]
        public async Task<BaseResponse<string>> DeleteUserProp(string userId, string propNumber)
        {
            var res = await _userService.DeleteUserProp(userId, propNumber);
            if (res.isok) return this.ToResult(res.msg);
            return this.ToFailResult<string>(res.msg);
        }

        /// <summary>
        /// 同步所有玩家的等级（根据经验值+充值重新计算）
        /// </summary>
        [HttpGet("SyncAllUserLevel")]
        public async Task<BaseResponse<string>> SyncAllUserLevel()
        {
            var (total, updated, msg) = await _userService.SyncAllUserLevel();
            return this.ToResult(msg);
        }

    }


    public class UserListItemDto
    {
        public string Id { get; set; }
        public string Number { get; set; }
        public string NickName { get; set; }
        public string Avatar { get; set; }
        public string Mobile { get; set; }
        public int Diamond { get; set; }
        public long Gold { get; set; }
        public long SafeBoxGold { get; set; }
        public int VipLevel { get; set; }
        public int UserType { get; set; }
        public bool IsBan { get; set; }
        public string BanReason { get; set; }
        public long BanEndTime { get; set; }
        public bool IsBlack { get; set; }
        public long RegisterTime { get; set; }
        public string RegisterIp { get; set; }
        public string LastLoginIp { get; set; }
        public long LastLoginTime { get; set; }
        public string RoomNumber { get; set; }
        public int CurrentGameType { get; set; }
        public bool IsOnline { get; set; }
        public string Channel { get; set; }
        public long TotalRecharge { get; set; }
    }

    public class UserStatisticsDto
    {
        public long TotalUsers { get; set; }
        public long TodayRegisteredUsers { get; set; }
        public long MonthRegisteredUsers { get; set; }
        public long OnlineUsers { get; set; }
        public long BannedUsers { get; set; }
        public long VipUsers { get; set; }
        public Dictionary<int, long> VipLevelCount { get; set; }
        public long TotalGold { get; set; }
        public long TotalDiamond { get; set; }
    }

    public class EmailStatisticsDto
    {
        public long TotalEmails { get; set; }
        public long RewardEmails { get; set; }
        public long UnclaimedEmails { get; set; }
        public long TodayEmails { get; set; }
        public long MonthEmails { get; set; }
    }

    public class PlayerFactorDto
    {
        public bool IsBlack { get; set; }
        public bool IsIgnore { get; set; }
        public double ViolateValue { get; set; }
        public double CompensateRate { get; set; }
        public double PenaltyRate { get; set; }
        public int CompensateQuota { get; set; }
        public int PenaltyQuota { get; set; }
        public long StartingBonus { get; set; }
    }

    public class UserFactorListItemDto
    {
        public string Id { get; set; }
        public string Number { get; set; }
        public string UserName { get; set; }
        public string Mobile { get; set; }
        public int UserType { get; set; }
        public string RegisterIp { get; set; }
        public string LoginIp { get; set; }
        public int IpCount { get; set; }
        public bool IsBlack { get; set; }
        public double ViolateValue { get; set; }
        public double MissRate { get; set; }
        public int CompensateQuota { get; set; }
        public int PenaltyQuota { get; set; }
        public CompensateRateDto CompensateRate { get; set; }
        public PenaltyRateDto PenaltyRate { get; set; }
        public long CreateTime { get; set; }
        public double TotalRecharge { get; set; }
        public long TotalRechargeGold { get; set; }
        public long TotalConsumeGold { get; set; }
        public long CurrentGold { get; set; }
        public long Profit { get; set; }
        public double AdditionalFactor { get; set; }
        public long StartingBonus { get; set; }
    }

    public class CompensateRateDto
    {
        public double BossRate { get; set; } = 1;
        public double GoldRate { get; set; } = 1;
        public double SpecialRate { get; set; } = 1;
        public double Ordinary { get; set; } = 1;
    }

    public class PenaltyRateDto
    {
        public double BossRate { get; set; } = 1;
        public double GoldRate { get; set; } = 1;
        public double SpecialRate { get; set; } = 1;
        public double Ordinary { get; set; } = 1;
    }

    public class BanUserParam
    {
        public string UserId { get; set; } = "";

        public string Reason { get; set; } = "";

        public int Days { get; set; } = 0;
    }

    public class EmailListItemDto
    {
        public string Id { get; set; } = "";
        public string UserId { get; set; } = "";
        public string UserName { get; set; } = "";
        public string UserNumber { get; set; } = "";
        public string Title { get; set; } = "";
        public bool IsRead { get; set; }
        public bool IsReward { get; set; }
        public long RewardGold { get; set; }
        public int RewardDiamond { get; set; }
        public long SendTime { get; set; }
        public long ReadTime { get; set; }
        public long ExpireTime { get; set; }
        public string RewardText { get; set; } = "";
    }

}