package svc

import (
	"tyc-server/app/main/api/internal/config"
	"tyc-server/app/main/api/internal/middleware"
	"tyc-server/app/main/api/internal/service"
	"tyc-server/app/main/model"

	"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"
)

type ServiceContext struct {
	Config config.Config
	Redis  *redis.Redis

	// 中间件
	SourceInterceptor rest.Middleware
	AuthInterceptor   rest.Middleware

	// 模型
	UserModel                model.UserModel
	UserAuthModel            model.UserAuthModel
	ProductModel             model.ProductModel
	FeatureModel             model.FeatureModel
	ProductFeatureModel      model.ProductFeatureModel
	ProductRenderModel       model.ProductRenderModel
	OrderModel               model.OrderModel
	QueryModel               model.QueryModel
	GlobalNotificationsModel model.GlobalNotificationsModel
	ExampleModel             model.ExampleModel
	ExampleParamsModel       model.ExampleParamsModel

	// 服务
	AlipayService                  *service.AliPayService
	WechatPayService               *service.WechatPayService
	ApplePayService                *service.ApplePayService
	WestDexService                 *service.WestDexService
	YushanService                  *service.YushanService
	TianjuService                  *service.TianjuService
	ApiRequestService              *service.ApiRequestService
	AsynqServer                    *asynq.Server         // 服务端
	AsynqService                   *service.AsynqService // 客户端
	VerificationService            *service.VerificationService
	DictService                    *service.DictService
	AdminPromotionLinkStatsService *service.AdminPromotionLinkStatsService

	// admin
	AdminApiModel      model.AdminApiModel
	AdminMenuModel     model.AdminMenuModel
	AdminRoleModel     model.AdminRoleModel
	AdminRoleApiModel  model.AdminRoleApiModel
	AdminRoleMenuModel model.AdminRoleMenuModel
	AdminUserModel     model.AdminUserModel
	AdminUserRoleModel model.AdminUserRoleModel
	AdminDictDataModel model.AdminDictDataModel
	AdminDictTypeModel model.AdminDictTypeModel

	// admin promotion
	AdminPromotionLinkModel             model.AdminPromotionLinkModel
	AdminPromotionLinkStatsTotalModel   model.AdminPromotionLinkStatsTotalModel
	AdminPromotionLinkStatsHistoryModel model.AdminPromotionLinkStatsHistoryModel
	AdminPromotionOrderModel            model.AdminPromotionOrderModel
}

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,
		},
	)
	adminApiModel := model.NewAdminApiModel(db, c.CacheRedis)
	adminMenuModel := model.NewAdminMenuModel(db, c.CacheRedis)
	adminRoleModel := model.NewAdminRoleModel(db, c.CacheRedis)
	adminRoleApiModel := model.NewAdminRoleApiModel(db, c.CacheRedis)
	adminRoleMenuModel := model.NewAdminRoleMenuModel(db, c.CacheRedis)
	adminUserModel := model.NewAdminUserModel(db, c.CacheRedis)
	adminUserRoleModel := model.NewAdminUserRoleModel(db, c.CacheRedis)
	adminDictDataModel := model.NewAdminDictDataModel(db, c.CacheRedis)
	adminDictTypeModel := model.NewAdminDictTypeModel(db, c.CacheRedis)

	// admin promotion
	adminPromotionLinkModel := model.NewAdminPromotionLinkModel(db, c.CacheRedis)
	adminPromotionLinkStatsTotalModel := model.NewAdminPromotionLinkStatsTotalModel(db, c.CacheRedis)
	adminPromotionLinkStatsHistoryModel := model.NewAdminPromotionLinkStatsHistoryModel(db, c.CacheRedis)
	adminPromotionOrderModel := model.NewAdminPromotionOrderModel(db, c.CacheRedis)

	westDexService := service.NewWestDexService(c)
	yushanService := service.NewYushanService(c)
	tianjuService := service.NewTianjuService(c)
	productFeatureModel := model.NewProductFeatureModel(db, c.CacheRedis)
	featureModel := model.NewFeatureModel(db, c.CacheRedis)
	userAuthModel := model.NewUserAuthModel(db, c.CacheRedis)
	apiRequestService := service.NewApiRequestService(c, westDexService, yushanService, tianjuService, featureModel, productFeatureModel)
	adminPromotionLinkStatsService := service.NewAdminPromotionLinkStatsService(&service.ServiceContext{
		AdminPromotionLinkModel:             adminPromotionLinkModel,
		AdminPromotionLinkStatsTotalModel:   adminPromotionLinkStatsTotalModel,
		AdminPromotionLinkStatsHistoryModel: adminPromotionLinkStatsHistoryModel,
	})
	dictService := service.NewDictService(adminDictTypeModel, adminDictDataModel)
	return &ServiceContext{
		Config:                         c,
		Redis:                          redis.MustNewRedis(redisConf),
		SourceInterceptor:              middleware.NewSourceInterceptorMiddleware().Handle,
		AuthInterceptor:                middleware.NewAuthInterceptorMiddleware(c).Handle,
		AlipayService:                  service.NewAliPayService(c),
		WechatPayService:               service.NewWechatPayService(c, userAuthModel),
		ApplePayService:                service.NewApplePayService(c),
		WestDexService:                 westDexService,
		YushanService:                  yushanService,
		TianjuService:                  tianjuService,
		AdminPromotionLinkStatsService: adminPromotionLinkStatsService,
		VerificationService:            service.NewVerificationService(c, westDexService, apiRequestService),
		AsynqServer:                    asynqServer,
		ApiRequestService:              apiRequestService,
		AsynqService:                   service.NewAsynqService(c),
		DictService:                    dictService,
		UserModel:                      model.NewUserModel(db, c.CacheRedis),
		UserAuthModel:                  userAuthModel,
		ProductModel:                   model.NewProductModel(db, c.CacheRedis),
		ProductRenderModel:             model.NewProductRenderModel(db, c.CacheRedis),
		OrderModel:                     model.NewOrderModel(db, c.CacheRedis),
		QueryModel:                     model.NewQueryModel(db, c.CacheRedis),
		ExampleModel:                   model.NewExampleModel(db, c.CacheRedis),
		ExampleParamsModel:             model.NewExampleParamsModel(db, c.CacheRedis),
		GlobalNotificationsModel:       model.NewGlobalNotificationsModel(db, c.CacheRedis),
		FeatureModel:                   featureModel,
		ProductFeatureModel:            productFeatureModel,

		AdminApiModel:      adminApiModel,
		AdminMenuModel:     adminMenuModel,
		AdminRoleModel:     adminRoleModel,
		AdminRoleApiModel:  adminRoleApiModel,
		AdminRoleMenuModel: adminRoleMenuModel,
		AdminUserModel:     adminUserModel,
		AdminUserRoleModel: adminUserRoleModel,
		AdminDictDataModel: adminDictDataModel,
		AdminDictTypeModel: adminDictTypeModel,

		AdminPromotionLinkModel:             adminPromotionLinkModel,
		AdminPromotionLinkStatsTotalModel:   adminPromotionLinkStatsTotalModel,
		AdminPromotionLinkStatsHistoryModel: adminPromotionLinkStatsHistoryModel,
		AdminPromotionOrderModel:            adminPromotionOrderModel,
	}
}
func (s *ServiceContext) Close() {
	if s.AsynqService != nil {
		s.AsynqService.Close()
	}
}