config

type Application struct {
	Mode     string `mapstructure:"mode" json:"mode"`         // 环境: dev, test, prod
	Name     string `mapstructure:"name" json:"name"`         // 应用名称
	EnableDP bool   `mapstructure:"enabledp" json:"enabledp"` // 数据权限功能开关

}

type BacklogDetectionConfig struct {
	Enabled          bool          `mapstructure:"enabled"`
	MaxLagThreshold  int64         `mapstructure:"maxLagThreshold"`
	MaxTimeThreshold time.Duration `mapstructure:"maxTimeThreshold"`
	CheckInterval    time.Duration `mapstructure:"checkInterval"`
}

type Cache struct {
	Redis  *RedisConnectOptions
	Memory interface{}
}

type ClientMiddlewaresConfig struct {
	Trace      bool `mapstructure:"trace" json:"trace,default=true"`           // 链路跟踪
	Duration   bool `mapstructure:"duration" json:"duration,default=true"`     // 持续时间统计
	Prometheus bool `mapstructure:"prometheus" json:"prometheus,default=true"` // Prometheus监控
	Breaker    bool `mapstructure:"breaker" json:"breaker,default=true"`       // 熔断器
}

type Config struct {
	Application    *Application          `mapstructure:"application"`
	HTTP           *HTTPConfig           `mapstructure:"http" json:"http"`
	GRPC           *GRPCConfig           `mapstructure:"grpc" json:"grpc"`
	Etcd           *ETCDConfig           `mapstructure:"etcd" json:"etcd"`
	Logger         *Logger               `mapstructure:"logger"`
	SSL            *SSL                  `mapstructure:"ssl"`
	JWT            *JWTConfig            `mapstructure:"jwt"`
	Database       *Database             `mapstructure:"database"`
	Cache          *Cache                `mapstructure:"cache"`
	Queue          *Queue                `mapstructure:"queue"`
	EventBus       *EventBusConfig       `mapstructure:"eventBus"`
	Locker         *Locker               `mapstructure:"locker"`
	Tenants        *Tenants              `mapstructure:"tenants"`
	Storage        *StorageConfig        `mapstructure:"storage"`         // 共享存储配置（HTTP/FTP）
	DuplicateCheck *DuplicateCheckConfig `mapstructure:"duplicate_check"` // 共享去重配置
	FTP            *FTPConfig            `mapstructure:"ftp"`             // FTP 服务器配置
}

type ConsumerConfig struct {
	GroupID           string        `mapstructure:"groupId"`           // 消费者组ID
	AutoOffsetReset   string        `mapstructure:"autoOffsetReset"`   // 偏移量重置策略 (earliest, latest, none)
	SessionTimeout    time.Duration `mapstructure:"sessionTimeout"`    // 会话超时时间
	HeartbeatInterval time.Duration `mapstructure:"heartbeatInterval"` // 心跳间隔

}

type Database struct {
	Driver          string     `mapstructure:"driver"`
	Source          string     `mapstructure:"source"`
	ConnMaxIdleTime int        `mapstructure:"connmaxidletime"`
	ConnMaxLifeTime int        `mapstructure:"connmaxlifetime"`
	MaxIdleConns    int        `mapstructure:"maxidleconns"`
	MaxOpenConns    int        `mapstructure:"maxopenconns"`
	Registers       []Register `mapstructure:"registers"`
}

type DefaultTenantConfig struct {
	// 服务级数据库配置映射（service_code -> config）
	ServiceDatabases map[string]TenantDatabaseDetailConfig `mapstructure:"service_databases" yaml:"service_databases"` // 服务级数据库配置

	Domain     *TenantDomainConfig        `mapstructure:"domain" yaml:"domain"`           // 域名配置
	FTPConfigs []TenantFTPDetailConfig    `mapstructure:"ftp_configs" yaml:"ftp_configs"` // FTP 配置数组
	Storage    *TenantStorageDetailConfig `mapstructure:"storage" yaml:"storage"`         // 存储配置
	WvpConfig  *TenantWvpDetailConfig     `mapstructure:"wvp_config" yaml:"wvp_config"`   // WVP 平台配置
}

type DuplicateCheckConfig struct {
	Enabled  bool                     `mapstructure:"enabled" yaml:"enabled"`   // 是否启用去重检查
	Strategy string                   `mapstructure:"strategy" yaml:"strategy"` // 策略: filename, content, hybrid
	Filename *DuplicateFilenameConfig `mapstructure:"filename" yaml:"filename"` // 文件名匹配配置
	Content  *DuplicateContentConfig  `mapstructure:"content" yaml:"content"`   // 内容匹配配置
}

type DuplicateContentConfig struct {
	Algorithm string `mapstructure:"algorithm" yaml:"algorithm"` // 哈希算法: sha1, sha256, md5
}

type DuplicateFilenameConfig struct {
	CaseSensitive bool   `mapstructure:"case_sensitive" yaml:"case_sensitive"` // 是否大小写敏感
	MatchMode     string `mapstructure:"match_mode" yaml:"match_mode"`         // 匹配模式: prefix, exact, regex
}

type ETCDConfig struct {
	Enabled     bool              `mapstructure:"enabled" json:"enabled"`         // 是否启用ETCD
	Hosts       []string          `mapstructure:"hosts" json:"hosts"`             // ETCD主机列表
	Username    string            `mapstructure:"username" json:"username"`       // 用户名
	Password    string            `mapstructure:"password" json:"password"`       // 密码
	Namespace   string            `mapstructure:"namespace" json:"namespace"`     // 命名空间前缀
	DialTimeout int               `mapstructure:"dialTimeout" json:"dialTimeout"` // 连接超时(秒)
	Timeout     int               `mapstructure:"timeout" json:"timeout"`         // 操作超时(秒)
	TLS         TLSConfig         `mapstructure:"tls" json:"tls"`                 // TLS配置
	Tenant      *ETCDTenantConfig `mapstructure:"tenant" json:"tenant"`           // 租户相关配置
}

type ETCDTenantConfig struct {
	WatchEnabled       bool   `mapstructure:"watchEnabled" json:"watchEnabled"`             // 启用 Watch 监听
	WatchRetryInterval int    `mapstructure:"watchRetryInterval" json:"watchRetryInterval"` // Watch 重试间隔(秒)
	CacheFile          string `mapstructure:"cacheFile" json:"cacheFile"`                   // 本地缓存文件路径
}

type ErrorHandlingConfig struct {
	DeadLetterTopic  string        `mapstructure:"deadLetterTopic"`
	MaxRetryAttempts int           `mapstructure:"maxRetryAttempts"`
	RetryBackoffBase time.Duration `mapstructure:"retryBackoffBase"`
	RetryBackoffMax  time.Duration `mapstructure:"retryBackoffMax"`
}

type EventBusConfig struct {
	// 基础配置
	Type        string `mapstructure:"type"`        // kafka, nats, memory
	ServiceName string `mapstructure:"serviceName"` // 微服务名称

	// 统一特性配置（适用于所有EventBus类型）
	HealthCheck HealthCheckConfig `mapstructure:"healthCheck"` // 健康检查
	Monitoring  MetricsConfig     `mapstructure:"monitoring"`  // 监控（复用现有的MetricsConfig）
	Security    SecurityConfig    `mapstructure:"security"`    // 安全

	// 发布端配置
	Publisher PublisherConfig `mapstructure:"publisher"`

	// 订阅端配置
	Subscriber SubscriberConfig `mapstructure:"subscriber"`

	// 具体实现配置
	Kafka  KafkaConfig  `mapstructure:"kafka"`  // Kafka配置
	NATS   NATSConfig   `mapstructure:"nats"`   // NATS配置
	Memory MemoryConfig `mapstructure:"memory"` // Memory配置
}

type FTPConfig struct {
	Enabled           bool            `mapstructure:"enabled" yaml:"enabled"`
	ListenAddr        string          `mapstructure:"listen_addr" yaml:"listen_addr"`
	PublicHost        string          `mapstructure:"public_host" yaml:"public_host"`
	PassivePortRange  PortRange       `mapstructure:"passive_port_range" yaml:"passive_port_range"`
	IdleTimeout       int             `mapstructure:"idle_timeout" yaml:"idle_timeout"`
	ConnectionTimeout int             `mapstructure:"connection_timeout" yaml:"connection_timeout"`
	TLS               FTPTLSConfig    `mapstructure:"tls" yaml:"tls"`
	Users             []FTPUserConfig `mapstructure:"users" yaml:"users"`
}

type FTPResolverConfig struct {
	Type string `mapstructure:"type" yaml:"type"` // 识别方式: username, password
}

type FTPTLSConfig struct {
	Enabled  bool   `mapstructure:"enabled" yaml:"enabled"`
	CertFile string `mapstructure:"cert_file" yaml:"cert_file"`
	KeyFile  string `mapstructure:"key_file" yaml:"key_file"`
}

type FTPUserConfig struct {
	Username        string `mapstructure:"username" yaml:"username"`
	Password        string `mapstructure:"password" yaml:"password"`
	HomeDirectory   string `mapstructure:"home_directory" yaml:"home_directory"`
	WritePermission bool   `mapstructure:"write_permission" yaml:"write_permission"`
}

type GRPCClientConfig struct {
	Enabled       bool          `mapstructure:"enabled" json:"enabled,default=true"`            // 是否启用gRPC客户端
	ServiceKey    string        `mapstructure:"serviceKey" json:"serviceKey"`                   // 服务发现键名
	Timeout       int64         `mapstructure:"timeout" json:"timeout,default=2000"`            // 超时时间(毫秒)
	KeepaliveTime time.Duration `mapstructure:"keepaliveTime" json:"keepaliveTime,default=20s"` // Keepalive时间

	// 连接配置
	Endpoints    []string `mapstructure:"endpoints" json:"endpoints,optional"`           // 直连端点列表
	Target       string   `mapstructure:"target" json:"target,optional"`                 // gRPC目标地址
	NonBlock     bool     `mapstructure:"nonBlock" json:"nonBlock,optional"`             // 非阻塞模式
	UseDiscovery bool     `mapstructure:"useDiscovery" json:"useDiscovery,default=true"` // 是否使用服务发现

	// 认证配置
	App   string `mapstructure:"app" json:"app,optional"`     // 应用名称
	Token string `mapstructure:"token" json:"token,optional"` // 认证Token

	// 性能配置
	Retries        int `mapstructure:"retries" json:"retries,default=3"`              // 重试次数
	MaxRecvMsgSize int `mapstructure:"maxRecvMsgSize" json:"maxRecvMsgSize,optional"` // 最大接收消息大小
	MaxSendMsgSize int `mapstructure:"maxSendMsgSize" json:"maxSendMsgSize,optional"` // 最大发送消息大小

	// 中间件配置
	Middlewares ClientMiddlewaresConfig `mapstructure:"middlewares" json:"middlewares,optional"` // 中间件配置
}

type GRPCConfig struct {
	Server GRPCServerConfig `mapstructure:"server" json:"server"` // gRPC服务配置
	Client GRPCClientConfig `mapstructure:"client" json:"client"` // gRPC客户端配置
}

type GRPCServerConfig struct {
	Enabled    bool   `mapstructure:"enabled" json:"enabled,default=true"`    // 是否启用gRPC服务
	ListenOn   string `mapstructure:"listenOn" json:"listenOn,default=:9000"` // 监听地址
	ServiceKey string `mapstructure:"serviceKey" json:"serviceKey"`           // 服务发现键名
	Timeout    int64  `mapstructure:"timeout" json:"timeout,default=2000"`    // 超时时间(毫秒)

	// 认证配置
	Auth bool `mapstructure:"auth" json:"auth,optional"` // 是否启用认证

	// 性能控制
	CpuThreshold   int64 `mapstructure:"cpuThreshold" json:"cpuThreshold,default=900,range=[0:1000]"` // CPU阈值
	StrictControl  bool  `mapstructure:"strictControl" json:"strictControl,optional"`                 // 严格控制模式
	MaxRecvMsgSize int   `mapstructure:"maxRecvMsgSize" json:"maxRecvMsgSize,optional"`               // 最大接收消息大小
	MaxSendMsgSize int   `mapstructure:"maxSendMsgSize" json:"maxSendMsgSize,optional"`               // 最大发送消息大小

	// TLS配置
	TLS TLSConfig `mapstructure:"tls" json:"tls,optional"` // TLS配置

	// KeepAlive配置
	KeepAlive KeepAliveConfig `mapstructure:"keepAlive" json:"keepAlive,optional"` // 保活配置

	// 中间件配置
	Middlewares ServerMiddlewaresConfig `mapstructure:"middlewares" json:"middlewares,optional"` // 中间件配置

	// 自定义服务配置
	Services map[string]ServiceConfig `mapstructure:"services" json:"services,optional"` // 服务配置
}

type HTTPConfig struct {
	Enabled        bool      `mapstructure:"enabled" json:"enabled"`               // 是否启用HTTP服务
	Host           string    `mapstructure:"host" json:"host"`                     // 服务器绑定IP
	Port           int       `mapstructure:"port" json:"port"`                     // HTTP端口
	ReadTimeout    int       `mapstructure:"readtimeout" json:"readtimeout"`       // 读取超时(秒)
	WriteTimeout   int       `mapstructure:"writetimeout" json:"writetimeout"`     // 写入超时(秒)
	IdleTimeout    int       `mapstructure:"idletimeout" json:"idletimeout"`       // 空闲超时(秒)
	MaxHeaderBytes int       `mapstructure:"maxheaderbytes" json:"maxheaderbytes"` // 最大请求头(MB)
	SSL            SSLConfig `mapstructure:"ssl" json:"ssl"`                       // SSL配置
}

type HTTPResolverConfig struct {
	Type       string `mapstructure:"type" yaml:"type"`             // 识别方式: host, header, query, path
	HeaderName string `mapstructure:"headerName" yaml:"headerName"` // 当 type 为 header 时使用的 header 名称
	QueryParam string `mapstructure:"queryParam" yaml:"queryParam"` // 当 type 为 query 时使用的查询参数名
	PathIndex  int    `mapstructure:"pathIndex" yaml:"pathIndex"`   // 当 type 为 path 时使用的路径索引
	HostMode   string `mapstructure:"hostMode" yaml:"hostMode"`     // 【新增】host 模式下的识别方式：numeric, domain, code
}

type HealthCheckConfig struct {
	// 基础配置
	Enabled bool `mapstructure:"enabled"` // 是否启用健康检查

	// 发布器配置
	Publisher HealthCheckPublisherConfig `mapstructure:"publisher"`

	// 订阅监控器配置
	Subscriber HealthCheckSubscriberConfig `mapstructure:"subscriber"`
}

type HealthCheckPublisherConfig struct {
	Topic            string        `mapstructure:"topic"`            // 健康检查发布主题（可选，默认自动生成）
	Interval         time.Duration `mapstructure:"interval"`         // 发布间隔（默认2分钟）
	Timeout          time.Duration `mapstructure:"timeout"`          // 发布超时（默认10秒）
	FailureThreshold int           `mapstructure:"failureThreshold"` // 连续失败阈值，触发重连（默认3次）
	MessageTTL       time.Duration `mapstructure:"messageTTL"`       // 消息存活时间（默认5分钟）
}

type HealthCheckSubscriberConfig struct {
	Topic             string        `mapstructure:"topic"`             // 健康检查订阅主题（可选，默认自动生成）
	MonitorInterval   time.Duration `mapstructure:"monitorInterval"`   // 监控检查间隔（默认30秒）
	WarningThreshold  int           `mapstructure:"warningThreshold"`  // 警告阈值（默认3次）
	ErrorThreshold    int           `mapstructure:"errorThreshold"`    // 错误阈值（默认5次）
	CriticalThreshold int           `mapstructure:"criticalThreshold"` // 严重阈值（默认10次）
}

type JWTConfig struct {
	Secret  string `mapstructure:"secret"`
	Timeout int    `mapstructure:"timeout"`
}

type JetStreamConfig struct {
	Enabled        bool          `mapstructure:"enabled"`
	Domain         string        `mapstructure:"domain"`
	APIPrefix      string        `mapstructure:"apiPrefix"`
	PublishTimeout time.Duration `mapstructure:"publishTimeout"`
	AckWait        time.Duration `mapstructure:"ackWait"`
	MaxDeliver     int           `mapstructure:"maxDeliver"`

	// 流配置
	Stream StreamConfig `mapstructure:"stream"`

	// 消费者配置
	Consumer NATSConsumerConfig `mapstructure:"consumer"`
}

type KafkaConfig struct {
	Brokers  []string       `mapstructure:"brokers"`  // Kafka集群地址
	Producer ProducerConfig `mapstructure:"producer"` // 生产者配置
	Consumer ConsumerConfig `mapstructure:"consumer"` // 消费者配置

}

type KeepAliveConfig struct {
	Time                int  `mapstructure:"time" json:"time,default=7200"`                                // 保活时间(秒)
	Timeout             int  `mapstructure:"timeout" json:"timeout,default=20"`                            // 保活超时(秒)
	PermitWithoutStream bool `mapstructure:"permitWithoutStream" json:"permitWithoutStream,default=false"` // 允许无流保活
}

type Locker struct {
	Redis *RedisConnectOptions `mapstructure:"redis"`
}

type Logger struct {
	Type            string `mapstructure:"type"`            // zap，logrus，或自研，无用删除by jiyuanjje
	Path            string `mapstructure:"path"`            // 日志文件路径
	Level           string `mapstructure:"level"`           // 日志级别
	Stdout          bool   `mapstructure:"stdout"`          // 是否输出到标准控制台（true：输出，false：不输出）
	MaxSize         int    `mapstructure:"maxsize"`         // 每个日志文件最大多少MB，一般设置50MB add by jiyuanjje
	ErrorMaxAge     int    `mapstructure:"errormaxage"`     // error日志文件保留天数，一般设置14天 add by jiyuanjje
	InfoMaxAge      int    `mapstructure:"infomaxage"`      // info日志文件保留天数，一般设置3天 add by jiyuanjje
	MaxBackups      int    `mapstructure:"maxbackups"`      // 日志文件保留个数，一般设置20个 add by jiyuanjje
	EnabledDB       bool   `mapstructure:"enableddb"`       // 是否启用数据库日志(true：启用，false：不启用)
	GormLoggerLevel int    `mapstructure:"gormloggerlevel"` // 数据库日志打印级别（4：Info，3 Warn，2 Error，1 Silent）add by jiyuanjie
}

type MemoryConfig struct {
	MaxChannelSize int `mapstructure:"maxChannelSize"` // 最大通道大小
	BufferSize     int `mapstructure:"bufferSize"`     // 缓冲区大小
}

type MetricsConfig struct {
	Enabled         bool          `mapstructure:"enabled"`
	CollectInterval time.Duration `mapstructure:"collectInterval"`
	ExportEndpoint  string        `mapstructure:"exportEndpoint"`
}

type NATSConfig struct {
	URLs              []string           `mapstructure:"urls"`              // NATS服务器地址
	ClientID          string             `mapstructure:"clientId"`          // 客户端ID
	MaxReconnects     int                `mapstructure:"maxReconnects"`     // 最大重连次数
	ReconnectWait     time.Duration      `mapstructure:"reconnectWait"`     // 重连等待时间
	ConnectionTimeout time.Duration      `mapstructure:"connectionTimeout"` // 连接超时
	JetStream         JetStreamConfig    `mapstructure:"jetstream"`         // JetStream配置
	Security          NATSSecurityConfig `mapstructure:"security"`          // NATS安全配置
}

type NATSConsumerConfig struct {
	DurableName   string          `mapstructure:"durableName"`
	DeliverPolicy string          `mapstructure:"deliverPolicy"` // all, last, new, by_start_sequence, by_start_time
	AckPolicy     string          `mapstructure:"ackPolicy"`     // none, all, explicit
	ReplayPolicy  string          `mapstructure:"replayPolicy"`  // instant, original
	MaxAckPending int             `mapstructure:"maxAckPending"`
	MaxWaiting    int             `mapstructure:"maxWaiting"`
	MaxDeliver    int             `mapstructure:"maxDeliver"`
	BackOff       []time.Duration `mapstructure:"backOff"`
}

type NATSSecurityConfig struct {
	Enabled    bool   `mapstructure:"enabled"`
	Token      string `mapstructure:"token"`
	Username   string `mapstructure:"username"`
	Password   string `mapstructure:"password"`
	NKeyFile   string `mapstructure:"nkeyFile"`
	CredFile   string `mapstructure:"credFile"`
	CertFile   string `mapstructure:"certFile"`
	KeyFile    string `mapstructure:"keyFile"`
	CAFile     string `mapstructure:"caFile"`
	SkipVerify bool   `mapstructure:"skipVerify"`
}

type NSQOptions struct {
	DialTimeout time.Duration `opt:"dial_timeout" default:"1s"`

	// Deadlines for network reads and writes
	ReadTimeout  time.Duration `opt:"read_timeout" min:"100ms" max:"5m" default:"60s"`
	WriteTimeout time.Duration `opt:"write_timeout" min:"100ms" max:"5m" default:"1s"`

	// Addresses is the local address to use when dialing an nsqd.
	Addresses []string `opt:"addresses"`

	// Duration between polling lookupd for new producers, and fractional jitter to add to
	// the lookupd pool loop. this helps evenly distribute requests even if multiple consumers
	// restart at the same time
	//
	// NOTE: when not using nsqlookupd, LookupdPollInterval represents the duration of time between
	// reconnection attempts
	LookupdPollInterval time.Duration `opt:"lookupd_poll_interval" min:"10ms" max:"5m" default:"60s"`
	LookupdPollJitter   float64       `opt:"lookupd_poll_jitter" min:"0" max:"1" default:"0.3"`

	// Maximum duration when REQueueing (for doubling of deferred requeue)
	MaxRequeueDelay     time.Duration `opt:"max_requeue_delay" min:"0" max:"60m" default:"15m"`
	DefaultRequeueDelay time.Duration `opt:"default_requeue_delay" min:"0" max:"60m" default:"90s"`

	// Maximum amount of time to backoff when processing fails 0 == no backoff
	MaxBackoffDuration time.Duration `opt:"max_backoff_duration" min:"0" max:"60m" default:"2m"`
	// Unit of time for calculating consumer backoff
	BackoffMultiplier time.Duration `opt:"backoff_multiplier" min:"0" max:"60m" default:"1s"`

	// Maximum number of times this consumer will attempt to process a message before giving up
	MaxAttempts uint16 `opt:"max_attempts" min:"0" max:"65535" default:"5"`

	// Duration to wait for a message from an nsqd when in a state where RDY
	// counts are re-distributed (e.g. max_in_flight < num_producers)
	LowRdyIdleTimeout time.Duration `opt:"low_rdy_idle_timeout" min:"1s" max:"5m" default:"10s"`
	// Duration to wait until redistributing RDY for an nsqd regardless of LowRdyIdleTimeout
	LowRdyTimeout time.Duration `opt:"low_rdy_timeout" min:"1s" max:"5m" default:"30s"`
	// Duration between redistributing max-in-flight to connections
	RDYRedistributeInterval time.Duration `opt:"rdy_redistribute_interval" min:"1ms" max:"5s" default:"5s"`

	// Identifiers sent to nsqd representing this client
	// UserAgent is in the spirit of HTTP (default: "<client_library_name>/<version>")
	ClientID  string `opt:"client_id"` // (defaults: short hostname)
	Hostname  string `opt:"hostname"`
	UserAgent string `opt:"user_agent"`

	// Duration of time between heartbeats. This must be less than ReadTimeout
	HeartbeatInterval time.Duration `opt:"heartbeat_interval" default:"30s"`
	// Integer percentage to sample the channel (requires nsqd 0.2.25+)
	SampleRate int32 `opt:"sample_rate" min:"0" max:"99"`

	Tls *Tls `yaml:"tls" json:"tls"`

	// Compression Settings
	Deflate      bool `opt:"deflate"`
	DeflateLevel int  `opt:"deflate_level" min:"1" max:"9" default:"6"`
	Snappy       bool `opt:"snappy"`

	// Size of the buffer (in bytes) used by nsqd for buffering writes to this connection
	OutputBufferSize int64 `opt:"output_buffer_size" default:"16384"`
	// Timeout used by nsqd before flushing buffered writes (set to 0 to disable).
	//
	// WARNING: configuring clients with an extremely low
	// (< 25ms) output_buffer_timeout has a significant effect
	// on nsqd CPU usage (particularly with > 50 clients connected).
	OutputBufferTimeout time.Duration `opt:"output_buffer_timeout" default:"250ms"`

	// Maximum number of messages to allow in flight (concurrency knob)
	MaxInFlight int `opt:"max_in_flight" min:"0" default:"1"`

	// The server-side message timeout for messages delivered to this client
	MsgTimeout time.Duration `opt:"msg_timeout" min:"0"`

	// secret for nsqd authentication (requires nsqd 0.2.29+)
	AuthSecret string `opt:"auth_secret"`
}

type PortRange struct {
	Start int `mapstructure:"start" yaml:"start"`
	End   int `mapstructure:"end" yaml:"end"`
}

type ProducerConfig struct {
	RequiredAcks   int           `mapstructure:"requiredAcks"`   // 消息确认级别 (0=不确认, 1=leader确认, -1=所有副本确认)
	FlushFrequency time.Duration `mapstructure:"flushFrequency"` // 刷新频率
	FlushMessages  int           `mapstructure:"flushMessages"`  // 批量消息数
	Timeout        time.Duration `mapstructure:"timeout"`        // 发送超时时间

}

type PublisherBacklogDetectionConfig struct {
	Enabled           bool          `mapstructure:"enabled"`
	MaxQueueDepth     int64         `mapstructure:"maxQueueDepth"`     // 最大队列深度
	MaxPublishLatency time.Duration `mapstructure:"maxPublishLatency"` // 最大发送延迟
	RateThreshold     float64       `mapstructure:"rateThreshold"`     // 发送速率阈值 (msg/sec)
	CheckInterval     time.Duration `mapstructure:"checkInterval"`     // 检测间隔
}

type PublisherConfig struct {
	// 重连配置
	MaxReconnectAttempts int           `mapstructure:"maxReconnectAttempts"` // 最大重连尝试次数（默认5次）
	InitialBackoff       time.Duration `mapstructure:"initialBackoff"`       // 初始退避时间（默认1秒）
	MaxBackoff           time.Duration `mapstructure:"maxBackoff"`           // 最大退避时间（默认30秒）

	// 发布配置
	PublishTimeout time.Duration `mapstructure:"publishTimeout"` // 发布超时（默认10秒）

	// 企业特性
	BacklogDetection PublisherBacklogDetectionConfig `mapstructure:"backlogDetection"` // 发送端积压检测
	RateLimit        RateLimitConfig                 `mapstructure:"rateLimit"`        // 流量控制
	ErrorHandling    ErrorHandlingConfig             `mapstructure:"errorHandling"`    // 错误处理
}

type Queue struct {
	Redis  *QueueRedis  `mapstructure:"redis"`
	Memory *QueueMemory `mapstructure:"memory"`
	NSQ    *QueueNSQ    `mapstructure:"nsq" json:"nsq"`
}

type QueueMemory struct {
	PoolSize uint
}

type QueueNSQ struct {
	NSQOptions    // opt: tags — decoded by opt, not mapstructure; defer squash until NSQOptions gains mapstructure tags
	ChannelPrefix string
}

type QueueRedis struct {
	RedisConnectOptions `mapstructure:",squash"`
	Producer            *queue.ProducerConfig
	Consumer            *queue.ConsumerConfig
}

type RateLimitConfig struct {
	Enabled       bool    `mapstructure:"enabled"`
	RatePerSecond float64 `mapstructure:"ratePerSecond"`
	BurstSize     int     `mapstructure:"burstSize"`
}

type Redis struct {
	Addr     string `mapstructure:"addr"`
	Password string `mapstructure:"password"`
	DB       int    `mapstructure:"db"`
}

type RedisConnectOptions struct {
	Network    string `mapstructure:"network" json:"network"`
	Addr       string `mapstructure:"addr" json:"addr"`
	Username   string `mapstructure:"username" json:"username"`
	Password   string `mapstructure:"password" json:"password"`
	DB         int    `mapstructure:"db" json:"db"`
	PoolSize   int    `mapstructure:"pool_size" json:"pool_size"`
	Tls        *Tls   `mapstructure:"tls" json:"tls"`
	MaxRetries int    `mapstructure:"max_retries" json:"max_retries"`

	// Sentinel（可选）。MasterName 非空 => NewFailoverClient；空 => 保持单点行为。
	MasterName       string   `mapstructure:"master_name" json:"master_name"`
	SentinelAddrs    []string `mapstructure:"sentinel_addrs" json:"sentinel_addrs"`
	SentinelPassword string   `mapstructure:"sentinel_password" json:"sentinel_password"`
}

type RedisHealth struct {
	// contains filtered or unexported fields
}

type Register struct {
	Sources  []string `mapstructure:"sources"`
	Replicas []string `mapstructure:"replicas"`
	Policy   string   `mapstructure:"policy"`
	Tables   []string `mapstructure:"tables"`
}

type ResolverConfig struct {
	HTTP HTTPResolverConfig `mapstructure:"http" yaml:"http"` // HTTP 识别配置
	FTP  FTPResolverConfig  `mapstructure:"ftp" yaml:"ftp"`   // FTP 识别配置
}

type SSL struct {
	KeyStr string `mapstructure:"key_str"` // 私钥内容（字符串形式）
	Pem    string `mapstructure:"pem"`     // 证书内容（PEM格式，字符串形式）
	Enable bool   `mapstructure:"enable"`  // 是否启用安全连接
	Domain string `mapstructure:"domain"`  // 证书域名（用于生成证书）
}

type SSLConfig struct {
	Enabled bool   `mapstructure:"enabled" json:"enabled"` // 是否启用HTTPS
	KeyStr  string `mapstructure:"key_str"`                // 私钥内容（字符串形式）
	Pem     string `mapstructure:"pem"`                    // 证书内容（PEM格式，字符串形式）
	Domain  string `mapstructure:"domain"`                 // 证书域名（用于生成证书）
}

type SecurityConfig struct {
	Enabled  bool   `mapstructure:"enabled"`
	Protocol string `mapstructure:"protocol"`
	Username string `mapstructure:"username"`
	Password string `mapstructure:"password"`
	CertFile string `mapstructure:"certFile"`
	KeyFile  string `mapstructure:"keyFile"`
	CAFile   string `mapstructure:"caFile"`
}

type ServerMiddlewaresConfig struct {
	Trace      bool `mapstructure:"trace" json:"trace,default=true"`           // 链路跟踪
	Recover    bool `mapstructure:"recover" json:"recover,default=true"`       // 异常恢复
	Stat       bool `mapstructure:"stat" json:"stat,default=true"`             // 统计
	Prometheus bool `mapstructure:"prometheus" json:"prometheus,default=true"` // Prometheus监控
	Breaker    bool `mapstructure:"breaker" json:"breaker,default=true"`       // 熔断器
}

type ServiceConfig struct {
	Enabled      bool     `mapstructure:"enabled" json:"enabled,default=true"`       // 服务启用状态
	Interceptors []string `mapstructure:"interceptors" json:"interceptors,optional"` // 拦截器列表
}

type StorageConfig struct {
	StorageSiteNo string `mapstructure:"storage_site_no" yaml:"storage_site_no"` // 标识当前部署/站点
	PublicUrl     string `mapstructure:"public_url" yaml:"public_url"`           // 外部 HTTP URL 覆盖（如 "http://storage.jxt.com"），空则自动拼接
	RootPath      string `mapstructure:"root_path" yaml:"root_path"`             // 根存储路径
	TempPath      string `mapstructure:"temp_path" yaml:"temp_path"`             // 临时文件路径
}

type StreamConfig struct {
	Name      string        `mapstructure:"name"`
	Subjects  []string      `mapstructure:"subjects"`
	Retention string        `mapstructure:"retention"` // limits, interest, workqueue
	Storage   string        `mapstructure:"storage"`   // file, memory
	Replicas  int           `mapstructure:"replicas"`
	MaxAge    time.Duration `mapstructure:"maxAge"`
	MaxBytes  int64         `mapstructure:"maxBytes"`
	MaxMsgs   int64         `mapstructure:"maxMsgs"`
	Discard   string        `mapstructure:"discard"` // old, new
}

type SubscriberBacklogDetectionConfig struct {
	Enabled          bool          `mapstructure:"enabled"`
	MaxLagThreshold  int64         `mapstructure:"maxLagThreshold"`  // 最大消息积压数量
	MaxTimeThreshold time.Duration `mapstructure:"maxTimeThreshold"` // 最大积压时间
	CheckInterval    time.Duration `mapstructure:"checkInterval"`    // 检测间隔
}

type SubscriberConfig struct {
	// 消费配置
	MaxConcurrency int           `mapstructure:"maxConcurrency"` // 最大并发数（默认10）
	ProcessTimeout time.Duration `mapstructure:"processTimeout"` // 处理超时（默认30秒）

	// 企业特性
	BacklogDetection SubscriberBacklogDetectionConfig `mapstructure:"backlogDetection"` // 订阅端积压检测
	RateLimit        RateLimitConfig                  `mapstructure:"rateLimit"`        // 流量控制
	ErrorHandling    ErrorHandlingConfig              `mapstructure:"errorHandling"`    // 错误处理
}

type TLSConfig struct {
	Enabled bool   `mapstructure:"enabled" json:"enabled,optional"` // 是否启用TLS
	KeyStr  string `mapstructure:"key_str" json:"key_str,optional"` // 私钥内容
	Pem     string `mapstructure:"pem" json:"pem,optional"`         // 证书内容
	Domain  string `mapstructure:"domain" json:"domain,optional"`   // 证书域名
}

type TenantDatabaseDetailConfig struct {
	Driver          string `mapstructure:"driver" yaml:"driver"`                         // 数据库驱动: postgres | mysql
	Host            string `mapstructure:"host" yaml:"host"`                             // 数据库主机
	Port            int    `mapstructure:"port" yaml:"port"`                             // 数据库端口
	Database        string `mapstructure:"database" yaml:"database"`                     // 数据库名称
	Username        string `mapstructure:"username" yaml:"username"`                     // 数据库用户
	Password        string `mapstructure:"password" yaml:"password"`                     // 数据库密码
	SSLMode         string `mapstructure:"sslmode" yaml:"sslmode"`                       // SSL 模式: disable | require | verify-ca | verify-full
	MaxOpenConns    int    `mapstructure:"max_open_conns" yaml:"max_open_conns"`         // 最大打开连接数
	MaxIdleConns    int    `mapstructure:"max_idle_conns" yaml:"max_idle_conns"`         // 最大空闲连接数
	ConnMaxIdleTime int    `mapstructure:"conn_max_idle_time" yaml:"conn_max_idle_time"` // 连接最大空闲时间（秒）
	ConnMaxLifeTime int    `mapstructure:"conn_max_life_time" yaml:"conn_max_life_time"` // 连接最大生命周期（秒）
	ConnectTimeout  int    `mapstructure:"connect_timeout" yaml:"connect_timeout"`       // 连接超时（秒）
	ReadTimeout     int    `mapstructure:"read_timeout" yaml:"read_timeout"`             // 读超时（秒）
	WriteTimeout    int    `mapstructure:"write_timeout" yaml:"write_timeout"`           // 写超时（秒）
}

type TenantDomainConfig struct {
	Primary  string   `mapstructure:"primary" yaml:"primary"`   // 主域名（必填）
	Aliases  []string `mapstructure:"aliases" yaml:"aliases"`   // 备用域名（可选）
	Internal string   `mapstructure:"internal" yaml:"internal"` // 内部调用域名（可选）
}

type TenantFTPDetailConfig struct {
	Username        string `mapstructure:"username" yaml:"username"`                 // FTP 用户名
	InitialPassword string `mapstructure:"initial_password" yaml:"initial_password"` // 初始密码（首次创建时使用）
	Description     string `mapstructure:"description" yaml:"description"`           // FTP 配置描述（用于标识不同 FTP）
	Status          string `mapstructure:"status" yaml:"status"`                     // 状态: active, inactive
}

type TenantStorageDetailConfig struct {
	UploadQuotaGB        int `mapstructure:"upload_quota_gb" yaml:"upload_quota_gb"`               // 上传配额（GB）
	MaxFileSizeMB        int `mapstructure:"max_file_size_mb" yaml:"max_file_size_mb"`             // 单文件最大大小（MB）
	MaxConcurrentUploads int `mapstructure:"max_concurrent_uploads" yaml:"max_concurrent_uploads"` // 最大并发上传数
}

type TenantWvpDetailConfig struct {
	ApiUrl string `mapstructure:"api_url" yaml:"api_url"` // WVP HTTP API 地址
	Realm  string `mapstructure:"realm" yaml:"realm"`     // SIP 域（用于 HA1 计算）
}

type Tenants struct {
	Resolver ResolverConfig        `mapstructure:"resolver" yaml:"resolver"` // 租户识别配置
	Storage  *TenantsStorageConfig `mapstructure:"storage" yaml:"storage"`   // 多租户存储配置
	Default  *DefaultTenantConfig  `mapstructure:"default" yaml:"default"`   // 默认租户配置
}

type TenantsStorageConfig struct {
	Directory string `mapstructure:"directory" yaml:"directory"` // 租户存储目录名（默认: tenants）
}

type Tls struct {
	Cert string `mapstructure:"cert" json:"cert"`
	Key  string `mapstructure:"key" json:"key"`
	Ca   string `mapstructure:"ca" json:"ca"`
}

type TracingConfig struct {
	Enabled     bool    `mapstructure:"enabled"`
	ServiceName string  `mapstructure:"serviceName"`
	Endpoint    string  `mapstructure:"endpoint"`
	SampleRate  float64 `mapstructure:"sampleRate"`
}