hfb_sys/backend/internal/modules/listing/mutation.go

package listing

import (
	"context"
	"errors"
	"fmt"
	"strings"
	"time"

	"hfb_sys/backend/internal/listingstatus"
	"hfb_sys/backend/internal/model"

	"gorm.io/datatypes"
	"gorm.io/gorm"
	"gorm.io/gorm/clause"
)

func (r *Repository) Create(ctx context.Context, ownerID uint64, req CreateRequest, reviewRequired bool, publishCooldown time.Duration, siteCode ...string) (*ListingDTO, error) {
	var dto *ListingDTO
	err := r.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
		now := time.Now()
		if err := r.ensureCreateCooldown(tx, ownerID, publishCooldown, now); err != nil {
			return err
		}

		var site model.DistributionSite
		var siteID *uint64
		originChannel := ""
		if len(siteCode) > 0 && strings.TrimSpace(siteCode[0]) != "" {
			trimmedSiteCode := strings.TrimSpace(siteCode[0])
			if err := tx.Where("site_code = ? AND status = 'active'", trimmedSiteCode).First(&site).Error; err != nil {
				if errors.Is(err, gorm.ErrRecordNotFound) {
					return ErrDistributionSiteInvalid
				}
				return err
			}
			siteID = &site.ID
			originChannel = site.SiteCode
		}

		listingNo, err := r.nextListingNo(tx, now)
		if err != nil {
			return err
		}
		screenshots, err := marshalScreenshots(req.ScreenshotURLS)
		if err != nil {
			return err
		}
		assetSummary, err := marshalAssetSummary(req.AssetSummary)
		if err != nil {
			return err
		}
		listingStatus, reviewStatus, publishedAt := initialPublishState(reviewRequired)

		account := model.GameAccount{
			OwnerID:        ownerID,
			GameName:       "delta_force",
			ServerRegion:   req.ServerRegion,
			LoginPlatform:  req.LoginPlatform,
			Title:          req.Title,
			Description:    req.Description,
			RankLevel:      req.RankLevel,
			HafCoinAmount:  req.HafCoinAmount,
			AssetSummary:   assetSummary,
			ScreenshotURLS: screenshots,
			Status:         listingStatus,
		}
		if err := tx.Create(&account).Error; err != nil {
			return err
		}

		priceCent := normalizedListingPriceCent(req)
		listing := model.RentalListing{
			ListingNo:          listingNo,
			AccountID:          account.ID,
			OwnerID:            ownerID,
			PriceCent:          priceCent,
			DepositAmountCent:  req.DepositAmountCent,
			Status:             listingStatus,
			ReviewStatus:       reviewStatus,
			PublishedAt:        publishedAt,
			DistributionSiteID: siteID,
			SourceChannel:      originChannel,
		}
		if err := tx.Create(&listing).Error; err != nil {
			return err
		}

		if siteID != nil {
			dsa := model.DistributionSiteAccount{
				SiteID:        *siteID,
				AccountID:     account.ID,
				ListingID:     listing.ID,
				DisplayStatus: "enabled",
			}
			if err := tx.Create(&dsa).Error; err != nil {
				return err
			}
		}

		// 免审直接上架时，同步铺货到其余开启自动展示的分站货架。
		if err := r.syncPublishedShelf(tx, &listing); err != nil {
			return err
		}

		if err := listingstatus.AppendTransition(tx, &listing, "", listingstatus.SourceSeller, listingstatus.ActorUser, ownerID, "发布上架"); err != nil {
			return err
		}

		// 发布提交时建发布群
		var conversationID uint64
		if r.chatCreator != nil {
			convID, err := r.chatCreator.EnsureListingConversation(tx, listing, 0)
			if err != nil {
				return err
			}
			conversationID = convID
		}

		dto = toDTO(account, listing)
		if siteID != nil {
			dto.DistributionSiteID = siteID
			dto.DistributionSiteCode = site.SiteCode
			dto.DistributionSiteName = site.SiteName
			dto.SourceChannel = fmt.Sprintf("分销站 - %s (%s)", site.SiteName, site.SiteCode)
		}
		dto.ListingGroupConversationID = conversationID
		return nil
	})
	return dto, err
}

func (r *Repository) ensureCreateCooldown(tx *gorm.DB, ownerID uint64, cooldown time.Duration, now time.Time) error {
	if cooldown <= 0 {
		return nil
	}

	var user model.User
	if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).Select("id").First(&user, ownerID).Error; err != nil {
		return err
	}

	var latest model.RentalListing
	err := tx.Where("owner_id = ?", ownerID).
		Order("created_at DESC, id DESC").
		First(&latest).Error
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil
		}
		return err
	}
	remaining := latest.CreatedAt.Add(cooldown).Sub(now)
	if remaining > 0 {
		return PublishCooldownError{Cooldown: cooldown, Remaining: remaining}
	}
	return nil
}

type externalUploadCreate struct {
	UploaderName     string
	SourceChannel    string
	ClientUploadTime *time.Time
	ClientIP         string
	RawPayload       []byte
	ParsedPayload    []byte
}

func (r *Repository) CreateFromExternalUpload(ctx context.Context, upload externalUploadCreate, req CreateRequest) (*ListingDTO, error) {
	var dto *ListingDTO
	err := r.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
		listingNo, err := r.nextListingNo(tx, time.Now())
		if err != nil {
			return err
		}
		admin, err := r.findActiveUploadAdmin(tx, upload.UploaderName)
		if err != nil {
			return err
		}
		owner, err := r.ensureUploadOwnerUser(tx, admin)
		if err != nil {
			return err
		}
		screenshots, err := marshalScreenshots(req.ScreenshotURLS)
		if err != nil {
			return err
		}
		assetSummary, err := marshalAssetSummary(req.AssetSummary)
		if err != nil {
			return err
		}
		account := model.GameAccount{
			OwnerID:        owner.ID,
			GameName:       "delta_force",
			ServerRegion:   req.ServerRegion,
			LoginPlatform:  req.LoginPlatform,
			Title:          req.Title,
			Description:    req.Description,
			RankLevel:      req.RankLevel,
			HafCoinAmount:  req.HafCoinAmount,
			AssetSummary:   assetSummary,
			ScreenshotURLS: screenshots,
			Status:         "draft",
		}
		if err := tx.Create(&account).Error; err != nil {
			return err
		}
		priceCent := normalizedListingPriceCent(req)
		listing := model.RentalListing{
			ListingNo:         listingNo,
			AccountID:         account.ID,
			OwnerID:           owner.ID,
			PriceCent:         priceCent,
			DepositAmountCent: req.DepositAmountCent,
			Status:            "draft",
			ReviewStatus:      "pending",
			HandoffMode:       "platform",
			SettlementMode:    "platform_managed",
			ManagedAdminID:    &admin.ID,
			SourceChannel:     upload.SourceChannel,
		}
		if err := tx.Create(&listing).Error; err != nil {
			return err
		}
		var conversationID uint64
		if r.chatCreator != nil {
			convID, err := r.chatCreator.EnsureListingConversation(tx, listing, admin.ID)
			if err != nil {
				return err
			}
			conversationID = convID
		}
		matchedAdminID := admin.ID
		ownerID := owner.ID
		listingID := listing.ID
		uploadRow := model.ListingUpload{
			UploaderName:     upload.UploaderName,
			SourceChannel:    upload.SourceChannel,
			MatchedAdminID:   &matchedAdminID,
			OwnerID:          &ownerID,
			ClientUploadTime: upload.ClientUploadTime,
			ClientIP:         upload.ClientIP,
			RawPayload:       datatypes.JSON(upload.RawPayload),
			ParsedPayload:    datatypes.JSON(upload.ParsedPayload),
			ListingID:        &listingID,
			Status:           "draft_created",
		}
		if err := tx.Create(&uploadRow).Error; err != nil {
			return err
		}
		dto = toDTO(account, listing)
		dto.ListingGroupConversationID = conversationID
		return nil
	})
	return dto, err
}

func (r *Repository) Update(ctx context.Context, ownerID uint64, listingID uint64, req UpdateRequest, reviewRequired bool) (*ListingDTO, error) {
	var dto *ListingDTO
	err := r.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
		listing, account, err := r.findOwnedForUpdate(tx, ownerID, listingID)
		if err != nil {
			return err
		}
		if listingLockedForOwnerMutation(listing) {
			return ErrListingLocked
		}
		// 仅允许草稿/已下架状态编辑；已上架的必须先主动下架，避免在线编辑影响正在出租的账号
		if listing.Status != "draft" && listing.Status != "offline" {
			return ErrListingMustOfflineToEdit
		}

		account.Title = req.Title
		account.Description = req.Description
		account.ServerRegion = req.ServerRegion
		account.LoginPlatform = req.LoginPlatform
		account.RankLevel = req.RankLevel
		account.HafCoinAmount = req.HafCoinAmount
		assetSummary, err := marshalAssetSummary(req.AssetSummary)
		if err != nil {
			return err
		}
		account.AssetSummary = assetSummary
		screenshots, err := marshalScreenshots(req.ScreenshotURLS)
		if err != nil {
			return err
		}
		account.ScreenshotURLS = screenshots

		listing.PriceCent = normalizedListingPriceCent(req)
		listing.DepositAmountCent = req.DepositAmountCent
		fromStatus := listing.Status
		listingStatus, reviewStatus, publishedAt := initialPublishState(reviewRequired)
		listing.Status = listingStatus
		listing.ReviewStatus = reviewStatus
		listing.ReviewReason = ""
		listing.PublishedAt = publishedAt
		account.Status = listingStatus
		if err := tx.Save(account).Error; err != nil {
			return err
		}
		if err := tx.Save(listing).Error; err != nil {
			return err
		}
		if err := listingstatus.AppendTransition(tx, listing, fromStatus, listingstatus.SourceSeller, listingstatus.ActorUser, ownerID, "编辑后上架"); err != nil {
			return err
		}
		if err := r.syncPublishedShelf(tx, listing); err != nil {
			return err
		}
		dto = toDTO(*account, *listing)
		return nil
	})
	return dto, err
}

func (r *Repository) SubmitReview(ctx context.Context, ownerID uint64, listingID uint64, reviewRequired bool) (*ListingDTO, error) {
	var dto *ListingDTO
	err := r.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
		listing, account, err := r.findOwnedForUpdate(tx, ownerID, listingID)
		if err != nil {
			return err
		}
		if listingLockedForOwnerMutation(listing) {
			return ErrListingLocked
		}
		fromStatus := listing.Status
		listingStatus, reviewStatus, publishedAt := initialPublishState(reviewRequired)
		listing.Status = listingStatus
		listing.ReviewStatus = reviewStatus
		listing.ReviewReason = ""
		listing.PublishedAt = publishedAt
		account.Status = listingStatus
		if err := tx.Save(account).Error; err != nil {
			return err
		}
		if err := tx.Save(listing).Error; err != nil {
			return err
		}
		if err := listingstatus.AppendTransition(tx, listing, fromStatus, listingstatus.SourceSeller, listingstatus.ActorUser, ownerID, "提交发布"); err != nil {
			return err
		}
		if err := r.syncPublishedShelf(tx, listing); err != nil {
			return err
		}
		dto = toDTO(*account, *listing)
		return nil
	})
	return dto, err
}

func (r *Repository) findActiveUploadAdmin(tx *gorm.DB, uploaderName string) (*model.AdminUser, error) {
	uploaderName = strings.TrimSpace(uploaderName)
	var admin model.AdminUser
	if err := tx.Where("username = ? AND status = ?", uploaderName, "active").First(&admin).Error; err == nil {
		return &admin, nil
	} else if !errors.Is(err, gorm.ErrRecordNotFound) {
		return nil, err
	}

	var admins []model.AdminUser
	if err := tx.Where("nickname = ? AND status = ?", uploaderName, "active").Limit(2).Find(&admins).Error; err != nil {
		return nil, err
	}
	switch len(admins) {
	case 0:
		return nil, ErrUploaderNotFound
	case 1:
		return &admins[0], nil
	default:
		return nil, ErrUploaderAmbiguous
	}
}

func (r *Repository) ensureUploadOwnerUser(tx *gorm.DB, admin *model.AdminUser) (*model.User, error) {
	phone := fmt.Sprintf("admin:%d", admin.ID)
	nickname := strings.TrimSpace(admin.Nickname)
	if nickname == "" {
		nickname = admin.Username
	}
	var user model.User
	err := tx.Where("phone = ?", phone).First(&user).Error
	if err == nil {
		updates := map[string]any{
			"nickname":        nickname,
			"status":          "active",
			"realname_status": "verified",
		}
		if err := tx.Model(&user).Updates(updates).Error; err != nil {
			return nil, err
		}
		user.Nickname = nickname
		user.Status = "active"
		user.RealnameStatus = "verified"
		return &user, nil
	}
	if !errors.Is(err, gorm.ErrRecordNotFound) {
		return nil, err
	}
	user = model.User{
		Phone:          phone,
		Nickname:       nickname,
		RealnameStatus: "verified",
		RiskStatus:     "normal",
		CreditScore:    100,
		Status:         "active",
	}
	if err := tx.Create(&user).Error; err != nil {
		return nil, err
	}
	return &user, nil
}

func (r *Repository) Offline(ctx context.Context, ownerID uint64, listingID uint64) (*ListingDTO, error) {
	var dto *ListingDTO
	err := r.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
		listing, account, err := r.findOwnedForUpdate(tx, ownerID, listingID)
		if err != nil {
			return err
		}
		if listingLockedForOwnerMutation(listing) {
			return ErrListingLocked
		}
		fromStatus := listing.Status
		listing.Status = "offline"
		listing.ReviewStatus = "none"
		listing.ReviewReason = "号主已手动下架"
		listing.PublishedAt = nil
		account.Status = "offline"
		if err := tx.Save(account).Error; err != nil {
			return err
		}
		if err := tx.Save(listing).Error; err != nil {
			return err
		}
		if err := listingstatus.AppendTransition(tx, listing, fromStatus, listingstatus.SourceSeller, listingstatus.ActorUser, ownerID, "号主手动下架"); err != nil {
			return err
		}
		dto = toDTO(*account, *listing)
		return nil
	})
	return dto, err
}

func listingLockedForOwnerMutation(listing *model.RentalListing) bool {
	if listing == nil {
		return true
	}
	return listing.Status == "rented" || listing.Status == "completed" ||
		listing.Status == "sealed" || listing.InTransaction
}