tyapi-server/internal/container/container.go

package container

import (
	"context"
	"fmt"
	"time"

	"go.uber.org/fx"
	"go.uber.org/zap"
	"go.uber.org/zap/zapcore"
	"gorm.io/gorm"

	"tyapi-server/internal/application/article"
	"tyapi-server/internal/application/certification"
	"tyapi-server/internal/application/finance"
	"tyapi-server/internal/application/product"
	"tyapi-server/internal/application/statistics"
	"tyapi-server/internal/application/user"
	"tyapi-server/internal/config"
	api_repositories "tyapi-server/internal/domains/api/repositories"
	domain_article_repo "tyapi-server/internal/domains/article/repositories"
	article_service "tyapi-server/internal/domains/article/services"
	domain_certification_repo "tyapi-server/internal/domains/certification/repositories"
	certification_service "tyapi-server/internal/domains/certification/services"
	domain_finance_repo "tyapi-server/internal/domains/finance/repositories"
	finance_service "tyapi-server/internal/domains/finance/services"
	domain_product_repo "tyapi-server/internal/domains/product/repositories"
	product_service "tyapi-server/internal/domains/product/services"
	statistics_service "tyapi-server/internal/domains/statistics/services"
	user_service "tyapi-server/internal/domains/user/services"
	"tyapi-server/internal/infrastructure/cache"
	"tyapi-server/internal/infrastructure/database"
	article_repo "tyapi-server/internal/infrastructure/database/repositories/article"
	certification_repo "tyapi-server/internal/infrastructure/database/repositories/certification"
	finance_repo "tyapi-server/internal/infrastructure/database/repositories/finance"
	product_repo "tyapi-server/internal/infrastructure/database/repositories/product"
	infra_events "tyapi-server/internal/infrastructure/events"
	"tyapi-server/internal/infrastructure/external/alicloud"
	"tyapi-server/internal/infrastructure/external/email"
	"tyapi-server/internal/infrastructure/external/ocr"
	"tyapi-server/internal/infrastructure/external/sms"
	"tyapi-server/internal/infrastructure/external/storage"
	"tyapi-server/internal/infrastructure/external/tianyancha"
	"tyapi-server/internal/infrastructure/external/westdex"
	"tyapi-server/internal/infrastructure/external/xingwei"
	"tyapi-server/internal/infrastructure/external/yushan"
	"tyapi-server/internal/infrastructure/external/zhicha"
	"tyapi-server/internal/infrastructure/http/handlers"
	"tyapi-server/internal/infrastructure/http/routes"
	"tyapi-server/internal/infrastructure/task"
	task_implementations "tyapi-server/internal/infrastructure/task/implementations"
	asynq "tyapi-server/internal/infrastructure/task/implementations/asynq"
	task_interfaces "tyapi-server/internal/infrastructure/task/interfaces"
	task_repositories "tyapi-server/internal/infrastructure/task/repositories"
	shared_database "tyapi-server/internal/shared/database"
	"tyapi-server/internal/shared/esign"
	shared_events "tyapi-server/internal/shared/events"
	"tyapi-server/internal/shared/export"
	"tyapi-server/internal/shared/health"
	"tyapi-server/internal/shared/hooks"
	sharedhttp "tyapi-server/internal/shared/http"
	"tyapi-server/internal/shared/interfaces"
	"tyapi-server/internal/shared/logger"
	"tyapi-server/internal/shared/metrics"
	"tyapi-server/internal/shared/middleware"
	sharedOCR "tyapi-server/internal/shared/ocr"
	"tyapi-server/internal/shared/payment"
	"tyapi-server/internal/shared/resilience"
	"tyapi-server/internal/shared/saga"
	"tyapi-server/internal/shared/tracing"
	"tyapi-server/internal/shared/validator"

	domain_user_repo "tyapi-server/internal/domains/user/repositories"
	user_repo "tyapi-server/internal/infrastructure/database/repositories/user"

	hibiken_asynq "github.com/hibiken/asynq"
	"github.com/redis/go-redis/v9"

	api_app "tyapi-server/internal/application/api"
	domain_api_repo "tyapi-server/internal/domains/api/repositories"
	api_services "tyapi-server/internal/domains/api/services"
	finance_services "tyapi-server/internal/domains/finance/services"
	product_services "tyapi-server/internal/domains/product/services"
	domain_statistics_repo "tyapi-server/internal/domains/statistics/repositories"
	user_repositories "tyapi-server/internal/domains/user/repositories"
	api_repo "tyapi-server/internal/infrastructure/database/repositories/api"
	statistics_repo "tyapi-server/internal/infrastructure/database/repositories/statistics"
)

// Container 应用容器
type Container struct {
	App *fx.App
}

// NewContainer 创建新的应用容器
func NewContainer() *Container {
	app := fx.New(
		// 配置模块
		fx.Provide(
			config.LoadConfig,
		),

		// 基础设施模块
		fx.Provide(
			// 日志器 - 提供自定义Logger和*zap.Logger
			func(cfg *config.Config) (logger.Logger, error) {
				// 将 config.LoggerConfig 转换为 logger.Config
				// 转换 LevelConfigs 类型
				levelConfigs := make(map[string]interface{})
				for key, value := range cfg.Logger.LevelConfigs {
					levelConfigs[key] = value
				}

				logCfg := logger.Config{
					Level:                 cfg.Logger.Level,
					Format:                cfg.Logger.Format,
					Output:                cfg.Logger.Output,
					LogDir:                cfg.Logger.LogDir,
					MaxSize:               cfg.Logger.MaxSize,
					MaxBackups:            cfg.Logger.MaxBackups,
					MaxAge:                cfg.Logger.MaxAge,
					Compress:              cfg.Logger.Compress,
					UseDaily:              cfg.Logger.UseDaily,
					UseColor:              cfg.Logger.UseColor,
					EnableLevelSeparation: cfg.Logger.EnableLevelSeparation,
					LevelConfigs:          levelConfigs,
					Development:           cfg.App.Env == "development",
				}

				// 初始化全局日志器
				if err := logger.InitGlobalLogger(logCfg); err != nil {
					return nil, err
				}

				if cfg.Logger.EnableLevelSeparation {
					// 使用按级别分文件的日志器
					levelConfig := logger.LevelLoggerConfig{
						BaseConfig:            logCfg,
						EnableLevelSeparation: true,
						LevelConfigs:          convertLevelConfigs(cfg.Logger.LevelConfigs),
					}
					return logger.NewLevelLogger(levelConfig)
				} else {
					// 使用普通日志器
					return logger.NewLogger(logCfg)
				}
			},
			// 提供普通的*zap.Logger（用于大多数场景）
			fx.Annotate(
				func(log logger.Logger) *zap.Logger {
					// 尝试转换为ZapLogger
					if zapLogger, ok := log.(*logger.ZapLogger); ok {
						return zapLogger.GetZapLogger()
					}
					// 尝试转换为LevelLogger
					if levelLogger, ok := log.(*logger.LevelLogger); ok {
						// 获取Info级别的日志器作为默认
						if infoLogger := levelLogger.GetLevelLogger(zapcore.InfoLevel); infoLogger != nil {
							return infoLogger
						}
					}
					// 如果类型转换失败，使用全局日志器
					return logger.GetGlobalLogger()
				},
			),

			// 数据库连接
			func(cfg *config.Config, cacheService interfaces.CacheService, logger *zap.Logger) (*gorm.DB, error) {
				dbCfg := database.Config{
					Host:            cfg.Database.Host,
					Port:            cfg.Database.Port,
					User:            cfg.Database.User,
					Password:        cfg.Database.Password,
					Name:            cfg.Database.Name,
					SSLMode:         cfg.Database.SSLMode,
					Timezone:        cfg.Database.Timezone,
					MaxOpenConns:    cfg.Database.MaxOpenConns,
					MaxIdleConns:    cfg.Database.MaxIdleConns,
					ConnMaxLifetime: cfg.Database.ConnMaxLifetime,
				}
				db, err := database.NewConnection(dbCfg)
				if err != nil {
					logger.Error("数据库连接失败",
						zap.String("host", cfg.Database.Host),
						zap.String("port", cfg.Database.Port),
						zap.String("database", cfg.Database.Name),
						zap.String("user", cfg.Database.User),
						zap.Error(err))
					return nil, err
				}

				logger.Info("数据库连接成功",
					zap.String("host", cfg.Database.Host),
					zap.String("port", cfg.Database.Port),
					zap.String("database", cfg.Database.Name))

				// 设置GORM缓存插件
				if err := SetupGormCache(db.DB, cacheService, cfg, logger); err != nil {
					logger.Warn("GORM缓存插件设置失败", zap.Error(err))
					// 不返回错误，允许系统在没有缓存的情况下运行
				}

				return db.DB, nil
			},
			// Redis客户端
			NewRedisClient,
			// 缓存服务
			fx.Annotate(NewRedisCache, fx.As(new(interfaces.CacheService))),
			// 事件总线
			// 提供workerCount参数
			func() int {
				return 5 // 默认5个工作协程
			},
			fx.Annotate(
				shared_events.NewMemoryEventBus,
				fx.As(new(interfaces.EventBus)),
			),
			// 健康检查
			health.NewHealthChecker,
			// 提供 config.SMSConfig
			func(cfg *config.Config) config.SMSConfig {
				return cfg.SMS
			},
			// 提供 config.AppConfig
			func(cfg *config.Config) config.AppConfig {
				return cfg.App
			},
			// 事务管理器
			func(db *gorm.DB, logger *zap.Logger) *shared_database.TransactionManager {
				return shared_database.NewTransactionManager(db, logger)
			},
			// 短信服务
			sms.NewAliSMSService,
			// 邮件服务
			fx.Annotate(
				func(cfg *config.Config, logger *zap.Logger) *email.QQEmailService {
					return email.NewQQEmailService(cfg.Email, logger)
				},
			),
			// 存储服务
			fx.Annotate(
				func(cfg *config.Config, logger *zap.Logger) *storage.QiNiuStorageService {
					return storage.NewQiNiuStorageService(
						cfg.Storage.AccessKey,
						cfg.Storage.SecretKey,
						cfg.Storage.Bucket,
						cfg.Storage.Domain,
						logger,
					)
				},
			),
			// OCR服务
			fx.Annotate(
				func(cfg *config.Config, logger *zap.Logger) *ocr.BaiduOCRService {
					return ocr.NewBaiduOCRService(
						cfg.OCR.APIKey,
						cfg.OCR.SecretKey,
						logger,
					)
				},
				fx.As(new(sharedOCR.OCRService)),
			),
			// e签宝配置
			func(cfg *config.Config) (*esign.Config, error) {
				return esign.NewConfig(
					cfg.Esign.AppID,
					cfg.Esign.AppSecret,
					cfg.Esign.ServerURL,
					cfg.Esign.TemplateID,
					&esign.EsignContractConfig{
						Name:       cfg.Esign.Contract.Name,
						ExpireDays: cfg.Esign.Contract.ExpireDays,
						RetryCount: cfg.Esign.Contract.RetryCount,
					},
					&esign.EsignAuthConfig{
						OrgAuthModes:         cfg.Esign.Auth.OrgAuthModes,
						DefaultAuthMode:      cfg.Esign.Auth.DefaultAuthMode,
						PsnAuthModes:         cfg.Esign.Auth.PsnAuthModes,
						WillingnessAuthModes: cfg.Esign.Auth.WillingnessAuthModes,
						RedirectUrl:          cfg.Esign.Auth.RedirectURL,
					},
					&esign.EsignSignConfig{
						AutoFinish:     cfg.Esign.Sign.AutoFinish,
						SignFieldStyle: cfg.Esign.Sign.SignFieldStyle,
						ClientType:     cfg.Esign.Sign.ClientType,
						RedirectUrl:    cfg.Esign.Sign.RedirectURL,
					},
				)
			},
			// e签宝服务
			func(esignConfig *esign.Config) *esign.Client {
				return esign.NewClient(esignConfig)
			},
			// 支付宝支付服务
			func(cfg *config.Config) *payment.AliPayService {
				config := payment.AlipayConfig{
					AppID:           cfg.AliPay.AppID,
					PrivateKey:      cfg.AliPay.PrivateKey,
					AlipayPublicKey: cfg.AliPay.AlipayPublicKey,
					IsProduction:    cfg.AliPay.IsProduction,
					NotifyUrl:       cfg.AliPay.NotifyURL,
					ReturnURL:       cfg.AliPay.ReturnURL,
				}
				return payment.NewAliPayService(config)
			},
			// 导出管理器
			func(logger *zap.Logger) *export.ExportManager {
				return export.NewExportManager(logger)
			},
		),

		// 高级特性模块
		fx.Provide(
			// 提供TracerConfig
			func(cfg *config.Config) tracing.TracerConfig {
				return tracing.TracerConfig{
					ServiceName:    cfg.App.Name,
					ServiceVersion: cfg.App.Version,
					Environment:    cfg.App.Env,
					Endpoint:       cfg.Monitoring.TracingEndpoint,
					SampleRate:     cfg.Monitoring.SampleRate,
					Enabled:        cfg.Monitoring.TracingEnabled,
				}
			},
			tracing.NewTracer,
			metrics.NewPrometheusMetrics,
			metrics.NewBusinessMetrics,
			resilience.NewWrapper,
			resilience.NewRetryerWrapper,
			saga.NewSagaManager,
			hooks.NewHookSystem,
		),

		// HTTP基础组件
		fx.Provide(
			sharedhttp.NewResponseBuilder,
			validator.NewRequestValidator,
			// WestDexService - 需要从配置中获取参数
			func(cfg *config.Config) (*westdex.WestDexService, error) {
				return westdex.NewWestDexServiceWithConfig(cfg)
			},
			// ZhichaService - 智查金控服务
			func(cfg *config.Config) (*zhicha.ZhichaService, error) {
				return zhicha.NewZhichaServiceWithConfig(cfg)
			},
			// XingweiService - 行为数据服务
			func(cfg *config.Config) (*xingwei.XingweiService, error) {
				return xingwei.NewXingweiServiceWithConfig(cfg)
			},
			func(cfg *config.Config) *yushan.YushanService {
				return yushan.NewYushanService(
					cfg.Yushan.URL,
					cfg.Yushan.APIKey,
					cfg.Yushan.AcctID,
					nil, // 暂时不传入logger，使用无日志版本
				)
			},
			// TianYanChaService - 天眼查服务
			func(cfg *config.Config) *tianyancha.TianYanChaService {
				return tianyancha.NewTianYanChaService(
					cfg.TianYanCha.BaseURL, // 天眼查API基础URL
					cfg.TianYanCha.APIKey,
					30*time.Second, // 默认超时时间
				)
			},
			// AlicloudService - 阿里云服务
			func(cfg *config.Config) *alicloud.AlicloudService {
				return alicloud.NewAlicloudService(
					cfg.Alicloud.Host,
					cfg.Alicloud.AppCode,
				)
			},
			sharedhttp.NewGinRouter,
		),

		// 中间件组件
		fx.Provide(
			middleware.NewRequestIDMiddleware,
			middleware.NewSecurityHeadersMiddleware,
			middleware.NewResponseTimeMiddleware,
			middleware.NewCORSMiddleware,
			middleware.NewRateLimitMiddleware,
			// 每日限流中间件
			func(cfg *config.Config, redis *redis.Client, response interfaces.ResponseBuilder, logger *zap.Logger) *middleware.DailyRateLimitMiddleware {
				limitConfig := middleware.DailyRateLimitConfig{
					MaxRequestsPerDay: cfg.DailyRateLimit.MaxRequestsPerDay,
					MaxRequestsPerIP:  cfg.DailyRateLimit.MaxRequestsPerIP,
					KeyPrefix:         cfg.DailyRateLimit.KeyPrefix,
					TTL:               cfg.DailyRateLimit.TTL,
					MaxConcurrent:     cfg.DailyRateLimit.MaxConcurrent,
					// 安全配置
					EnableIPWhitelist: cfg.DailyRateLimit.EnableIPWhitelist,
					IPWhitelist:       cfg.DailyRateLimit.IPWhitelist,
					EnableIPBlacklist: cfg.DailyRateLimit.EnableIPBlacklist,
					IPBlacklist:       cfg.DailyRateLimit.IPBlacklist,
					EnableUserAgent:   cfg.DailyRateLimit.EnableUserAgent,
					BlockedUserAgents: cfg.DailyRateLimit.BlockedUserAgents,
					EnableReferer:     cfg.DailyRateLimit.EnableReferer,
					AllowedReferers:   cfg.DailyRateLimit.AllowedReferers,
					EnableGeoBlock:    cfg.DailyRateLimit.EnableGeoBlock,
					BlockedCountries:  cfg.DailyRateLimit.BlockedCountries,
					EnableProxyCheck:  cfg.DailyRateLimit.EnableProxyCheck,
					// 排除路径配置
					ExcludePaths:      cfg.DailyRateLimit.ExcludePaths,
					// 排除域名配置
					ExcludeDomains:    cfg.DailyRateLimit.ExcludeDomains,
				}
				return middleware.NewDailyRateLimitMiddleware(cfg, redis, response, logger, limitConfig)
			},
			NewRequestLoggerMiddlewareWrapper,
			middleware.NewJWTAuthMiddleware,
			middleware.NewOptionalAuthMiddleware,
			middleware.NewAdminAuthMiddleware,
			middleware.NewDomainAuthMiddleware,
			middleware.NewTraceIDMiddleware,
			middleware.NewErrorTrackingMiddleware,
			NewRequestBodyLoggerMiddlewareWrapper,
			// 新增的中间件
			func(logger *zap.Logger) *middleware.PanicRecoveryMiddleware {
				return middleware.NewPanicRecoveryMiddleware(logger)
			},
			func(logger *zap.Logger, cfg *config.Config) *middleware.ComprehensiveLoggerMiddleware {
				config := &middleware.ComprehensiveLoggerConfig{
					EnableRequestLogging:     true,
					EnableResponseLogging:    true,
					EnableRequestBodyLogging: cfg.App.IsDevelopment(), // 开发环境记录请求体
					EnableErrorLogging:       true,
					EnableBusinessLogging:    true,
					EnablePerformanceLogging: true,
					MaxBodySize:              1024 * 10, // 10KB
					ExcludePaths:             []string{"/health", "/metrics", "/favicon.ico", "/swagger"},
				}
				return middleware.NewComprehensiveLoggerMiddleware(logger, config)
			},
			// 业务日志记录器
			func(logger *zap.Logger) *middleware.BusinessLogger {
				return middleware.NewBusinessLogger(logger)
			},
		),

		// 仓储层 - 用户域
		fx.Provide(
			// 用户仓储 - 同时注册具体类型和接口类型
			fx.Annotate(
				user_repo.NewGormUserRepository,
				fx.As(new(domain_user_repo.UserRepository)),
			),

			// 短信验证码仓储 - 同时注册具体类型和接口类型
			fx.Annotate(
				user_repo.NewGormSMSCodeRepository,
				fx.As(new(domain_user_repo.SMSCodeRepository)),
			),
			// 用户信息仓储 - 同时注册具体类型和接口类型
			fx.Annotate(
				user_repo.NewGormEnterpriseInfoRepository,
				fx.As(new(domain_user_repo.EnterpriseInfoRepository)),
			),
			// 合同信息仓储 - 同时注册具体类型和接口类型
			fx.Annotate(
				user_repo.NewGormContractInfoRepository,
				fx.As(new(domain_user_repo.ContractInfoRepository)),
			),
		),

		// 仓储层 - 认证域
		fx.Provide(
			// 认证命令仓储
			fx.Annotate(
				certification_repo.NewGormCertificationCommandRepository,
				fx.As(new(domain_certification_repo.CertificationCommandRepository)),
			),
			// 认证查询仓储
			fx.Annotate(
				certification_repo.NewGormCertificationQueryRepository,
				fx.As(new(domain_certification_repo.CertificationQueryRepository)),
			),
			// 企业信息提交记录仓储
			fx.Annotate(
				certification_repo.NewGormEnterpriseInfoSubmitRecordRepository,
				fx.As(new(domain_certification_repo.EnterpriseInfoSubmitRecordRepository)),
			),
		),

		// 仓储层 - 财务域
		fx.Provide(
			// 钱包仓储
			fx.Annotate(
				finance_repo.NewGormWalletRepository,
				fx.As(new(domain_finance_repo.WalletRepository)),
			),
			// 钱包交易记录仓储
			fx.Annotate(
				finance_repo.NewGormWalletTransactionRepository,
				fx.As(new(domain_finance_repo.WalletTransactionRepository)),
			),
			// 充值记录仓储
			fx.Annotate(
				finance_repo.NewGormRechargeRecordRepository,
				fx.As(new(domain_finance_repo.RechargeRecordRepository)),
			),
			// 支付宝订单仓储
			fx.Annotate(
				finance_repo.NewGormAlipayOrderRepository,
				fx.As(new(domain_finance_repo.AlipayOrderRepository)),
			),
			// 发票申请仓储
			fx.Annotate(
				finance_repo.NewGormInvoiceApplicationRepository,
				fx.As(new(domain_finance_repo.InvoiceApplicationRepository)),
			),
			// 用户开票信息仓储
			fx.Annotate(
				finance_repo.NewGormUserInvoiceInfoRepository,
				fx.As(new(domain_finance_repo.UserInvoiceInfoRepository)),
			),
		),

		// 仓储层 - 产品域
		fx.Provide(
			// 产品仓储 - 同时注册具体类型和接口类型
			fx.Annotate(
				product_repo.NewGormProductRepository,
				fx.As(new(domain_product_repo.ProductRepository)),
			),
			// 产品分类仓储 - 同时注册具体类型和接口类型
			fx.Annotate(
				product_repo.NewGormProductCategoryRepository,
				fx.As(new(domain_product_repo.ProductCategoryRepository)),
			),
			// 订阅仓储 - 同时注册具体类型和接口类型
			fx.Annotate(
				product_repo.NewGormSubscriptionRepository,
				fx.As(new(domain_product_repo.SubscriptionRepository)),
			),
			// 产品API配置仓储 - 同时注册具体类型和接口类型
			fx.Annotate(
				product_repo.NewGormProductApiConfigRepository,
				fx.As(new(domain_product_repo.ProductApiConfigRepository)),
			),
			fx.Annotate(
				product_repo.NewGormProductDocumentationRepository,
				fx.As(new(domain_product_repo.ProductDocumentationRepository)),
			),
		),

		// 仓储层 - 文章域
		fx.Provide(
			// 文章仓储 - 同时注册具体类型和接口类型
			fx.Annotate(
				article_repo.NewGormArticleRepository,
				fx.As(new(domain_article_repo.ArticleRepository)),
			),
			// 分类仓储 - 同时注册具体类型和接口类型
			fx.Annotate(
				article_repo.NewGormCategoryRepository,
				fx.As(new(domain_article_repo.CategoryRepository)),
			),
			// 标签仓储 - 同时注册具体类型和接口类型
			fx.Annotate(
				article_repo.NewGormTagRepository,
				fx.As(new(domain_article_repo.TagRepository)),
			),
			// 定时任务仓储 - 同时注册具体类型和接口类型
			fx.Annotate(
				article_repo.NewGormScheduledTaskRepository,
				fx.As(new(domain_article_repo.ScheduledTaskRepository)),
			),
		),

		// API域仓储层
		fx.Provide(
			fx.Annotate(
				api_repo.NewGormApiUserRepository,
				fx.As(new(domain_api_repo.ApiUserRepository)),
			),
			fx.Annotate(
				api_repo.NewGormApiCallRepository,
				fx.As(new(domain_api_repo.ApiCallRepository)),
			),
		),

		// 统计域仓储层
		fx.Provide(
			fx.Annotate(
				statistics_repo.NewGormStatisticsRepository,
				fx.As(new(domain_statistics_repo.StatisticsRepository)),
			),
			fx.Annotate(
				statistics_repo.NewGormStatisticsReportRepository,
				fx.As(new(domain_statistics_repo.StatisticsReportRepository)),
			),
			fx.Annotate(
				statistics_repo.NewGormStatisticsDashboardRepository,
				fx.As(new(domain_statistics_repo.StatisticsDashboardRepository)),
			),
		),

		// 领域服务
		fx.Provide(
			fx.Annotate(
				user_service.NewUserAggregateService,
			),
			user_service.NewUserAuthService,
			user_service.NewSMSCodeService,
			user_service.NewContractAggregateService,
			product_service.NewProductManagementService,
			product_service.NewProductSubscriptionService,
			product_service.NewProductApiConfigService,
			product_service.NewProductDocumentationService,
			fx.Annotate(
				func(
					apiUserRepo api_repositories.ApiUserRepository,
					userRepo user_repositories.UserRepository,
					enterpriseInfoRepo user_repositories.EnterpriseInfoRepository,
					smsService *sms.AliSMSService,
					config *config.Config,
					logger *zap.Logger,
				) finance_service.BalanceAlertService {
					return finance_service.NewBalanceAlertService(
						apiUserRepo,
						userRepo,
						enterpriseInfoRepo,
						smsService,
						config,
						logger,
					)
				},
			),
			finance_service.NewWalletAggregateService,
			finance_service.NewRechargeRecordService,
			// 发票领域服务
			fx.Annotate(
				finance_service.NewInvoiceDomainService,
			),
			// 用户开票信息服务
			fx.Annotate(
				finance_service.NewUserInvoiceInfoService,
			),
			// 发票事件发布器 - 绑定到接口
			fx.Annotate(
				func(logger *zap.Logger, eventBus interfaces.EventBus) finance_service.EventPublisher {
					return infra_events.NewInvoiceEventPublisher(logger, eventBus)
				},
				fx.As(new(finance_service.EventPublisher)),
			),
			// 发票聚合服务 - 需要用户开票信息仓储
			fx.Annotate(
				func(
					applicationRepo domain_finance_repo.InvoiceApplicationRepository,
					userInvoiceInfoRepo domain_finance_repo.UserInvoiceInfoRepository,
					domainService finance_service.InvoiceDomainService,
					qiniuStorageService *storage.QiNiuStorageService,
					logger *zap.Logger,
					eventPublisher finance_service.EventPublisher,
				) finance_service.InvoiceAggregateService {
					return finance_service.NewInvoiceAggregateService(
						applicationRepo,
						userInvoiceInfoRepo,
						domainService,
						qiniuStorageService,
						logger,
						eventPublisher,
					)
				},
			),
			// 发票事件处理器
			infra_events.NewInvoiceEventHandler,
			certification_service.NewCertificationAggregateService,
			certification_service.NewEnterpriseInfoSubmitRecordService,
			// 文章领域服务
			article_service.NewArticleService,
			// 统计领域服务
			statistics_service.NewStatisticsAggregateService,
			statistics_service.NewStatisticsCalculationService,
			statistics_service.NewStatisticsReportService,
		),

		// API域服务层
		fx.Provide(
			fx.Annotate(
				api_services.NewApiUserAggregateService,
			),
			api_services.NewApiCallAggregateService,
			api_services.NewApiRequestService,
			api_services.NewFormConfigService,
		),

		// API域应用服务
		fx.Provide(
			// API应用服务 - 绑定到接口
			fx.Annotate(
				func(
					apiCallService api_services.ApiCallAggregateService,
					apiUserService api_services.ApiUserAggregateService,
					apiRequestService *api_services.ApiRequestService,
					formConfigService api_services.FormConfigService,
					apiCallRepository domain_api_repo.ApiCallRepository,
					productManagementService *product_services.ProductManagementService,
					userRepo user_repositories.UserRepository,
					txManager *shared_database.TransactionManager,
					config *config.Config,
					logger *zap.Logger,
					contractInfoService user_repositories.ContractInfoRepository,
					taskManager task_interfaces.TaskManager,
					walletService finance_services.WalletAggregateService,
					subscriptionService *product_services.ProductSubscriptionService,
					exportManager *export.ExportManager,
					balanceAlertService finance_services.BalanceAlertService,
				) api_app.ApiApplicationService {
					return api_app.NewApiApplicationService(
						apiCallService,
						apiUserService,
						apiRequestService,
						formConfigService,
						apiCallRepository,
						productManagementService,
						userRepo,
						txManager,
						config,
						logger,
						contractInfoService,
						taskManager,
						walletService,
						subscriptionService,
						exportManager,
						balanceAlertService,
					)
				},
				fx.As(new(api_app.ApiApplicationService)),
			),
		),

		// 任务系统
		fx.Provide(
			// Asynq 客户端 (github.com/hibiken/asynq)
			func(cfg *config.Config) *hibiken_asynq.Client {
				redisAddr := fmt.Sprintf("%s:%s", cfg.Redis.Host, cfg.Redis.Port)
				return hibiken_asynq.NewClient(hibiken_asynq.RedisClientOpt{Addr: redisAddr})
			},
			// 自定义Asynq客户端 (用于文章任务)
			func(cfg *config.Config, scheduledTaskRepo domain_article_repo.ScheduledTaskRepository, logger *zap.Logger) *asynq.AsynqClient {
				redisAddr := fmt.Sprintf("%s:%s", cfg.Redis.Host, cfg.Redis.Port)
				return task.NewAsynqClient(redisAddr, scheduledTaskRepo, logger)
			},
			// 文章任务队列
			func(cfg *config.Config, logger *zap.Logger) task_interfaces.ArticleTaskQueue {
				redisAddr := fmt.Sprintf("%s:%s", cfg.Redis.Host, cfg.Redis.Port)
				return task.NewArticleTaskQueue(redisAddr, logger)
			},
			// AsyncTask 仓库
			task_repositories.NewAsyncTaskRepository,
			// TaskManager - 统一任务管理器
			func(
				asynqClient *hibiken_asynq.Client,
				asyncTaskRepo task_repositories.AsyncTaskRepository,
				logger *zap.Logger,
				config *config.Config,
			) task_interfaces.TaskManager {
				taskConfig := &task_interfaces.TaskManagerConfig{
					RedisAddr:     fmt.Sprintf("%s:%s", config.Redis.Host, config.Redis.Port),
					MaxRetries:    5,
					RetryInterval: 5 * time.Minute,
					CleanupDays:   30,
				}
				return task_implementations.NewTaskManager(asynqClient, asyncTaskRepo, logger, taskConfig)
			},
			// AsynqWorker - 任务处理器
			func(
				cfg *config.Config, 
				logger *zap.Logger, 
				articleApplicationService article.ArticleApplicationService,
				apiApplicationService api_app.ApiApplicationService,
				walletService finance_services.WalletAggregateService,
				subscriptionService *product_services.ProductSubscriptionService,
				asyncTaskRepo task_repositories.AsyncTaskRepository,
			) *asynq.AsynqWorker {
				redisAddr := fmt.Sprintf("%s:%s", cfg.Redis.Host, cfg.Redis.Port)
				return asynq.NewAsynqWorker(
					redisAddr, 
					logger, 
					articleApplicationService,
					apiApplicationService,
					walletService,
					subscriptionService,
					asyncTaskRepo,
				)
			},
		),

		// 应用服务
		fx.Provide(
			// 用户应用服务 - 绑定到接口
			fx.Annotate(
				user.NewUserApplicationService,
				fx.As(new(user.UserApplicationService)),
			),
			// 认证应用服务 - 绑定到接口
			fx.Annotate(
				func(
					aggregateService certification_service.CertificationAggregateService,
					userAggregateService user_service.UserAggregateService,
					queryRepository domain_certification_repo.CertificationQueryRepository,
					enterpriseInfoSubmitRecordRepo domain_certification_repo.EnterpriseInfoSubmitRecordRepository,
					smsCodeService *user_service.SMSCodeService,
					esignClient *esign.Client,
					esignConfig *esign.Config,
					qiniuStorageService *storage.QiNiuStorageService,
					contractAggregateService user_service.ContractAggregateService,
					walletAggregateService finance_services.WalletAggregateService,
					apiUserAggregateService api_services.ApiUserAggregateService,
					enterpriseInfoSubmitRecordService *certification_service.EnterpriseInfoSubmitRecordService,
					ocrService sharedOCR.OCRService,
					txManager *shared_database.TransactionManager,
					logger *zap.Logger,
				) certification.CertificationApplicationService {
					return certification.NewCertificationApplicationService(
						aggregateService,
						userAggregateService,
						queryRepository,
						enterpriseInfoSubmitRecordRepo,
						smsCodeService,
						esignClient,
						esignConfig,
						qiniuStorageService,
						contractAggregateService,
						walletAggregateService,
						apiUserAggregateService,
						enterpriseInfoSubmitRecordService,
						ocrService,
						txManager,
						logger,
					)
				},
				fx.As(new(certification.CertificationApplicationService)),
			),
			// 财务应用服务 - 绑定到接口
			fx.Annotate(
				func(
					aliPayClient *payment.AliPayService,
					walletService finance_services.WalletAggregateService,
					rechargeRecordService finance_services.RechargeRecordService,
					walletTransactionRepo domain_finance_repo.WalletTransactionRepository,
					alipayOrderRepo domain_finance_repo.AlipayOrderRepository,
					userRepo domain_user_repo.UserRepository,
					txManager *shared_database.TransactionManager,
					logger *zap.Logger,
					config *config.Config,
					exportManager *export.ExportManager,
				) finance.FinanceApplicationService {
					return finance.NewFinanceApplicationService(
						aliPayClient,
						walletService,
						rechargeRecordService,
						walletTransactionRepo,
						alipayOrderRepo,
						userRepo,
						txManager,
						logger,
						config,
						exportManager,
					)
				},
				fx.As(new(finance.FinanceApplicationService)),
			),
			// 发票应用服务 - 绑定到接口
			fx.Annotate(
				finance.NewInvoiceApplicationService,
				fx.As(new(finance.InvoiceApplicationService)),
			),
			// 管理员发票应用服务 - 绑定到接口
			fx.Annotate(
				finance.NewAdminInvoiceApplicationService,
				fx.As(new(finance.AdminInvoiceApplicationService)),
			),
			// 产品应用服务 - 绑定到接口
			fx.Annotate(
				product.NewProductApplicationService,
				fx.As(new(product.ProductApplicationService)),
			),
			// 产品API配置应用服务 - 绑定到接口
			fx.Annotate(
				product.NewProductApiConfigApplicationService,
				fx.As(new(product.ProductApiConfigApplicationService)),
			),
			// 分类应用服务 - 绑定到接口
			fx.Annotate(
				product.NewCategoryApplicationService,
				fx.As(new(product.CategoryApplicationService)),
			),
			fx.Annotate(
				product.NewDocumentationApplicationService,
				fx.As(new(product.DocumentationApplicationServiceInterface)),
			),
			// 订阅应用服务 - 绑定到接口
			fx.Annotate(
				product.NewSubscriptionApplicationService,
				fx.As(new(product.SubscriptionApplicationService)),
			),
			// 任务管理服务
			article.NewTaskManagementService,
			// 文章应用服务 - 绑定到接口
			fx.Annotate(
				func(
					articleRepo domain_article_repo.ArticleRepository,
					categoryRepo domain_article_repo.CategoryRepository,
					tagRepo domain_article_repo.TagRepository,
					articleService *article_service.ArticleService,
					taskManager task_interfaces.TaskManager,
					logger *zap.Logger,
				) article.ArticleApplicationService {
					return article.NewArticleApplicationService(
						articleRepo,
						categoryRepo,
						tagRepo,
						articleService,
						taskManager,
						logger,
					)
				},
				fx.As(new(article.ArticleApplicationService)),
			),
			// 统计应用服务 - 绑定到接口
			fx.Annotate(
				func(
					aggregateService statistics_service.StatisticsAggregateService,
					calculationService statistics_service.StatisticsCalculationService,
					reportService statistics_service.StatisticsReportService,
					metricRepo domain_statistics_repo.StatisticsRepository,
					reportRepo domain_statistics_repo.StatisticsReportRepository,
					dashboardRepo domain_statistics_repo.StatisticsDashboardRepository,
					userRepo domain_user_repo.UserRepository,
					enterpriseInfoRepo domain_user_repo.EnterpriseInfoRepository,
					apiCallRepo domain_api_repo.ApiCallRepository,
					walletTransactionRepo domain_finance_repo.WalletTransactionRepository,
					rechargeRecordRepo domain_finance_repo.RechargeRecordRepository,
					productRepo domain_product_repo.ProductRepository,
					certificationRepo domain_certification_repo.CertificationQueryRepository,
					logger *zap.Logger,
				) statistics.StatisticsApplicationService {
					return statistics.NewStatisticsApplicationService(
						aggregateService,
						calculationService,
						reportService,
						metricRepo,
						reportRepo,
						dashboardRepo,
						userRepo,
						enterpriseInfoRepo,
						apiCallRepo,
						walletTransactionRepo,
						rechargeRecordRepo,
						productRepo,
						certificationRepo,
						logger,
					)
				},
				fx.As(new(statistics.StatisticsApplicationService)),
			),
		),

		// HTTP处理器
		fx.Provide(
			// 用户HTTP处理器
			handlers.NewUserHandler,
			// 认证HTTP处理器
			handlers.NewCertificationHandler,
			// 财务HTTP处理器
			handlers.NewFinanceHandler,
			// 产品HTTP处理器
			handlers.NewProductHandler,
			// 产品管理员HTTP处理器
			handlers.NewProductAdminHandler,
			// API Handler
			handlers.NewApiHandler,
			// 统计HTTP处理器
			handlers.NewStatisticsHandler,
			// 文章HTTP处理器
			func(
				appService article.ArticleApplicationService,
				responseBuilder interfaces.ResponseBuilder,
				validator interfaces.RequestValidator,
				logger *zap.Logger,
			) *handlers.ArticleHandler {
				return handlers.NewArticleHandler(appService, responseBuilder, validator, logger)
			},
		),

		// 路由注册
		fx.Provide(
			// 用户路由
			routes.NewUserRoutes,
			// 认证路由
			routes.NewCertificationRoutes,
			// 财务路由
			routes.NewFinanceRoutes,
			// 产品路由
			routes.NewProductRoutes,
			// 产品管理员路由
			routes.NewProductAdminRoutes,
			// 文章路由
			routes.NewArticleRoutes,
			// API路由
			routes.NewApiRoutes,
			// 统计路由
			routes.NewStatisticsRoutes,
		),

		// 应用生命周期
		fx.Invoke(
			RegisterLifecycleHooks,
			RegisterMiddlewares,
			RegisterRoutes,
			RegisterEventHandlers,
		),
	)

	return &Container{App: app}
}

// Start 启动容器
func (c *Container) Start() error {
	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
	defer cancel()

	return c.App.Start(ctx)
}

// Stop 停止容器
func (c *Container) Stop() error {
	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
	defer cancel()

	return c.App.Stop(ctx)
}

// RegisterLifecycleHooks 注册生命周期钩子
func RegisterLifecycleHooks(
	lifecycle fx.Lifecycle,
	logger *zap.Logger,
	asynqWorker *asynq.AsynqWorker,
) {
	lifecycle.Append(fx.Hook{
		OnStart: func(context.Context) error {
			logger.Info("应用启动中...")
			logger.Info("所有依赖注入完成，开始启动应用服务")

			// 确保校验器最先初始化
			validator.InitGlobalValidator()
			logger.Info("全局校验器初始化完成")

			// 启动AsynqWorker
			if err := asynqWorker.Start(); err != nil {
				logger.Error("启动AsynqWorker失败", zap.Error(err))
				return err
			}
			logger.Info("AsynqWorker启动成功")

			return nil
		},
		OnStop: func(context.Context) error {
			logger.Info("应用关闭中...")
			
			// 停止AsynqWorker
			asynqWorker.Stop()
			asynqWorker.Shutdown()
			logger.Info("AsynqWorker已停止")
			
			return nil
		},
	})
}

// RegisterMiddlewares 注册中间件
func RegisterMiddlewares(
	router *sharedhttp.GinRouter,
	panicRecovery *middleware.PanicRecoveryMiddleware,
	comprehensiveLogger *middleware.ComprehensiveLoggerMiddleware,
	requestID *middleware.RequestIDMiddleware,
	security *middleware.SecurityHeadersMiddleware,
	responseTime *middleware.ResponseTimeMiddleware,
	cors *middleware.CORSMiddleware,
	rateLimit *middleware.RateLimitMiddleware,
	dailyRateLimit *middleware.DailyRateLimitMiddleware,
	requestLogger *middleware.RequestLoggerMiddleware,
	traceIDMiddleware *middleware.TraceIDMiddleware,
	errorTrackingMiddleware *middleware.ErrorTrackingMiddleware,
	requestBodyLogger *middleware.RequestBodyLoggerMiddleware,
) {
	// 注册所有中间件（按优先级顺序）
	router.RegisterMiddleware(panicRecovery)
	router.RegisterMiddleware(comprehensiveLogger)
	router.RegisterMiddleware(requestID)
	router.RegisterMiddleware(security)
	router.RegisterMiddleware(responseTime)
	router.RegisterMiddleware(cors)
	router.RegisterMiddleware(rateLimit)
	router.RegisterMiddleware(dailyRateLimit)
	router.RegisterMiddleware(requestLogger)
	router.RegisterMiddleware(traceIDMiddleware)
	router.RegisterMiddleware(errorTrackingMiddleware)
	router.RegisterMiddleware(requestBodyLogger)
}

// RegisterRoutes 注册路由
func RegisterRoutes(
	router *sharedhttp.GinRouter,
	userRoutes *routes.UserRoutes,
	certificationRoutes *routes.CertificationRoutes,
	financeRoutes *routes.FinanceRoutes,
	productRoutes *routes.ProductRoutes,
	productAdminRoutes *routes.ProductAdminRoutes,
	articleRoutes *routes.ArticleRoutes,
	apiRoutes *routes.ApiRoutes,
	statisticsRoutes *routes.StatisticsRoutes,
	cfg *config.Config,
	logger *zap.Logger,
) {
	router.SetupDefaultRoutes()

	//  api域名路由
	apiRoutes.Register(router)

	// 所有域名路由路由
	userRoutes.Register(router)
	certificationRoutes.Register(router)
	financeRoutes.Register(router)
	productRoutes.Register(router)
	productAdminRoutes.Register(router)
	articleRoutes.Register(router)
	statisticsRoutes.Register(router)

	// 打印注册的路由信息
	router.PrintRoutes()

	// 启动HTTP服务器
	go func() {
		addr := ":" + cfg.Server.Port
		logger.Info("正在启动HTTP服务器", zap.String("addr", addr))

		if err := router.Start(addr); err != nil {
			logger.Error("HTTP服务器启动失败", zap.Error(err))
			// 在goroutine中记录错误，但不会影响主程序
		} else {
			logger.Info("HTTP服务器启动成功", zap.String("addr", addr))
		}
	}()

	logger.Info("路由注册完成，HTTP服务器启动中...")
}

// ================ 中间件包装函数 ================

// NewRequestLoggerMiddlewareWrapper 创建请求日志中间件包装器
func NewRequestLoggerMiddlewareWrapper(logger *zap.Logger, cfg *config.Config, tracer *tracing.Tracer) *middleware.RequestLoggerMiddleware {
	return middleware.NewRequestLoggerMiddleware(logger, cfg.App.IsDevelopment(), tracer)
}

// NewRequestBodyLoggerMiddlewareWrapper 创建请求体日志中间件包装器
func NewRequestBodyLoggerMiddlewareWrapper(logger *zap.Logger, cfg *config.Config, tracer *tracing.Tracer) *middleware.RequestBodyLoggerMiddleware {
	return middleware.NewRequestBodyLoggerMiddleware(logger, cfg.App.IsDevelopment(), tracer)
}

// ================ 辅助函数 ================

// convertLevelConfigs 转换级别配置
func convertLevelConfigs(configs map[string]config.LevelFileConfig) map[zapcore.Level]logger.LevelFileConfig {
	result := make(map[zapcore.Level]logger.LevelFileConfig)

	levelMap := map[string]zapcore.Level{
		"debug": zapcore.DebugLevel,
		"info":  zapcore.InfoLevel,
		"warn":  zapcore.WarnLevel,
		"error": zapcore.ErrorLevel,
		"fatal": zapcore.FatalLevel,
		"panic": zapcore.PanicLevel,
	}

	// 只转换配置文件中存在的级别
	for levelStr, config := range configs {
		if level, exists := levelMap[levelStr]; exists {
			result[level] = logger.LevelFileConfig{
				MaxSize:    config.MaxSize,
				MaxBackups: config.MaxBackups,
				MaxAge:     config.MaxAge,
				Compress:   config.Compress,
			}
		}
	}

	return result
}

// ================ Redis相关工厂函数 ================

// NewRedisClient 创建Redis客户端
func NewRedisClient(cfg *config.Config, logger *zap.Logger) (*redis.Client, error) {
	client := redis.NewClient(&redis.Options{
		Addr:         cfg.Redis.GetRedisAddr(),
		Password:     cfg.Redis.Password,
		DB:           cfg.Redis.DB,
		PoolSize:     cfg.Redis.PoolSize,
		MinIdleConns: cfg.Redis.MinIdleConns,
		DialTimeout:  cfg.Redis.DialTimeout,
		ReadTimeout:  cfg.Redis.ReadTimeout,
		WriteTimeout: cfg.Redis.WriteTimeout,
	})

	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	_, err := client.Ping(ctx).Result()
	if err != nil {
		logger.Error("Redis连接失败", zap.Error(err))
		return nil, err
	}

	logger.Info("Redis连接已建立")
	return client, nil
}

// NewRedisCache 创建Redis缓存服务
func NewRedisCache(client *redis.Client, logger *zap.Logger, cfg *config.Config) interfaces.CacheService {
	return cache.NewRedisCache(client, logger, "app")
}

// NewTracedRedisCache 创建带追踪的Redis缓存服务
func NewTracedRedisCache(client *redis.Client, tracer *tracing.Tracer, logger *zap.Logger, cfg *config.Config) interfaces.CacheService {
	return tracing.NewTracedRedisCache(client, tracer, logger, "app")
}

// RegisterEventHandlers 注册事件处理器
func RegisterEventHandlers(
	eventBus interfaces.EventBus,
	invoiceEventHandler *infra_events.InvoiceEventHandler,
	logger *zap.Logger,
) {
	// 启动事件总线
	if err := eventBus.Start(context.Background()); err != nil {
		logger.Error("启动事件总线失败", zap.Error(err))
		return
	}

	// 注册发票事件处理器
	for _, eventType := range invoiceEventHandler.GetEventTypes() {
		if err := eventBus.Subscribe(eventType, invoiceEventHandler); err != nil {
			logger.Error("注册发票事件处理器失败",
				zap.String("event_type", eventType),
				zap.String("handler", invoiceEventHandler.GetName()),
				zap.Error(err),
			)
		} else {
			logger.Info("发票事件处理器注册成功",
				zap.String("event_type", eventType),
				zap.String("handler", invoiceEventHandler.GetName()),
			)
		}
	}

	logger.Info("所有事件处理器已注册")
}