wsc

type AccessControl struct {
	MaxMessageSize    int      `mapstructure:"max-message-size" yaml:"max-message-size" json:"maxMessageSize"`          // 最大消息大小(KB)
	BlockedIPs        []string `mapstructure:"blocked-ips" yaml:"blocked-ips" json:"blockedIps"`                        // 黑名单IP
	WhitelistIPs      []string `mapstructure:"whitelist-ips" yaml:"whitelist-ips" json:"whitelistIps"`                  // 白名单IP
	EnableIPWhitelist bool     `mapstructure:"enable-ip-whitelist" yaml:"enable-ip-whitelist" json:"enableIpWhitelist"` // 是否启用IP白名单
}

type AggregatorConfig struct {
	// DrainInterval drain 窗口节拍（默认 500ms）：每窗口 Flush 一次全部群组，产出每群组一条数组帧；窗口越小端到端延迟越低、合帧率越低
	DrainInterval time.Duration `mapstructure:"drain-interval" yaml:"drain-interval" json:"drainInterval"`
	// BatchSize 单群组窗口攒批上限（默认 64 条）：超限新消息直通降级单发；弹幕洪峰场景按 峰值消息速率 × DrainInterval 估算上调
	BatchSize int `mapstructure:"batch-size" yaml:"batch-size" json:"batchSize"`
	// MaxGroups 并发活跃群组数上限（默认 65536）：防群组风暴（恶意/爬虫建群）内存膨胀；空群组在 Flush 换出空批时惰性删除，上限仅约束同时有在途消息的群组数
	MaxGroups int `mapstructure:"max-groups" yaml:"max-groups" json:"maxGroups"`
}

type BatchProcessing struct {
	OfflineMessageBatchSize int `mapstructure:"offline-message-batch-size" yaml:"offline-message-batch-size" json:"offlineMessageBatchSize"` // 离线消息批次大小
	MessagePoolBufferSize   int `mapstructure:"message-pool-buffer-size" yaml:"message-pool-buffer-size" json:"messagePoolBufferSize"`       // 消息池缓冲区大小
	ConnectionBatchSize     int `mapstructure:"connection-batch-size" yaml:"connection-batch-size" json:"connectionBatchSize"`               // 连接记录批量操作大小
}

type BatcherConfig struct {
	MessageStatus   *BatcherParams `mapstructure:"message-status" yaml:"message-status" json:"messageStatus"`       // 消息状态更新（广播万人=1次UPDATE）
	HeartbeatStats  *BatcherParams `mapstructure:"heartbeat-stats" yaml:"heartbeat-stats" json:"heartbeatStats"`    // 心跳统计批量更新
	MessageStats    *BatcherParams `mapstructure:"message-stats" yaml:"message-stats" json:"messageStats"`          // 消息统计批量更新（广播939人=1次事务）
	ObserverNotify  *BatcherParams `mapstructure:"observer-notify" yaml:"observer-notify" json:"observerNotify"`    // 观察者通知批量处理
	ClusterDispatch *BatcherParams `mapstructure:"cluster-dispatch" yaml:"cluster-dispatch" json:"clusterDispatch"` // 跨节点分发批量处理
	ErrorStats      *BatcherParams `mapstructure:"error-stats" yaml:"error-stats" json:"errorStats"`                // 连接错误统计批量更新（断连风暴=1次事务）
}

type BatcherParams struct {
	QueueSize     int           `mapstructure:"queue-size" yaml:"queue-size" json:"queueSize"`             // 队列缓冲大小（channel buffer）
	BatchSize     int           `mapstructure:"batch-size" yaml:"batch-size" json:"batchSize"`             // 每批最大条数，达到即 flush
	FlushInterval time.Duration `mapstructure:"flush-interval" yaml:"flush-interval" json:"flushInterval"` // 定时 flush 间隔
}

type BrokerConsumerParams struct {
	BatchSize     int `mapstructure:"batch-size" yaml:"batch-size" json:"batchSize"`               // 单次批量拉取上限（摊薄 RTT）
	MaxAckPending int `mapstructure:"max-ack-pending" yaml:"max-ack-pending" json:"maxAckPending"` // 在途未 ack 上限（背压闸门，超限暂停拉取）
}

type CapacityEstimation struct {
	// Nodes 预估的节点数量
	// 用于优化 nodes map 的初始容量
	// 默认值：10
	// 建议：根据实际部署规模设置
	//   - 单机部署：1
	//   - 小型集群：3-5
	//   - 中型集群：10-20
	//   - 大型集群：50+
	Nodes int `mapstructure:"nodes" yaml:"nodes" json:"nodes"`

	// Clients 预估的客户端连接数
	// 用于优化内存分配，减少 map 扩容次数
	// 默认值：1000
	// 建议：根据实际业务场景设置
	//   - 小型应用：100-500
	//   - 中型应用：1000-5000
	//   - 大型应用：10000+
	Clients int `mapstructure:"clients" yaml:"clients" json:"clients"`

	// AgentRatio 预估客服连接占比
	// 用于计算 agentClients map 的初始容量
	// 默认值：0.1（10%）
	// 说明：客服通常占总连接数的 5-15%
	AgentRatio float64 `mapstructure:"agent-ratio" yaml:"agent-ratio" json:"agentRatio"`

	// ObserverRatio 预估观察者（管理员）连接占比
	// 用于计算 observerClients map 的初始容量
	// 默认值：0.05（5%）
	// 说明：观察者通常占总连接数的 2-10%
	ObserverRatio float64 `mapstructure:"observer-ratio" yaml:"observer-ratio" json:"observerRatio"`

	// SSERatio 预估 SSE 连接占比
	// 用于计算 sseClients map 的初始容量
	// 默认值：0.1（10%）
	// 说明：SSE 连接通常占总连接数的 5-20%
	SSERatio float64 `mapstructure:"sse-ratio" yaml:"sse-ratio" json:"sseRatio"`
}

type ChannelBuffers struct {
	BroadcastBufferMultiplier   int `mapstructure:"broadcast-buffer-multiplier" yaml:"broadcast-buffer-multiplier" json:"broadcastBufferMultiplier"`         // broadcast通道倍数
	NodeMessageBufferMultiplier int `mapstructure:"node-message-buffer-multiplier" yaml:"node-message-buffer-multiplier" json:"nodeMessageBufferMultiplier"` // nodeMessage通道倍数
}

type ClientAttributes struct {
	// ClientID 提取配置
	ClientIDSources []common.AttributeSource `mapstructure:"client-id-sources" yaml:"client-id-sources" json:"clientIdSources"` // ClientID 提取来源（按优先级排序）

	// UserID 提取配置
	UserIDSources []common.AttributeSource `mapstructure:"user-id-sources" yaml:"user-id-sources" json:"userIdSources"` // UserID 提取来源（按优先级排序）

	// UserType 提取配置
	UserTypeSources []common.AttributeSource `mapstructure:"user-type-sources" yaml:"user-type-sources" json:"userTypeSources"` // UserType 提取来源（按优先级排序）

	// DeviceID 提取配置
	DeviceIdSources []common.AttributeSource `mapstructure:"device-id-sources" yaml:"device-id-sources" json:"deviceIdSources"` // DeviceID 提取来源（按优先级排序）

	// AppID 提取配置（应用ID，最上层隔离维度，默认 "__default_app__"）
	AppIDSources []common.AttributeSource `mapstructure:"app-id-sources" yaml:"app-id-sources" json:"appIdSources"` // AppID 提取来源（按优先级排序）

	// Namespace 提取配置（命名空间隔离，默认 "default"）
	NamespaceSources []common.AttributeSource `mapstructure:"namespace-sources" yaml:"namespace-sources" json:"namespaceSources"` // Namespace 提取来源（按优先级排序）

	// GroupID 提取配置（默认群组，连接后自动加入，为空不自动加入；支持逗号分隔多群组）
	GroupIDSources []common.AttributeSource `mapstructure:"group-id-sources" yaml:"group-id-sources" json:"groupIdSources"` // GroupID 提取来源（按优先级排序）
}

type ClientCapacity struct {
	// 代理：高优先级，消息频率高，不能丢失
	// 预期消息频率：1000+ msg/s
	// 处理延迟：100ms
	// 缓冲消息数：100+
	Agent int `mapstructure:"agent" yaml:"agent" json:"agent"`

	// 机器人：消息频率很高，需要较大缓冲
	// 预期消息频率：100-500 msg/s
	// 处理延迟：100ms
	// 缓冲消息数：10-50
	Bot int `mapstructure:"bot" yaml:"bot" json:"bot"`

	// 普通客户：消息频率中等，中等优先级
	// 预期消息频率：20-80 msg/s
	// 处理延迟：100ms
	// 缓冲消息数：2-8
	Customer int `mapstructure:"customer" yaml:"customer" json:"customer"`

	// 观察者：消息频率低，低优先级，可以丢失
	// 预期消息频率：1-5 msg/s
	// 处理延迟：100ms
	// 缓冲消息数：0-1
	Observer int `mapstructure:"observer" yaml:"observer" json:"observer"`

	// 管理员：高优先级，类似代理
	// 预期消息频率：500+ msg/s
	// 处理延迟：100ms
	// 缓冲消息数：50+
	Admin int `mapstructure:"admin" yaml:"admin" json:"admin"`

	// VIP 客户：高优先级
	// 预期消息频率：100-200 msg/s
	// 处理延迟：100ms
	// 缓冲消息数：10-20
	VIP int `mapstructure:"vip" yaml:"vip" json:"vip"`

	// 访客：低优先级，但可能有突发流量
	// 预期消息频率：10-40 msg/s
	// 处理延迟：100ms
	// 缓冲消息数：1-4
	Visitor int `mapstructure:"visitor" yaml:"visitor" json:"visitor"`

	// 系统消息：高优先级，不能丢失
	// 预期消息频率：100+ msg/s
	// 处理延迟：100ms
	// 缓冲消息数：10+
	System int `mapstructure:"system" yaml:"system" json:"system"`

	// 默认容量：用于未知类型的客户端
	Default int `mapstructure:"default" yaml:"default" json:"default"`
}

type Compensation struct {
	EnableAutoCompensate bool          `mapstructure:"enable-auto-compensate" yaml:"enable-auto-compensate" json:"enableAutoCompensate"` // 是否启用自动补偿
	ScanInterval         time.Duration `mapstructure:"scan-interval" yaml:"scan-interval" json:"scanInterval"`                           // 扫描间隔
	BatchSize            int           `mapstructure:"batch-size" yaml:"batch-size" json:"batchSize"`                                    // 每批处理数量
	MaxConcurrent        int           `mapstructure:"max-concurrent" yaml:"max-concurrent" json:"maxConcurrent"`                        // 最大并发数
	DefaultMaxRetry      int           `mapstructure:"default-max-retry" yaml:"default-max-retry" json:"defaultMaxRetry"`                // 默认最大重试次数
	DefaultRetryInterval int           `mapstructure:"default-retry-interval" yaml:"default-retry-interval" json:"defaultRetryInterval"` // 默认重试间隔(秒)
	DefaultPriority      int           `mapstructure:"default-priority" yaml:"default-priority" json:"defaultPriority"`                  // 默认优先级(1-10)
	LockTimeout          time.Duration `mapstructure:"lock-timeout" yaml:"lock-timeout" json:"lockTimeout"`                              // 锁定超时时间
	CleanupDaysAgo       int           `mapstructure:"cleanup-days-ago" yaml:"cleanup-days-ago" json:"cleanupDaysAgo"`                   // 启动时清理N天前的数据（0表示不清理）
	EnableAutoCleanup    bool          `mapstructure:"enable-auto-cleanup" yaml:"enable-auto-cleanup" json:"enableAutoCleanup"`          // 是否启用自动清理
}

type ConnectionRecord struct {
	CleanupDaysAgo    int  `mapstructure:"cleanup-days-ago" yaml:"cleanup-days-ago" json:"cleanupDaysAgo"`          // 启动时清理N天前的数据（0表示不清理）
	EnableAutoCleanup bool `mapstructure:"enable-auto-cleanup" yaml:"enable-auto-cleanup" json:"enableAutoCleanup"` // 是否启用自动清理
}

type ConnectionToken struct {
	Enabled        bool   `mapstructure:"enabled" yaml:"enabled" json:"enabled"`                          // 是否启用连接 Token（默认 false，向后兼容明文参数方式）
	TokenParamName string `mapstructure:"token-param-name" yaml:"token-param-name" json:"tokenParamName"` // Token 在请求中的参数名（默认 "token"）
	TokenSource    string `mapstructure:"token-source" yaml:"token-source" json:"tokenSource"`            // Token 来源: query, header（默认 query）

	// 密钥与有效期（AES-256-GCM：密钥经 sha256(SigningKey) 派生为 32 字节）
	SigningKey  string        `mapstructure:"signing-key" yaml:"signing-key" json:"signingKey"`    // 加密密钥派生源（生产环境必须配置，任意非空字符串）
	ExpiresTime time.Duration `mapstructure:"expires-time" yaml:"expires-time" json:"expiresTime"` // Token 默认过期时间（仅 Issue 时使用，验证时由载荷加密的 exp 控制，默认 5m）

	// 容错控制
	AllowFallback bool `mapstructure:"allow-fallback" yaml:"allow-fallback" json:"allowFallback"` // Token 解析失败时是否回退到明文参数提取（默认 false，更安全）

	// 多 appid 配置（多租户隔离）
	// 兼容策略：Tokens 为空时使用上方顶层旧字段作为单 Default 配置（向后兼容）
	DefaultAppID string                         `mapstructure:"default-app-id" yaml:"default-app-id" json:"defaultAppId"` // 兜底 appid（claims.aid 为空或未知时使用）
	Tokens       map[string]*ConnectionTokenSet `mapstructure:"tokens" yaml:"tokens" json:"tokens"`                       // 按 appid 索引的多套配置
}

type ConnectionTokenSet struct {
	AppID          string        `mapstructure:"-" yaml:"-" json:"-"`                                            // 由 map key 回填，不参与序列化
	SigningKey     string        `mapstructure:"signing-key" yaml:"signing-key" json:"signingKey"`               // AES-256-GCM 密钥派生源（sha256 派生 32 字节，必填）
	ExpiresTime    time.Duration `mapstructure:"expires-time" yaml:"expires-time" json:"expiresTime"`            // Token 默认过期时间
	TokenSource    string        `mapstructure:"token-source" yaml:"token-source" json:"tokenSource"`            // Token 来源: query, header
	TokenParamName string        `mapstructure:"token-param-name" yaml:"token-param-name" json:"tokenParamName"` // Token 参数名
}

type ConnectionValidation struct {
	// 是否启用连接验证
	Enabled bool `mapstructure:"enabled" yaml:"enabled" json:"enabled"` // 是否启用连接验证（默认: true）

	// 必需参数配置
	RequireUserID   bool `mapstructure:"require-user-id" yaml:"require-user-id" json:"requireUserId"`       // 是否要求 UserID（默认: true）
	RequireUserType bool `mapstructure:"require-user-type" yaml:"require-user-type" json:"requireUserType"` // 是否要求 UserType（默认: true）

	// 错误消息模板
	MissingUserIDMessage   string `mapstructure:"missing-user-id-message" yaml:"missing-user-id-message" json:"missingUserIdMessage"`       // 缺少 UserID 的错误消息
	MissingUserTypeMessage string `mapstructure:"missing-user-type-message" yaml:"missing-user-type-message" json:"missingUserTypeMessage"` // 缺少 UserType 的错误消息
	MissingBothMessage     string `mapstructure:"missing-both-message" yaml:"missing-both-message" json:"missingBothMessage"`               // 同时缺少的错误消息
}

type Database struct {
	Enabled          bool              `mapstructure:"enabled" yaml:"enabled" json:"enabled"`                              // 是否启用数据库持久化
	AutoMigrate      bool              `mapstructure:"auto-migrate" yaml:"auto-migrate" json:"autoMigrate"`                // 是否自动迁移表结构
	TablePrefix      string            `mapstructure:"table-prefix" yaml:"table-prefix" json:"tablePrefix"`                // 表前缀
	LogLevel         string            `mapstructure:"log-level" yaml:"log-level" json:"logLevel"`                         // 日志级别
	SlowThreshold    time.Duration     `mapstructure:"slow-threshold" yaml:"slow-threshold" json:"slowThreshold"`          // 慢查询阈值
	ConnectionRecord *ConnectionRecord `mapstructure:"connection-record" yaml:"connection-record" json:"connectionRecord"` // 连接记录配置
	MessageRecord    *MessageRecord    `mapstructure:"message-record" yaml:"message-record" json:"messageRecord"`          // 消息发送记录配置
	Compensation     *Compensation     `mapstructure:"compensation" yaml:"compensation" json:"compensation"`               // 补偿队列配置
}

type DeadLetterQueue struct {
	Enabled           bool          `mapstructure:"enabled" yaml:"enabled" json:"enabled"`                                 // 是否启用死信队列
	KeyPrefix         string        `mapstructure:"key-prefix" yaml:"key-prefix" json:"keyPrefix"`                         // Redis键前缀
	MaxSize           int64         `mapstructure:"max-size" yaml:"max-size" json:"maxSize"`                               // 队列最大长度
	TTL               time.Duration `mapstructure:"ttl" yaml:"ttl" json:"ttl"`                                             // 过期时间
	MaxRetries        int           `mapstructure:"max-retries" yaml:"max-retries" json:"maxRetries"`                      // 最大重试次数（超过后移入死信队列）
	RetryDelay        time.Duration `mapstructure:"retry-delay" yaml:"retry-delay" json:"retryDelay"`                      // 重试延迟
	WarningThreshold  float64       `mapstructure:"warning-threshold" yaml:"warning-threshold" json:"warningThreshold"`    // 警告阈值（队列长度百分比，如 0.6 表示 60%）
	ErrorThreshold    float64       `mapstructure:"error-threshold" yaml:"error-threshold" json:"errorThreshold"`          // 错误阈值（队列长度百分比，如 0.8 表示 80%）
	CriticalThreshold float64       `mapstructure:"critical-threshold" yaml:"critical-threshold" json:"criticalThreshold"` // 严重阈值（队列长度百分比，如 0.95 表示 95%）
	BatchSize         int           `mapstructure:"batch-size" yaml:"batch-size" json:"batchSize"`                         // 批处理大小
	LockTimeout       time.Duration `mapstructure:"lock-timeout" yaml:"lock-timeout" json:"lockTimeout"`                   // 锁超时时间
	CleanupInterval   time.Duration `mapstructure:"cleanup-interval" yaml:"cleanup-interval" json:"cleanupInterval"`       // 清理间隔
}

type Group struct {
	KeyPrefix string `mapstructure:"key-prefix" yaml:"key-prefix" json:"keyPrefix"` // Redis键前缀
}

type HealthCheck struct {
	// 是否启用健康检查端点
	Enabled bool `mapstructure:"enabled" yaml:"enabled" json:"enabled"` // 是否启用健康检查（默认: true）

	// 健康检查参数名
	QueryParamName string `mapstructure:"query-param-name" yaml:"query-param-name" json:"queryParamName"` // 健康检查查询参数名（默认: health）

	// 健康检查参数值
	QueryParamValue string `mapstructure:"query-param-value" yaml:"query-param-value" json:"queryParamValue"` // 健康检查参数值（默认: true）

	// 响应消息配置
	SendResponseMessage bool `mapstructure:"send-response-message" yaml:"send-response-message" json:"sendResponseMessage"` // 是否发送响应消息（默认: true）

	// 是否立即关闭连接
	CloseImmediately bool `mapstructure:"close-immediately" yaml:"close-immediately" json:"closeImmediately"` // 是否立即关闭连接（默认: true）
}

type MessageBrokerConfig struct {
	Enabled     bool                  `mapstructure:"enabled" yaml:"enabled" json:"enabled"`               // 总开关（false = 直调模式，broker 域零初始化零开销）
	Driver      string                `mapstructure:"driver" yaml:"driver" json:"driver"`                  // 驱动：nats | memory（空 = 不启用）
	TopicPrefix string                `mapstructure:"topic-prefix" yaml:"topic-prefix" json:"topicPrefix"` // topic 前缀（wsc.{app}.deliver / .broadcast / .x）
	Group       string                `mapstructure:"group" yaml:"group" json:"group"`                     // consumer group（广播语义自动按 nodeID 派生独立 group）
	ShardCount  int                   `mapstructure:"shard-count" yaml:"shard-count" json:"shardCount"`    // JetStream deliver 分片数（顺序并行度，分片内串行保序）
	Consumer    *BrokerConsumerParams `mapstructure:"consumer" yaml:"consumer" json:"consumer"`            // 消费端批量拉取参数
}

type MessageEncryption struct {
	Enabled         bool   `mapstructure:"enabled" yaml:"enabled" json:"enabled"`                             // 是否启用消息数据加密
	Algorithm       string `mapstructure:"algorithm" yaml:"algorithm" json:"algorithm"`                       // 加密算法: AES-256-GCM, AES-128-GCM
	Key             string `mapstructure:"key" yaml:"key" json:"key"`                                         // 加密密钥 (32字节用于AES-256, 16字节用于AES-128)
	EnableKeyRotate bool   `mapstructure:"enable-key-rotate" yaml:"enable-key-rotate" json:"enableKeyRotate"` // 是否启用密钥轮换
	KeyRotateHours  int    `mapstructure:"key-rotate-hours" yaml:"key-rotate-hours" json:"keyRotateHours"`    // 密钥轮换间隔(小时)
	Compress        bool   `mapstructure:"compress" yaml:"compress" json:"compress"`                          // 加密前是否压缩数据
	EncryptPrefix   string `mapstructure:"encrypt-prefix" yaml:"encrypt-prefix" json:"encryptPrefix"`         // 加密数据前缀标识
	BackupKeys      int    `mapstructure:"backup-keys" yaml:"backup-keys" json:"backupKeys"`                  // 保留的备份密钥数量
}

type MessageRecord struct {
	CleanupDaysAgo     int  `mapstructure:"cleanup-days-ago" yaml:"cleanup-days-ago" json:"cleanupDaysAgo"`             // 启动时清理N天前的数据（0表示不清理）
	EnableAutoCleanup  bool `mapstructure:"enable-auto-cleanup" yaml:"enable-auto-cleanup" json:"enableAutoCleanup"`    // 是否启用自动清理
	EnableCompression  bool `mapstructure:"enable-compression" yaml:"enable-compression" json:"enableCompression"`      // 是否启用压缩
	CompressionMinSize int  `mapstructure:"compression-min-size" yaml:"compression-min-size" json:"compressionMinSize"` // 最小压缩大小（字节，小于此值不压缩）
}

type NodeGRPC struct {
	Enabled          bool   `mapstructure:"enabled" yaml:"enabled" json:"enabled"`                                // 是否启用 gRPC 节点通信
	Host             string `mapstructure:"host" yaml:"host" json:"host"`                                         // gRPC 监听地址
	Port             int    `mapstructure:"port" yaml:"port" json:"port"`                                         // gRPC 监听端口
	TLSEnabled       bool   `mapstructure:"tls-enabled" yaml:"tls-enabled" json:"tlsEnabled"`                     // 是否启用 TLS
	TLSCertFile      string `mapstructure:"tls-cert-file" yaml:"tls-cert-file" json:"tlsCertFile"`                // TLS 证书文件
	TLSKeyFile       string `mapstructure:"tls-key-file" yaml:"tls-key-file" json:"tlsKeyFile"`                   // TLS 私钥文件
	NodeGRPCKey      string `mapstructure:"node-grpc-key" yaml:"node-grpc-key" json:"nodeGrpcKey"`                // 节点 gRPC 地址 Hash key，默认 "wsc:nodes:grpc"
	NodeHeartbeatKey string `mapstructure:"node-heartbeat-key" yaml:"node-heartbeat-key" json:"nodeHeartbeatKey"` // 节点心跳 Hash key，默认 "wsc:nodes:heartbeat"
}

type OfflineMessage struct {
	KeyPrefix         string        `mapstructure:"key-prefix" yaml:"key-prefix" json:"keyPrefix"`                           // Redis键前缀
	QueueTTL          time.Duration `mapstructure:"queue-ttl" yaml:"queue-ttl" json:"queueTTL"`                              // 队列过期时间
	AutoStore         bool          `mapstructure:"auto-store" yaml:"auto-store" json:"autoStore"`                           // 是否自动存储离线消息
	AutoPush          bool          `mapstructure:"auto-push" yaml:"auto-push" json:"autoPush"`                              // 是否自动推送离线消息
	MaxCount          int           `mapstructure:"max-count" yaml:"max-count" json:"maxCount"`                              // 单次推送最大离线消息数
	CleanupDaysAgo    int           `mapstructure:"cleanup-days-ago" yaml:"cleanup-days-ago" json:"cleanupDaysAgo"`          // 启动时清理N天前的数据（0表示不清理）
	EnableAutoCleanup bool          `mapstructure:"enable-auto-cleanup" yaml:"enable-auto-cleanup" json:"enableAutoCleanup"` // 是否启用自动清理
}

type OnlineStatus struct {
	KeyPrefix                string        `mapstructure:"key-prefix" yaml:"key-prefix" json:"keyPrefix"`                                                // Redis键前缀
	TTL                      time.Duration `mapstructure:"ttl" yaml:"ttl" json:"ttl"`                                                                    // 过期时间
	CleanupDaysAgo           int           `mapstructure:"cleanup-days-ago" yaml:"cleanup-days-ago" json:"cleanupDaysAgo"`                               // 启动时清理N天前的数据（0表示不清理）
	EnableAutoCleanup        bool          `mapstructure:"enable-auto-cleanup" yaml:"enable-auto-cleanup" json:"enableAutoCleanup"`                      // 是否启用自动清理
	StatusRefreshInterval    time.Duration `mapstructure:"status-refresh-interval" yaml:"status-refresh-interval" json:"statusRefreshInterval"`          // 状态刷新间隔
	HeartbeatRefreshInterval time.Duration `mapstructure:"heartbeat-refresh-interval" yaml:"heartbeat-refresh-interval" json:"heartbeatRefreshInterval"` // 心跳批量重建在线索引的 flush 间隔（processHeartbeatRedisUpdates 用，默认 2s）
	EnableCompression        bool          `mapstructure:"enable-compression" yaml:"enable-compression" json:"enableCompression"`                        // 是否启用压缩
	CompressionMinSize       int           `mapstructure:"compression-min-size" yaml:"compression-min-size" json:"compressionMinSize"`                   // 压缩阈值（字节）
}

type Performance struct {
	MaxConnectionsPerNode int  `mapstructure:"max-connections-per-node" yaml:"max-connections-per-node" json:"maxConnectionsPerNode"` // 每个节点最大连接数
	ReadBufferSize        int  `mapstructure:"read-buffer-size" yaml:"read-buffer-size" json:"readBufferSize"`                        // 读缓冲区大小(KB)
	WriteBufferSize       int  `mapstructure:"write-buffer-size" yaml:"write-buffer-size" json:"writeBufferSize"`                     // 写缓冲区大小(KB)
	EnableCompression     bool `mapstructure:"enable-compression" yaml:"enable-compression" json:"enableCompression"`                 // 是否启用压缩
	CompressionLevel      int  `mapstructure:"compression-level" yaml:"compression-level" json:"compressionLevel"`                    // 压缩级别(1-9)
	EnableMetrics         bool `mapstructure:"enable-metrics" yaml:"enable-metrics" json:"enableMetrics"`                             // 是否启用性能指标
	MetricsInterval       int  `mapstructure:"metrics-interval" yaml:"metrics-interval" json:"metricsInterval"`                       // 指标采集间隔(秒)
	EnableSlowLog         bool `mapstructure:"enable-slow-log" yaml:"enable-slow-log" json:"enableSlowLog"`                           // 是否启用慢日志
	SlowLogThreshold      int  `mapstructure:"slow-log-threshold" yaml:"slow-log-threshold" json:"slowLogThreshold"`                  // 慢日志阈值(毫秒)
}

type PubSub struct {
	Enabled            bool          `mapstructure:"enabled" yaml:"enabled" json:"enabled"`                                      // 是否启用分布式消息订阅
	Namespace          string        `mapstructure:"namespace" yaml:"namespace" json:"namespace"`                                // 命名空间
	MaxRetries         int           `mapstructure:"max-retries" yaml:"max-retries" json:"maxRetries"`                           // 最大重试次数
	RetryDelay         time.Duration `mapstructure:"retry-delay" yaml:"retry-delay" json:"retryDelay"`                           // 重试延迟
	BufferSize         int           `mapstructure:"buffer-size" yaml:"buffer-size" json:"bufferSize"`                           // 消息缓冲区大小
	PingInterval       time.Duration `mapstructure:"ping-interval" yaml:"ping-interval" json:"pingInterval"`                     // 心跳间隔
	EnableCompression  bool          `mapstructure:"enable-compression" yaml:"enable-compression" json:"enableCompression"`      // 是否启用消息压缩
	CompressionMinSize int           `mapstructure:"compression-min-size" yaml:"compression-min-size" json:"compressionMinSize"` // 压缩阈值（字节）

	// Channel/Key 前缀配置（消除 hub 包中的硬编码 Redis key）
	NodeChannelPrefix string `mapstructure:"node-channel-prefix" yaml:"node-channel-prefix" json:"nodeChannelPrefix"` // 节点消息 channel 前缀，默认 "wsc:node:"
	BroadcastChannel  string `mapstructure:"broadcast-channel" yaml:"broadcast-channel" json:"broadcastChannel"`      // 广播 channel 名称，默认 "wsc:broadcast"
	ObserverChannel   string `mapstructure:"observer-channel" yaml:"observer-channel" json:"observerChannel"`         // 观察者 channel 名称，默认 "wsc:observers"
	LockKeyPrefix     string `mapstructure:"lock-key-prefix" yaml:"lock-key-prefix" json:"lockKeyPrefix"`             // 分布式锁 key 前缀，默认 "wsc:lock:"
}

type RedisRepository struct {
	// 全局清理配置（所有子模块的默认值）
	CleanupDaysAgo    int  `mapstructure:"cleanup-days-ago" yaml:"cleanup-days-ago" json:"cleanupDaysAgo"`          // 全局：启动时清理N天前的数据（0表示不清理）
	EnableAutoCleanup bool `mapstructure:"enable-auto-cleanup" yaml:"enable-auto-cleanup" json:"enableAutoCleanup"` // 全局：是否启用自动清理

	// 子模块配置
	OnlineStatus    *OnlineStatus    `mapstructure:"online-status" yaml:"online-status" json:"onlineStatus"`            // 在线状态配置
	Stats           *Stats           `mapstructure:"stats" yaml:"stats" json:"stats"`                                   // 统计数据配置
	Workload        *Workload        `mapstructure:"workload" yaml:"workload" json:"workload"`                          // 负载管理配置
	OfflineMessage  *OfflineMessage  `mapstructure:"offline-message" yaml:"offline-message" json:"offlineMessage"`      // 离线消息配置
	PubSub          *PubSub          `mapstructure:"pubsub" yaml:"pubsub" json:"pubsub"`                                // 分布式消息订阅配置
	DeadLetterQueue *DeadLetterQueue `mapstructure:"dead-letter-queue" yaml:"dead-letter-queue" json:"deadLetterQueue"` // 死信队列配置
	Group           *Group           `mapstructure:"group" yaml:"group" json:"group"`                                   // 群组配置
}

type ResponseHeaders struct {
	// 是否启用响应头
	Enabled bool `mapstructure:"enabled" yaml:"enabled" json:"enabled"` // 是否在 WebSocket 升级响应中返回客户端信息

	// 服务端分配的信息（有意义的响应头）
	ClientIDKey string `mapstructure:"client-id-key" yaml:"client-id-key" json:"clientIdKey"` // 客户端ID响应头键名（服务端生成或确认，默认: X-WSC-Client-ID）
	NodeIDKey   string `mapstructure:"node-id-key" yaml:"node-id-key" json:"nodeIdKey"`       // 节点ID响应头键名（服务端分配，默认: X-WSC-Node-ID）

	// 自定义响应头前缀
	CustomPrefix string `mapstructure:"custom-prefix" yaml:"custom-prefix" json:"customPrefix"` // 自定义响应头前缀（默认: X-WSC-）

	// 额外的自定义响应头（静态值）
	CustomHeaders map[string]string `mapstructure:"custom-headers" yaml:"custom-headers" json:"customHeaders"` // 额外的自定义响应头，如 {"X-Server-Version": "1.0.0", "X-Region": "us-west", "X-Protocol-Version": "1.0"}

	// 客户端注册成功消息配置
	SendRegisteredMessage    bool   `mapstructure:"send-registered-message" yaml:"send-registered-message" json:"sendRegisteredMessage"`          // 是否发送客户端注册成功消息（默认: true）
	RegisteredMessageContent string `mapstructure:"registered-message-content" yaml:"registered-message-content" json:"registeredMessageContent"` // 注册成功消息内容（默认: "Client registered successfully"）
}

type RetryPolicy struct {
	MaxRetries         int           `mapstructure:"max-retries" yaml:"max-retries" json:"maxRetries"`                           // 最大重试次数
	BaseDelay          time.Duration `mapstructure:"base-delay" yaml:"base-delay" json:"baseDelay"`                              // 基本重试延迟
	MaxDelay           time.Duration `mapstructure:"max-delay" yaml:"max-delay" json:"maxDelay"`                                 // 最大重试延迟
	BackoffFactor      float64       `mapstructure:"backoff-factor" yaml:"backoff-factor" json:"backoffFactor"`                  // 重试退避倍数
	Jitter             bool          `mapstructure:"jitter" yaml:"jitter" json:"jitter"`                                         // 是否添加随机抖动
	JitterPercent      float64       `mapstructure:"jitter-percent" yaml:"jitter-percent" json:"jitterPercent"`                  // 抖动百分比(0-1)
	RetryableErrors    []string      `mapstructure:"retryable-errors" yaml:"retryable-errors" json:"retryableErrors"`            // 可重试的错误类型
	NonRetryableErrors []string      `mapstructure:"non-retryable-errors" yaml:"non-retryable-errors" json:"nonRetryableErrors"` // 不可重试的错误类型
}

type RouterCacheConfig struct {
	// TTL 缓存过期时间（默认 5 分钟）
	TTL time.Duration `mapstructure:"ttl" yaml:"ttl" json:"ttl"`
	// MaxLocalCacheSize 本地缓存最大条目数（默认 50000，约 5 万用户）
	MaxLocalCacheSize int `mapstructure:"max-local-cache-size" yaml:"max-local-cache-size" json:"maxLocalCacheSize"`
	// Namespace Redis 命名空间（默认 "wsc"）
	Namespace string `mapstructure:"namespace" yaml:"namespace" json:"namespace"`
}

type Security struct {
	// 访问控制配置（消息大小/用户类型白名单/IP 黑白名单）
	AccessControl *AccessControl `mapstructure:"access-control" yaml:"access-control" json:"accessControl"` // 访问控制配置

	// 消息加密配置
	MessageEncryption *MessageEncryption `mapstructure:"message-encryption" yaml:"message-encryption" json:"messageEncryption"` // 消息加密配置

	// 连接 Token 配置（将 user_id/user_type/device_id 加密为单一 token，避免明文暴露）
	ConnectionToken *ConnectionToken `mapstructure:"connection-token" yaml:"connection-token" json:"connectionToken"` // 连接 Token 配置（可选启用，默认关闭向后兼容明文参数）
}

type Stats struct {
	KeyPrefix         string        `mapstructure:"key-prefix" yaml:"key-prefix" json:"keyPrefix"`                           // Redis键前缀
	TTL               time.Duration `mapstructure:"ttl" yaml:"ttl" json:"ttl"`                                               // 过期时间
	CleanupDaysAgo    int           `mapstructure:"cleanup-days-ago" yaml:"cleanup-days-ago" json:"cleanupDaysAgo"`          // 启动时清理N天前的数据（0表示不清理）
	EnableAutoCleanup bool          `mapstructure:"enable-auto-cleanup" yaml:"enable-auto-cleanup" json:"enableAutoCleanup"` // 是否启用自动清理
}

type TemporalHasherConfig struct {
	WindowMinutes int    `mapstructure:"window-minutes" yaml:"window-minutes" json:"windowMinutes"` // 时间窗口（分钟，默认: 5）
	HashLength    int    `mapstructure:"hash-length" yaml:"hash-length" json:"hashLength"`          // 哈希长度（默认: 12）
	Separator     string `mapstructure:"separator" yaml:"separator" json:"separator"`               // 分隔符（默认: ":"）
}

type TimerConfig struct {
	// TickInterval tick 间隔（默认 10ms）
	// 心跳/ACK 超时均为秒级语义，无需 1ms 精度；tick 越小空转 CPU 越高（每分片每 tick 一次锁检查）
	TickInterval time.Duration `mapstructure:"tick-interval" yaml:"tick-interval" json:"tickInterval"`
	// ShardCount 分片数（默认 16，需为 2 的幂）
	// 总 tick 频率 = ShardCount × (1s / TickInterval)，默认 16 × 100 = 1600 tick/s
	ShardCount int `mapstructure:"shard-count" yaml:"shard-count" json:"shardCount"`
}

type WSC struct {
	// === 基础配置 ===
	Enabled                    bool          `mapstructure:"enabled" yaml:"enabled" json:"enabled"`                                                              // 是否启用
	EnableAgent                bool          `mapstructure:"enable-agent" yaml:"enable-agent" json:"enableAgent"`                                                // 是否启用客服(Agent/Bot)连接管理（禁用时不维护 agentClients 映射，适用于纯通知场景）
	EnableObserver             bool          `mapstructure:"enable-observer" yaml:"enable-observer" json:"enableObserver"`                                       // 是否启用观察者模块（禁用时不维护 observerClients 映射且跳过观察者通知）
	EnableWorkload             bool          `mapstructure:"enable-workload" yaml:"enable-workload" json:"enableWorkload"`                                       // 是否启用客服负载管理（禁用时不初始化 workloadRepo）
	Network                    string        `mapstructure:"network" yaml:"network" json:"network"`                                                              // 网络类型: tcp, tcp4, tcp6
	NodeIP                     string        `mapstructure:"node-ip" yaml:"node-ip" json:"nodeIp"`                                                               // 节点IP
	NodePort                   int           `mapstructure:"node-port" yaml:"node-port" json:"nodePort"`                                                         // 节点端口
	Path                       string        `mapstructure:"path" yaml:"path" json:"path"`                                                                       // WebSocket服务路径
	AllowMultiLogin            bool          `mapstructure:"allow-multi-login" yaml:"allow-multi-login" json:"allowMultiLogin"`                                  // 是否允许多端登录（异地多活）
	MaxConnectionsPerUser      int           `mapstructure:"max-connections-per-user" yaml:"max-connections-per-user" json:"maxConnectionsPerUser"`              // 每个用户最大连接数（0表示不限制）
	ConnectionPolicy           string        `mapstructure:"connection-policy" yaml:"connection-policy" json:"connectionPolicy"`                                 // 连接冲突策略: kick_old(踢掉旧连接), kick_new(拒绝新连接), allow_all(允许所有)
	SendKickNotification       bool          `mapstructure:"send-kick-notification" yaml:"send-kick-notification" json:"sendKickNotification"`                   // 踢出时是否发送通知
	KickNotificationMsg        string        `mapstructure:"kick-notification-msg" yaml:"kick-notification-msg" json:"kickNotificationMsg"`                      // 踢出通知自定义消息
	HeartbeatInterval          time.Duration `mapstructure:"heartbeat-interval" yaml:"heartbeat-interval" json:"heartbeatInterval"`                              // 心跳间隔
	PerformanceMetricsInterval time.Duration `mapstructure:"performance-metrics-interval" yaml:"performance-metrics-interval" json:"performanceMetricsInterval"` // 性能监控间隔
	AckCleanupInterval         time.Duration `mapstructure:"ack-cleanup-interval" yaml:"ack-cleanup-interval" json:"ackCleanupInterval"`                         // ACK清理间隔
	ClientTimeout              time.Duration `mapstructure:"client-timeout" yaml:"client-timeout" json:"clientTimeout"`                                          // 客户端超时
	ShutdownBaseTimeout        time.Duration `mapstructure:"shutdown-base-timeout" yaml:"shutdown-base-timeout" json:"shutdownBaseTimeout"`                      // Hub关闭基础超时（5秒）
	ShutdownMaxTimeout         time.Duration `mapstructure:"shutdown-max-timeout" yaml:"shutdown-max-timeout" json:"shutdownMaxTimeout"`                         // Hub关闭最大超时（60秒）
	MessageBufferSize          int           `mapstructure:"message-buffer-size" yaml:"message-buffer-size" json:"messageBufferSize"`                            // 消息缓冲区大小
	MaxPendingQueueSize        int           `mapstructure:"max-pending-queue-size" yaml:"max-pending-queue-size" json:"maxPendingQueueSize"`                    // 最大待发送消息队列大小
	WebSocketOrigins           []string      `mapstructure:"websocket-origins" yaml:"websocket-origins" json:"websocketOrigins"`                                 // 允许的WebSocket Origin
	ReadTimeout                time.Duration `mapstructure:"read-timeout" yaml:"read-timeout" json:"readTimeout"`                                                // 读取超时
	WriteTimeout               time.Duration `mapstructure:"write-timeout" yaml:"write-timeout" json:"writeTimeout"`                                             // 写入超时
	IdleTimeout                time.Duration `mapstructure:"idle-timeout" yaml:"idle-timeout" json:"idleTimeout"`                                                // 空闲超时
	MaxMessageSize             int64         `mapstructure:"max-message-size" yaml:"max-message-size" json:"maxMessageSize"`                                     // 最大消息长度
	MinRecTime                 time.Duration `mapstructure:"min-rec-time" yaml:"min-rec-time" json:"minRecTime"`                                                 // 最小重连时间
	MaxRecTime                 time.Duration `mapstructure:"max-rec-time" yaml:"max-rec-time" json:"maxRecTime"`                                                 // 最大重连时间
	RecFactor                  float64       `mapstructure:"rec-factor" yaml:"rec-factor" json:"recFactor"`                                                      // 重连因子
	AutoReconnect              bool          `mapstructure:"auto-reconnect" yaml:"auto-reconnect" json:"autoReconnect"`                                          // 是否自动重连
	AckTimeout                 time.Duration `mapstructure:"ack-timeout" yaml:"ack-timeout" json:"ackTimeout"`                                                   // 消息确认超时
	AckMaxRetries              int           `mapstructure:"ack-max-retries" yaml:"ack-max-retries" json:"ackMaxRetries"`                                        // 消息确认最大重试次数
	EnableAck                  bool          `mapstructure:"enable-ack" yaml:"enable-ack" json:"enableAck"`                                                      // 是否启用消息确认
	MessageRecordTTL           time.Duration `mapstructure:"message-record-ttl" yaml:"message-record-ttl" json:"messageRecordTtl"`                               // 消息发送记录过期时间
	RecordCleanupInterval      time.Duration `mapstructure:"record-cleanup-interval" yaml:"record-cleanup-interval" json:"recordCleanupInterval"`                // 消息记录清理间隔

	// === SSE 配置 ===
	SSEPath          string        `mapstructure:"sse-path" yaml:"sse-path" json:"ssePath"`                              // SSE 服务路径（网关层注册的 HTTP 路由）
	SSEHeartbeat     time.Duration `mapstructure:"sse-heartbeat" yaml:"sse-heartbeat" json:"sseHeartbeat"`               // SSE心跳间隔
	SSETimeout       time.Duration `mapstructure:"sse-timeout" yaml:"sse-timeout" json:"sseTimeout"`                     // SSE超时
	SSEMessageBuffer int           `mapstructure:"sse-message-buffer" yaml:"sse-message-buffer" json:"sseMessageBuffer"` // SSE消息缓冲区大小

	// === Redis 仓库配置 ===
	RedisRepository *RedisRepository `mapstructure:"redis-repository" yaml:"redis-repository" json:"redisRepository"` // Redis仓库配置

	// === 节点间 gRPC 通信配置 ===
	NodeGRPC *NodeGRPC `mapstructure:"node-grpc" yaml:"node-grpc" json:"nodeGrpc"` // 节点间 gRPC 通信配置

	// === 性能配置 ===
	Performance *Performance `mapstructure:"performance" yaml:"performance" json:"performance"` // 性能配置

	// === 安全配置 ===
	Security *Security `mapstructure:"security" yaml:"security" json:"security"` // 安全配置

	// === 客户端属性提取配置 ===
	ClientAttributes *ClientAttributes `mapstructure:"client-attributes" yaml:"client-attributes" json:"clientAttributes"` // 客户端属性提取配置

	// === 时间窗口哈希生成器配置 ===
	TemporalHasher *TemporalHasherConfig `mapstructure:"temporal-hasher" yaml:"temporal-hasher" json:"temporalHasher"` // 时间窗口哈希生成器配置（用于生成基于时间窗口的 ClientID）

	// === WebSocket 升级响应头配置 ===
	ResponseHeaders *ResponseHeaders `mapstructure:"response-headers" yaml:"response-headers" json:"responseHeaders"` // WebSocket 升级响应头配置

	// === 健康检查配置 ===
	HealthCheck *HealthCheck `mapstructure:"health-check" yaml:"health-check" json:"healthCheck"` // 健康检查配置

	// === 连接验证配置 ===
	ConnectionValidation *ConnectionValidation `mapstructure:"connection-validation" yaml:"connection-validation" json:"connectionValidation"` // 连接验证配置

	// === 数据库配置 ===
	Database *Database `mapstructure:"database" yaml:"database" json:"database"`

	// === 日志配置 ===
	Logging *logging.Logging `mapstructure:"logging" yaml:"logging" json:"logging"` // 日志配置

	// === 批处理配置 ===
	BatchProcessing *BatchProcessing `mapstructure:"batch-processing" yaml:"batch-processing" json:"batchProcessing"` // 批处理配置

	// === 通道缓冲配置 ===
	ChannelBuffers *ChannelBuffers `mapstructure:"channel-buffers" yaml:"channel-buffers" json:"channelBuffers"` // 通道缓冲配置

	// === 重试策略配置 ===
	RetryPolicy *RetryPolicy `mapstructure:"retry-policy" yaml:"retry-policy" json:"retryPolicy"` // 重试策略配置

	// === 客户端容量配置 ===
	ClientCapacity *ClientCapacity `mapstructure:"client-capacity" yaml:"client-capacity" json:"clientCapacity"` // 客户端容量配置

	// === Hub 容量估算配置 ===
	CapacityEstimation *CapacityEstimation `mapstructure:"capacity-estimation" yaml:"capacity-estimation" json:"capacityEstimation"` // Hub 容量估算配置

	// === Hub 工作池配置 ===
	WorkerPool *WorkerPoolConfig `mapstructure:"worker-pool" yaml:"worker-pool" json:"workerPool"` // Hub 工作池配置（消息/回调/记录/分布式分池）

	// === 时间轮配置 ===
	Timer *TimerConfig `mapstructure:"timer" yaml:"timer" json:"timer"` // 心跳/ACK 超时时间轮配置（tick 精度与分片数）

	// === 路由缓存配置 ===
	RouterCache *RouterCacheConfig `mapstructure:"router-cache" yaml:"router-cache" json:"routerCache"` // 分布式路由缓存配置

	// === 批量处理器配置 ===
	Batcher *BatcherConfig `mapstructure:"batcher" yaml:"batcher" json:"batcher"` // 批量处理器配置（队列/批次/flush 间隔）

	// === 消息聚合器配置 ===
	Aggregator *AggregatorConfig `mapstructure:"aggregator" yaml:"aggregator" json:"aggregator"` // 消息聚合器配置（弹幕等可聚合档群组消息 N 条合 1 条数组帧）

	// === 消息总线配置 ===
	MessageBroker *MessageBrokerConfig `mapstructure:"message-broker" yaml:"message-broker" json:"messageBroker"` // 消息总线配置（MQ 入口与内部传输统一通道，禁用即直调模式）
}

type WorkStatus struct {
	Enabled       bool                    `mapstructure:"enabled" yaml:"enabled" json:"enabled"`                     // 是否启用工作状态统计（Bitmap）
	Granularities []WorkStatusGranularity `mapstructure:"granularities" yaml:"granularities" json:"granularities"`   // 统计粒度: hour, day, month, year
	RetentionDays int                     `mapstructure:"retention-days" yaml:"retention-days" json:"retentionDays"` // 数据保留天数（0表示永久保留）
	AsyncRecord   bool                    `mapstructure:"async-record" yaml:"async-record" json:"asyncRecord"`       // 是否异步记录（默认true）
	RecordTimeout int                     `mapstructure:"record-timeout" yaml:"record-timeout" json:"recordTimeout"` // 记录超时时间（秒，默认2秒）
	SyncToDB      bool                    `mapstructure:"sync-to-db" yaml:"sync-to-db" json:"syncToDb"`              // 是否同步到数据库（默认true）
	SyncInterval  int                     `mapstructure:"sync-interval" yaml:"sync-interval" json:"syncInterval"`    // 同步到数据库的间隔（秒，默认300秒=5分钟）
}

type WorkStatusGranularity string

type WorkerPoolConfig struct {
	// MessageWorkers 消息发送 worker 数（默认 64）
	MessageWorkers int `mapstructure:"message-workers" yaml:"message-workers" json:"messageWorkers"`
	// MessageQueueSize 消息发送队列大小（默认 4096）
	MessageQueueSize int `mapstructure:"message-queue-size" yaml:"message-queue-size" json:"messageQueueSize"`
	// CallbackWorkers 业务回调 worker 数（默认 32）
	CallbackWorkers int `mapstructure:"callback-workers" yaml:"callback-workers" json:"callbackWorkers"`
	// CallbackQueueSize 业务回调队列大小（默认 2048）
	CallbackQueueSize int `mapstructure:"callback-queue-size" yaml:"callback-queue-size" json:"callbackQueueSize"`
	// RecordWorkers 数据库记录 worker 数（默认 16）
	RecordWorkers int `mapstructure:"record-workers" yaml:"record-workers" json:"recordWorkers"`
	// RecordQueueSize 数据库记录队列大小（默认 2048）
	RecordQueueSize int `mapstructure:"record-queue-size" yaml:"record-queue-size" json:"recordQueueSize"`
	// DistributedWorkers 跨节点消息 worker 数（默认 32）
	DistributedWorkers int `mapstructure:"distributed-workers" yaml:"distributed-workers" json:"distributedWorkers"`
	// DistributedQueueSize 跨节点消息队列大小（默认 2048）
	DistributedQueueSize int `mapstructure:"distributed-queue-size" yaml:"distributed-queue-size" json:"distributedQueueSize"`
	// IdleTimeout worker 空闲自动回收超时（默认 60s）
	// 弹性池按队列积压扩容 worker，空闲超过该时长自动回收至保底数量
	IdleTimeout time.Duration `mapstructure:"idle-timeout" yaml:"idle-timeout" json:"idleTimeout"`
}

type Workload struct {
	KeyPrefix     string      `mapstructure:"key-prefix" yaml:"key-prefix" json:"keyPrefix"`             // Redis键前缀
	MaxCandidates int         `mapstructure:"max-candidates" yaml:"max-candidates" json:"maxCandidates"` // 获取负载最小客服时的最大候选数量
	WorkStatus    *WorkStatus `mapstructure:"work-status" yaml:"work-status" json:"workStatus"`          // 工作状态统计配置
}