package user

import (
	"context"
	"fmt"

	"github.com/perfect-panel/server/internal/config"
	"github.com/perfect-panel/server/internal/model/user"
	"github.com/perfect-panel/server/internal/svc"
	"github.com/perfect-panel/server/internal/types"
	"github.com/perfect-panel/server/pkg/constant"
	"github.com/perfect-panel/server/pkg/logger"
	"github.com/perfect-panel/server/pkg/uuidx"
	"github.com/perfect-panel/server/pkg/xerr"
	"github.com/pkg/errors"
	"gorm.io/gorm"
)

type UnbindDeviceLogic struct {
	logger.Logger
	ctx    context.Context
	svcCtx *svc.ServiceContext
}

// Unbind Device
func NewUnbindDeviceLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UnbindDeviceLogic {
	return &UnbindDeviceLogic{
		Logger: logger.WithContext(ctx),
		ctx:    ctx,
		svcCtx: svcCtx,
	}
}

func (l *UnbindDeviceLogic) UnbindDevice(req *types.UnbindDeviceRequest) error {
	userInfo := l.ctx.Value(constant.CtxKeyUser).(*user.User)
	device, err := l.svcCtx.UserModel.FindOneDevice(l.ctx, req.Id)
	if err != nil {
		return errors.Wrapf(xerr.NewErrCode(xerr.DeviceNotExist), "find device")
	}
	if device.UserId != userInfo.Id {
		return errors.Wrapf(xerr.NewErrCode(xerr.InvalidParams), "device not belong to user")
	}
	return l.svcCtx.DB.Transaction(func(tx *gorm.DB) error {
		newUser := &user.User{
			Salt:              "default",
			OnlyFirstPurchase: &l.svcCtx.Config.Invite.OnlyFirstPurchase,
		}
		if err := tx.Create(newUser).Error; err != nil {
			return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseInsertError), "create user failed: %v", err)
		}
		newUser.ReferCode = uuidx.UserInviteCode(newUser.Id)
		if err := tx.Model(newUser).Update("refer_code", newUser.ReferCode).Error; err != nil {
			return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "update refer code failed: %v", err)
		}
		oldUserId := device.UserId
		if err := tx.Model(&user.Device{}).Where("id = ?", device.Id).Update("user_id", newUser.Id).Error; err != nil {
			return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "update device owner failed: %v", err)
		}
		var authMethod user.AuthMethods
		amErr := tx.Where("auth_identifier = ? and auth_type = ?", device.Identifier, "device").First(&authMethod).Error
		if amErr != nil {
			if errors.Is(amErr, gorm.ErrRecordNotFound) {
				newAuth := &user.AuthMethods{
					UserId:         newUser.Id,
					AuthType:       "device",
					AuthIdentifier: device.Identifier,
					Verified:       true,
				}
				if err := tx.Create(newAuth).Error; err != nil {
					return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseInsertError), "create auth method failed: %v", err)
				}
			} else {
				return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "find auth method failed: %v", amErr)
			}
		} else {
			if err := tx.Model(&authMethod).Update("user_id", newUser.Id).Error; err != nil {
				return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "update auth method failed: %v", err)
			}
		}
		var count int64
		if err := tx.Model(&user.AuthMethods{}).Where("user_id = ?", oldUserId).Count(&count).Error; err != nil {
			return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "count user auth methods err: %v", err)
		}
		if count == 0 {
			if err := tx.Delete(&user.User{}, oldUserId).Error; err != nil {
				return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseDeletedError), "delete old user failed: %v", err)
			}
		}
		deviceCacheKey := fmt.Sprintf("%v:%v", config.DeviceCacheKeyKey, device.Identifier)
		if sessionId, err := l.svcCtx.Redis.Get(l.ctx, deviceCacheKey).Result(); err == nil && sessionId != "" {
			_ = l.svcCtx.Redis.Del(l.ctx, deviceCacheKey).Err()
			sessionIdCacheKey := fmt.Sprintf("%v:%v", config.SessionIdKey, sessionId)
			_ = l.svcCtx.Redis.Del(l.ctx, sessionIdCacheKey).Err()
		}
		l.Infow("device unbound and migrated to new user",
			logger.Field("device_id", device.Id),
			logger.Field("old_user_id", oldUserId),
			logger.Field("new_user_id", newUser.Id),
		)
		return nil
	})
}