package user

import (
	"context"
	"fmt"
	"time"

	"github.com/perfect-panel/server/internal/config"
	"github.com/perfect-panel/server/internal/model/log"
	"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/tool"
	"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 {
	// 获取当前 token 登录的用户
	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")
	}

	err = l.svcCtx.DB.Transaction(func(tx *gorm.DB) error {
		// 1. 查询设备记录
		var device user.Device
		err = tx.Model(&device).Where("id = ?", req.Id).First(&device).Error
		if err != nil {
			return errors.Wrapf(xerr.NewErrCode(xerr.QueueEnqueueError), "find device err: %v", err)
		}

		// 2. 查询对应的认证记录
		var userAuth user.AuthMethods
		err = tx.Model(&userAuth).Where("auth_identifier = ? and auth_type = ?", device.Identifier, "device").First(&userAuth).Error
		if err != nil {
			return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "find user auth method err: %v", err)
		}

		// 3. 创建新用户（匿名用户）
		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(&user.User{}).Where("id = ?", newUser.Id).Update("refer_code", newUser.ReferCode).Error; err != nil {
			return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "update refer code failed: %v", err)
		}

		// 3.1 激活试用订阅（如果开启）
		if l.svcCtx.Config.Register.EnableTrial {
			if err := l.activeTrial(newUser.Id, tx); err != nil {
				return err
			}
		}

		// 3.2 记录注册日志
		registerLog := log.Register{
			AuthMethod: "device",
			Identifier: device.Identifier,
			RegisterIP: device.Ip,
			UserAgent:  device.UserAgent,
			Timestamp:  time.Now().UnixMilli(),
		}
		content, _ := registerLog.Marshal()
		if err := tx.Create(&log.SystemLog{
			Type:     log.TypeRegister.Uint8(),
			Date:     time.Now().Format("2006-01-02"),
			ObjectID: newUser.Id,
			Content:  string(content),
		}).Error; err != nil {
			l.Errorw("failed to insert register log",
				logger.Field("user_id", newUser.Id),
				logger.Field("error", err.Error()),
			)
			// Log error but don't fail transaction
		}

		// 4. 迁移设备和认证记录到新用户
		// 更新设备归属
		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)
		}

		// 更新认证归属
		if err := tx.Model(&user.AuthMethods{}).Where("id = ?", userAuth.Id).Update("user_id", newUser.Id).Error; err != nil {
			return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "update auth owner failed: %v", err)
		}

		// 5. 检查原用户是否还有其他认证方式，如果没有则删除原用户
		var count int64
		err = tx.Model(user.AuthMethods{}).Where("user_id = ?", device.UserId).Count(&count).Error
		if err != nil {
			return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "count user auth methods err: %v", err)
		}

		if count < 1 {
			if err := tx.Where("id = ?", device.UserId).Delete(&user.User{}).Error; err != nil {
				return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseDeletedError), "delete old user failed: %v", err)
			}
		}

		// 6. 清理缓存
		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("设备解绑并迁移成功",
			logger.Field("device_identifier", device.Identifier),
			logger.Field("old_user_id", device.UserId),
			logger.Field("new_user_id", newUser.Id))

		return nil
	})

	return err
}

func (l *UnbindDeviceLogic) activeTrial(userId int64, tx *gorm.DB) error {
	sub, err := l.svcCtx.SubscribeModel.FindOne(l.ctx, l.svcCtx.Config.Register.TrialSubscribe)
	if err != nil {
		l.Errorw("failed to find trial subscription template",
			logger.Field("user_id", userId),
			logger.Field("trial_subscribe_id", l.svcCtx.Config.Register.TrialSubscribe),
			logger.Field("error", err.Error()),
		)
		return err
	}

	startTime := time.Now()
	expireTime := tool.AddTime(l.svcCtx.Config.Register.TrialTimeUnit, l.svcCtx.Config.Register.TrialTime, startTime)
	subscribeToken := uuidx.SubscribeToken(fmt.Sprintf("Trial-%v", userId))
	subscribeUUID := uuidx.NewUUID().String()

	userSub := &user.Subscribe{
		UserId:      userId,
		OrderId:     0,
		SubscribeId: sub.Id,
		StartTime:   startTime,
		ExpireTime:  expireTime,
		Traffic:     sub.Traffic,
		Download:    0,
		Upload:      0,
		Token:       subscribeToken,
		UUID:        subscribeUUID,
		Status:      1,
	}

	if err := tx.Create(userSub).Error; err != nil {
		l.Errorw("failed to insert trial subscription",
			logger.Field("user_id", userId),
			logger.Field("error", err.Error()),
		)
		return err
	}

	l.Infow("trial subscription activated successfully",
		logger.Field("user_id", userId),
		logger.Field("subscribe_id", sub.Id),
		logger.Field("expire_time", expireTime),
		logger.Field("traffic", sub.Traffic),
	)
	if clearErr := l.svcCtx.NodeModel.ClearServerAllCache(l.ctx); clearErr != nil {
		l.Errorf("ClearServerAllCache error: %v", clearErr.Error())
	}

	return nil
}