package svc

import (
	"github.com/hibiken/asynq"
	"github.com/zeromicro/go-zero/core/logx"
	"github.com/zeromicro/go-zero/core/stores/redis"
	"github.com/zeromicro/go-zero/core/stores/sqlx"
	"github.com/zeromicro/go-zero/rest"
	"tydata-server/app/user/cmd/api/internal/config"
	"tydata-server/app/user/cmd/api/internal/middleware"
	"tydata-server/app/user/cmd/api/internal/service"
	"tydata-server/app/user/model"
)

type ServiceContext struct {
	Config                            config.Config
	Redis                             *redis.Redis
	SourceInterceptor                 rest.Middleware
	UserModel                         model.UserModel
	UserAuthModel                     model.UserAuthModel
	ProductModel                      model.ProductModel
	FeatureModel                      model.FeatureModel
	ProductFeatureModel               model.ProductFeatureModel
	OrderModel                        model.OrderModel
	QueryModel                        model.QueryModel
	AgentModel                        model.AgentModel
	AgentAuditModel                   model.AgentAuditModel
	AgentClosureModel                 model.AgentClosureModel
	AgentCommissionModel              model.AgentCommissionModel
	AgentCommissionDeductionModel     model.AgentCommissionDeductionModel
	AgentWalletModel                  model.AgentWalletModel
	AgentLinkModel                    model.AgentLinkModel
	AgentOrderModel                   model.AgentOrderModel
	AgentRewardsModel                 model.AgentRewardsModel
	AgentMembershipConfigModel        model.AgentMembershipConfigModel
	AgentMembershipRechargeOrderModel model.AgentMembershipRechargeOrderModel
	AgentMembershipUserConfigModel    model.AgentMembershipUserConfigModel
	AgentProductConfigModel           model.AgentProductConfigModel
	AgentPlatformDeductionModel       model.AgentPlatformDeductionModel
	AgentActiveStatModel              model.AgentActiveStatModel
	AgentWithdrawalModel              model.AgentWithdrawalModel
	GlobalNotificationsModel          model.GlobalNotificationsModel
	AlipayService                     *service.AliPayService
	WechatPayService                  *service.WechatPayService
	ApplePayService                   *service.ApplePayService
	WestDexService                    *service.WestDexService
	YushanService                     *service.YushanService
	ApiRequestService                 *service.ApiRequestService
	AsynqServer                       *asynq.Server         // 服务端
	AsynqService                      *service.AsynqService // 客户端
	VerificationService               *service.VerificationService
	AgentService                      *service.AgentService
}

func NewServiceContext(c config.Config) *ServiceContext {
	db := sqlx.NewMysql(c.DataSource)

	redisConf := redis.RedisConf{
		Host: c.CacheRedis[0].Host,
		Pass: c.CacheRedis[0].Pass,
		Type: c.CacheRedis[0].Type,
	}

	asynqServer := asynq.NewServer(
		asynq.RedisClientOpt{Addr: c.CacheRedis[0].Host, Password: c.CacheRedis[0].Pass},
		asynq.Config{
			IsFailure: func(err error) bool {
				logx.Errorf("异步任务失败: %+v \n", err)
				return true
			},
			Concurrency: 10,
		},
	)

	westDexService := service.NewWestDexService(c)
	yushanService := service.NewYushanService(c)
	productFeatureModel := model.NewProductFeatureModel(db, c.CacheRedis)
	featureModel := model.NewFeatureModel(db, c.CacheRedis)
	userAuthModel := model.NewUserAuthModel(db, c.CacheRedis)

	userModel := model.NewUserModel(db, c.CacheRedis)
	productModel := model.NewProductModel(db, c.CacheRedis)
	orderModel := model.NewOrderModel(db, c.CacheRedis)
	queryModel := model.NewQueryModel(db, c.CacheRedis)
	globalNotificationsModel := model.NewGlobalNotificationsModel(db, c.CacheRedis)

	agentModel := model.NewAgentModel(db, c.CacheRedis)
	agentAuditModel := model.NewAgentAuditModel(db, c.CacheRedis)
	agentCommissionModel := model.NewAgentCommissionModel(db, c.CacheRedis)
	agentCommissionDeductionModel := model.NewAgentCommissionDeductionModel(db, c.CacheRedis)
	agentWalletModel := model.NewAgentWalletModel(db, c.CacheRedis)
	agentClosureModel := model.NewAgentClosureModel(db, c.CacheRedis)
	agentLinkModel := model.NewAgentLinkModel(db, c.CacheRedis)
	agentOrderModel := model.NewAgentOrderModel(db, c.CacheRedis)
	agentRewardsModel := model.NewAgentRewardsModel(db, c.CacheRedis)
	agentMembershipConfigModel := model.NewAgentMembershipConfigModel(db, c.CacheRedis)
	agentMembershipRechargeOrderModel := model.NewAgentMembershipRechargeOrderModel(db, c.CacheRedis)
	agentMembershipUserConfigModel := model.NewAgentMembershipUserConfigModel(db, c.CacheRedis)
	agentProductConfigModel := model.NewAgentProductConfigModel(db, c.CacheRedis)
	agentPlatformDeductionModel := model.NewAgentPlatformDeductionModel(db, c.CacheRedis)
	agentActiveStatModel := model.NewAgentActiveStatModel(db, c.CacheRedis)
	agentWithdrawalModel := model.NewAgentWithdrawalModel(db, c.CacheRedis)

	alipayService := service.NewAliPayService(c)
	wechatPayService := service.NewWechatPayService(c, userAuthModel)
	applePayService := service.NewApplePayService(c)
	apiRequestService := service.NewApiRequestService(c, westDexService, yushanService, featureModel, productFeatureModel)
	verificationService := service.NewVerificationService(c, westDexService, apiRequestService)
	asynqService := service.NewAsynqService(c)
	agentService := service.NewAgentService(c, agentModel, agentAuditModel, agentClosureModel, agentCommissionModel,
		agentCommissionDeductionModel, agentWalletModel, agentLinkModel, agentOrderModel, agentRewardsModel,
		agentMembershipConfigModel, agentMembershipRechargeOrderModel, agentMembershipUserConfigModel,
		agentProductConfigModel, agentPlatformDeductionModel, agentActiveStatModel, agentWithdrawalModel)
	return &ServiceContext{
		Config:                            c,
		Redis:                             redis.MustNewRedis(redisConf),
		SourceInterceptor:                 middleware.NewSourceInterceptorMiddleware().Handle,
		AlipayService:                     alipayService,
		WechatPayService:                  wechatPayService,
		ApplePayService:                   applePayService,
		WestDexService:                    westDexService,
		YushanService:                     yushanService,
		VerificationService:               verificationService,
		AsynqServer:                       asynqServer,
		ApiRequestService:                 apiRequestService,
		AsynqService:                      asynqService,
		AgentService:                      agentService,
		UserModel:                         userModel,
		UserAuthModel:                     userAuthModel,
		ProductModel:                      productModel,
		OrderModel:                        orderModel,
		QueryModel:                        queryModel,
		GlobalNotificationsModel:          globalNotificationsModel,
		FeatureModel:                      featureModel,
		ProductFeatureModel:               productFeatureModel,
		AgentModel:                        agentModel,
		AgentAuditModel:                   agentAuditModel,
		AgentCommissionModel:              agentCommissionModel,
		AgentCommissionDeductionModel:     agentCommissionDeductionModel,
		AgentWalletModel:                  agentWalletModel,
		AgentClosureModel:                 agentClosureModel,
		AgentLinkModel:                    agentLinkModel,
		AgentOrderModel:                   agentOrderModel,
		AgentRewardsModel:                 agentRewardsModel,
		AgentMembershipConfigModel:        agentMembershipConfigModel,
		AgentMembershipRechargeOrderModel: agentMembershipRechargeOrderModel,
		AgentMembershipUserConfigModel:    agentMembershipUserConfigModel,
		AgentProductConfigModel:           agentProductConfigModel,
		AgentPlatformDeductionModel:       agentPlatformDeductionModel,
		AgentActiveStatModel:              agentActiveStatModel,
		AgentWithdrawalModel:              agentWithdrawalModel,
	}
}

func (s *ServiceContext) Close() {
	if s.AsynqService != nil {
		s.AsynqService.Close()
	}
}