package user

import (
	"context"
	"time"

	logicCommon "github.com/perfect-panel/server/internal/logic/common"
	"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/xerr"
	"github.com/pkg/errors"
	"gorm.io/gorm"
)

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

// Commission Withdraw
func NewCommissionWithdrawLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CommissionWithdrawLogic {
	return &CommissionWithdrawLogic{
		Logger: logger.WithContext(ctx),
		ctx:    ctx,
		svcCtx: svcCtx,
	}
}

func (l *CommissionWithdrawLogic) CommissionWithdraw(req *types.CommissionWithdrawRequest) (resp *types.WithdrawalLog, err error) {
	u, ok := l.ctx.Value(constant.CtxKeyUser).(*user.User)
	if !ok {
		logger.Error("current user is not found in context")
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.InvalidAccess), "Invalid Access")
	}

	if u.Commission < req.Amount {
		logger.Errorf("User %d has insufficient commission balance: %.2f, requested: %.2f", u.Id, float64(u.Commission)/100, float64(req.Amount)/100)
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.UserCommissionNotEnough), "User %d has insufficient commission balance", u.Id)
	}

	tx := l.svcCtx.DB.WithContext(l.ctx).Begin()
	now := time.Now()

	// Atomically deduct the requested amount so concurrent commission growth is preserved.
	if err = l.svcCtx.DB.WithContext(l.ctx).
		Model(&user.User{}).
		Where("id = ? AND commission >= ?", u.Id, req.Amount).
		UpdateColumn("commission", gorm.Expr("commission - ?", req.Amount)).Error; err != nil {
		tx.Rollback()
		l.Errorf("Failed to update user %d commission balance: %v", u.Id, err)
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "Failed to update user %d commission balance: %v", u.Id, err)
	}
	_ = l.svcCtx.UserModel.ClearUserCache(l.ctx, u)

	// create withdrawal log
	if err = logicCommon.WriteCommissionLog(tx, u.Id, log.CommissionTypeConvertBalance, req.Amount, ""); err != nil {
		tx.Rollback()
		l.Errorf("Failed to create commission log for user %d: %v", u.Id, err)
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseInsertError), "Failed to create commission log for user %d: %v", u.Id, err)
	}

	err = tx.Model(&user.Withdrawal{}).Create(&user.Withdrawal{
		UserId:  u.Id,
		Amount:  req.Amount,
		Content: req.Content,
		Status:  0,
		Reason:  "",
	}).Error

	if err != nil {
		tx.Rollback()
		l.Errorf("Failed to create withdrawal log for user %d: %v", u.Id, err)
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseInsertError), "Failed to create withdrawal log for user %d: %v", u.Id, err)
	}
	if err = tx.Commit().Error; err != nil {
		l.Errorf("Transaction commit failed for user %d withdrawal: %v", u.Id, err)
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "Transaction commit failed for user %d withdrawal: %v", u.Id, err)
	}

	return &types.WithdrawalLog{
		UserId:    u.Id,
		Amount:    req.Amount,
		Content:   req.Content,
		Status:    0,
		Reason:    "",
		CreatedAt: now.UnixMilli(),
		UpdatedAt: now.UnixMilli(),
	}, nil
}
