package user

import (
	"context"

	"github.com/tidbcloud/account/commons/database"
	"github.com/tidbcloud/account/internel/dao"

	"go.uber.org/zap"

	"github.com/tidbcloud/tiinf/monitor/tilog"

	"github.com/tidbcloud/account/internel/dao/entity"
	userDao "github.com/tidbcloud/account/internel/dao/user"
)

func (s *UserSvc) ListUserLandingActions(ctx context.Context, filter userDao.LandingActionFilter) ([]entity.UserLandingAction, error) {
	tilog.Info(ctx, "userSvc ListUserLandingActions filter", zap.Any("filter", filter))
	return dao.GetDaoHub().User.ListUserLandingActions(ctx, database.DBConn.DB.WithContext(ctx), filter)
}

func (s *UserSvc) CreateUserLandingAction(ctx context.Context, userLandingAction *entity.UserLandingAction) error {
	tilog.Info(ctx, "userSvc CreateUserLandingAction ", zap.Any("userLandingAction", userLandingAction))
	return dao.GetDaoHub().User.CreateUserLandingAction(ctx, database.DBConn.DB.WithContext(ctx), userLandingAction)
}

func (s *UserSvc) SaveFirstAction(ctx context.Context, queryEntity entity.UserLandingAction, userLandingAction *entity.UserLandingAction) error {
	filter := userDao.LandingActionFilter{
		UserIDs: []entity.ID{queryEntity.UserID},
	}
	if queryEntity.TargetAction != "" {
		filter.TargetActions = []entity.UserTargetAction{queryEntity.TargetAction}
	}
	if queryEntity.TargetID != 0 {
		filter.TargetIDs = []entity.ID{queryEntity.TargetID}
	}
	list, err := dao.GetDaoHub().User.ListUserLandingActions(ctx, database.DBConn.DB.WithContext(ctx), filter)
	if err != nil {
		return err
	}
	if len(list) == 0 {
		tilog.Info(ctx, " CreateUserLandingAction ", zap.Any("userLandingAction", userLandingAction))
		return dao.GetDaoHub().User.CreateUserLandingAction(ctx, database.DBConn.DB.WithContext(ctx), userLandingAction)
	}
	tilog.Info(ctx, "ths UserLandingAction  is exits ,ignore", zap.Any("userLandingAction", userLandingAction))
	return nil
}

func (s *UserSvc) IsExist(ctx context.Context, filter userDao.LandingActionFilter) (*bool, error) {
	list, err := dao.GetDaoHub().User.ListUserLandingActions(ctx, database.DBConn.DB.WithContext(ctx), filter)
	tilog.Info(ctx, "LandingActionFilter IsExist ", zap.Any("ListUserLandingActions", list))
	if err != nil {
		return nil, err
	}
	flag := false
	if len(list) > 0 {
		flag = true

	}
	tilog.Info(ctx, "LandingActionFilter IsExist result", zap.Any("result", flag))
	return &flag, nil
}

func (s *UserSvc) GetNewUserDefaultCluster(ctx context.Context, userId *uint64, email *string) (*entity.UserLandingAction, error) {
	tilog.Info(ctx, "userSvc CreateUserLandingAction ", zap.Any("userId", userId), zap.Any("email", email))
	if userId == nil && email != nil {
		user, err := s.GetUserByEmail(ctx, *email)
		if err != nil {
			return nil, err
		}
		id := user.ID.Uint64()
		userId = &id
	}

	filter := userDao.LandingActionFilter{
		UserIDs:       []entity.ID{entity.ID(*userId)},
		TargetActions: []entity.UserTargetAction{entity.DefaultCreateClusterAction},
	}
	tilog.Info(ctx, "ListUserLandingActions ", zap.Any("filter", filter))

	objs, err := dao.GetDaoHub().User.ListUserLandingActions(ctx, database.DBConn.DB.WithContext(ctx), filter)
	if err != nil {
		return nil, err
	}
	if len(objs) == 1 {
		o1 := &objs[0]

		tilog.Info(ctx, "GetNewUserDefaultCluster result ", zap.Any("userId", userId), zap.Any("email", email), zap.Any("userLandingActions", o1))
		return o1, nil

	}
	tilog.Info(ctx, "GetNewUserDefaultCluster result  is null ", zap.Any("userId", userId), zap.Any("email", email))

	return nil, err
}

/*
func (s *UserSvc) GetNewUserDefaultCluster(ctx context.Context, userId *uint64, email *string) (*entity.UserLandingAction, error) {
	tilog.Info(ctx, "userSvc CreateUserLandingAction ", zap.Any("userId", userId), zap.Any("email", email))
	if userId == nil && email != nil {
		user, err := s.GetUserByEmail(ctx, *email)
		if err != nil {
			return nil, err
		}
		id := user.ID.Uint64()
		userId = &id
	}

	registerFilter := userDao.LandingActionFilter{
		UserIDs:       []entity.ID{entity.ID(*userId)},
		TargetActions: []entity.UserTargetAction{entity.NewUserAction},
	}
	newRegisterFlag, err := s.IsExist(ctx, registerFilter)
	tilog.Info(ctx, "newRegisterFlag ", zap.Any("newRegisterFlag", newRegisterFlag), zap.Any("userId", userId), zap.Any("email", email))
	if err != nil {
		return nil, err
	}
	if !*newRegisterFlag {
		return nil, err
	}
	filter := userDao.LandingActionFilter{
		UserIDs:       []entity.ID{entity.ID(*userId)},
		TargetActions: []entity.UserTargetAction{entity.DefaultCreateClusterAction, entity.CreateClusterAction},
	}
	tilog.Info(ctx, "ListUserLandingActions ", zap.Any("filter", filter))

	objs, err := s.hub.User.ListUserLandingActions(ctx, s.db.WithContext(ctx), filter)
	if err != nil {
		return nil, err
	}
	if len(objs) == 1 {
		o1 := &objs[0]
		if o1.TargetAction == entity.DefaultCreateClusterAction {
			tilog.Info(ctx, "GetNewUserDefaultCluster this user is new user ", zap.Any("userId", userId), zap.Any("email", email), zap.Any("userLandingActions", o1))
			return o1, nil
		}

	} else if len(objs) == 2 {
		o1 := &objs[0]
		o2 := &objs[1]
		if o1.TargetID == o2.TargetID {
			tilog.Info(ctx, "this user is new user ", zap.Any("userId", userId), zap.Any("email", email), zap.Any("userLandingActions", o1))
			return o1, nil
		}

	}
	tilog.Info(ctx, "this user is not new user ", zap.Any("userId", userId), zap.Any("email", email))

	return nil, err
}
*/

// IsNewUser
//
//	@Description:   NewUser，new register,and not create cluster
//	@Author wangletian 2023-01-19 18:03:14
//	@receiver s
//	@param ctx
//	@param userId
//	@return bool
//	@return error
func (s *UserSvc) IsNewUser(ctx context.Context, userId *uint64) (bool, error) {
	tilog.Info(ctx, "userSvc IsGetNewUser ", zap.Any("userId", userId))

	filter := userDao.LandingActionFilter{
		UserIDs:       []entity.ID{entity.ID(*userId)},
		TargetActions: []entity.UserTargetAction{entity.NewUserAction},
	}
	newRegisterFlag, err := s.IsExist(ctx, filter)
	if err != nil {
		return false, err
	}
	tilog.Info(ctx, "newRegisterFlag  ", zap.Any("userId", userId), zap.Any("filter", newRegisterFlag))
	clusterFilter := userDao.LandingActionFilter{
		UserIDs:       []entity.ID{entity.ID(*userId)},
		TargetActions: []entity.UserTargetAction{entity.CreateClusterAction},
	}
	createClusterFlag, err := s.IsExist(ctx, clusterFilter)
	if err != nil {
		return false, err
	}
	tilog.Info(ctx, "createClusterFlag  ", zap.Any("userId", userId), zap.Any("createClusterFlag", createClusterFlag))
	if *newRegisterFlag && !*createClusterFlag {
		tilog.Info(ctx, "IsNewUser result :new user ", zap.Any("userId", userId))
		return true, err
	}

	tilog.Info(ctx, "IsNewUser result : not new user ", zap.Any("userId", userId))
	return false, err
}

/*
func (s *UserSvc) IsNewUser2(ctx context.Context, userId *uint64) (bool, error) {
	tilog.Info(ctx, "userSvc IsGetNewUser ", zap.Any("userId", userId))

	filter := userDao.LandingActionFilter{
		UserIDs:       []entity.ID{entity.ID(*userId)},
		TargetActions: []entity.UserTargetAction{entity.NewUserAction},
	}
	newRegisterFlag, err := s.IsExist(ctx, filter)
	if err != nil {
		return false, err
	}
	tilog.Info(ctx, "newRegisterFlag  ", zap.Any("userId", userId), zap.Any("filter", newRegisterFlag))
	clusterFilter := userDao.LandingActionFilter{
		UserIDs:       []entity.ID{entity.ID(*userId)},
		TargetActions: []entity.UserTargetAction{entity.CreateClusterAction},
	}
	createClusterFlag := false
	list, err := s.ListUserLandingActions(ctx, clusterFilter)
	if err != nil {
		return false, err
	}
	if len(list) > 2 {
		createClusterFlag = true
	}
	tilog.Info(ctx, "createClusterFlag  ", zap.Any("userId", userId), zap.Any("createClusterFlag", createClusterFlag))
	if *newRegisterFlag && !createClusterFlag {
		tilog.Info(ctx, "IsNewUser this user is  new user ", zap.Any("userId", userId))
		return true, err
	}
	tilog.Info(ctx, "IsNewUser this user is not new user ", zap.Any("userId", userId))
	return false, err
}
*/