// Code scaffolded by goctl. Safe to edit.
// goctl 1.10.1

package svc

import (
	"context"

	"gateway/internal/config"
	libmongo "gateway/internal/library/mongo"
	redislib "gateway/internal/library/redis"
	"gateway/internal/library/validate"
	"gateway/internal/library/zitadel"
	authdomrepo "gateway/internal/model/auth/domain/repository"
	domauth "gateway/internal/model/auth/domain/usecase"
	authrepo "gateway/internal/model/auth/repository"
	authusecase "gateway/internal/model/auth/usecase"
	domrepo "gateway/internal/model/member/domain/repository"
	dommember "gateway/internal/model/member/domain/usecase"
	memberusecase "gateway/internal/model/member/usecase"
	domnotif "gateway/internal/model/notification/domain/usecase"
	notifusecase "gateway/internal/model/notification/usecase"
	"gateway/internal/worker/notification_retry"
)

type ServiceContext struct {
	Config                  config.Config
	Validator               validate.Validate
	Redis                   *redislib.Client
	AuthToken               domauth.TokenUseCase
	AuthInvite              domauth.InviteUseCase
	AuthRegistrationMeta    domauth.RegistrationMetaUseCase
	AuthRegistrationSession domauth.RegistrationSessionUseCase
	AuthLoginSession        domauth.LoginSessionUseCase
	Zitadel                 *zitadel.Client
	Notifier                domnotif.NotifierUseCase
	NotificationAdmin       domnotif.AdminNotifierUseCase
	NotificationRetry       *notification_retry.Runner

	MemberOTP          dommember.OTPUseCase
	MemberTOTP         dommember.TOTPUseCase
	MemberProfile      dommember.ProfileUseCase
	MemberLifecycle    dommember.LifecycleUseCase
	MemberProvisioning dommember.ProvisioningUseCase
	MemberTenant       dommember.TenantUseCase
	MemberVerifyRate   dommember.VerifyRateUseCase
	MemberRepo         domrepo.MemberRepository
}

func NewServiceContext(c config.Config) *ServiceContext {
	v, err := validate.NewWithDefaultEN()
	if err != nil {
		panic(err)
	}

	rds, err := redislib.NewClient(c.Redis)
	if err != nil {
		panic(err)
	}

	sc := &ServiceContext{
		Config:    c,
		Validator: v,
		Redis:     rds,
	}
	authCfg := c.Auth.Defaults()
	if authCfg.Enabled() {
		var revoke authdomrepo.TokenRevokeStore
		if rds != nil && rds.Zero() != nil {
			revoke = authrepo.NewRedisTokenRevokeStore(rds)
		}
		sc.AuthToken = authusecase.MustTokenUseCase(authusecase.TokenUseCaseParam{
			Config: authCfg,
			Revoke: revoke,
		})
	}
	zClient, err := zitadel.NewClient(c.Zitadel)
	if err != nil {
		panic(err)
	}
	sc.Zitadel = zClient
	if c.Mongo.Host != "" {
		mod, err := notifusecase.NewModuleFromParam(notifusecase.FactoryParam{
			MongoConf: &c.Mongo,
			Redis:     rds,
			Config:    c.Notification,
		})
		if err != nil {
			panic(err)
		}
		sc.Notifier = mod.Notifier
		sc.NotificationAdmin = mod.Admin
		sc.NotificationRetry = notification_retry.NewRunner(mod.RetryWorker)

		authMod, err := authusecase.NewModuleFromParam(authusecase.ModuleParam{
			MongoConf: &c.Mongo,
			Redis:     rds,
		})
		if err != nil {
			panic(err)
		}
		sc.AuthInvite = authMod.Invite
		sc.AuthRegistrationMeta = authMod.RegistrationMeta
		sc.AuthRegistrationSession = authMod.RegistrationSession
		sc.AuthLoginSession = authMod.LoginSession
	}
	if rds != nil && rds.Zero() != nil {
		var mongoConf *libmongo.Conf
		if c.Mongo.Host != "" {
			mongoConf = &c.Mongo
		}
		memberMod, err := memberusecase.NewModuleFromParam(memberusecase.ModuleParam{
			Redis:     rds,
			MongoConf: mongoConf,
			Config:    c.Member,
		})
		if err != nil {
			panic(err)
		}
		sc.MemberOTP = memberMod.OTP
		sc.MemberTOTP = memberMod.TOTP
		sc.MemberProfile = memberMod.Profile
		sc.MemberLifecycle = memberMod.Lifecycle
		sc.MemberProvisioning = memberMod.Provisioning
		sc.MemberTenant = memberMod.Tenant
		sc.MemberVerifyRate = memberMod.VerifyRate
		sc.MemberRepo = memberMod.Members
	}
	return sc
}

func (sc *ServiceContext) StartWorkers(ctx context.Context) {
	if sc.NotificationRetry != nil {
		sc.NotificationRetry.Start(ctx)
	}
}

func (sc *ServiceContext) StopWorkers() {
	if sc.NotificationRetry != nil {
		sc.NotificationRetry.Stop()
	}
}