hfb_sys/backend/internal/modules/dispute/repository.go

package dispute

import (
	"encoding/json"
	"errors"
	"time"

	"hfb_sys/backend/internal/model"
	"hfb_sys/backend/internal/modules/notification"

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

type Repository struct {
	db *gorm.DB
}

func NewRepository(db *gorm.DB) *Repository {
	return &Repository{db: db}
}

func (r *Repository) Create(userID uint64, orderID uint64, req CreateRequest) (*DisputeDTO, error) {
	var createdID uint64
	err := r.db.Transaction(func(tx *gorm.DB) error {
		var order model.RentalOrder
		if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).First(&order, orderID).Error; err != nil {
			return err
		}
		if order.RenterID != userID && order.OwnerID != userID {
			return ErrPermissionDenied
		}
		if order.Status == "completed" || order.Status == "cancelled" || order.Status == "closed" {
			return ErrInvalidDispute
		}
		var count int64
		if err := tx.Model(&model.Dispute{}).
			Where("order_id = ? AND status IN ?", order.ID, []string{"open", "processing"}).
			Count(&count).Error; err != nil {
			return err
		}
		if count > 0 {
			return ErrDisputeExists
		}

		targetID := order.OwnerID
		if userID == order.OwnerID {
			targetID = order.RenterID
		}
		evidence, err := marshalEvidence(req.EvidenceURLS)
		if err != nil {
			return err
		}
		row := model.Dispute{
			OrderID:      order.ID,
			InitiatorID:  userID,
			TargetUserID: targetID,
			Type:         req.Type,
			Status:       "open",
			Description:  req.Description,
			EvidenceURLS: evidence,
		}
		if err := tx.Create(&row).Error; err != nil {
			return err
		}
		order.Status = "disputing"
		if err := tx.Save(&order).Error; err != nil {
			return err
		}
		disputeID := row.ID
		if err := notification.Append(tx,
			notification.Entry{
				UserID:  targetID,
				Type:    "dispute",
				Title:   "订单进入申诉",
				Content: "对方已发起申诉，请等待客服仲裁或补充沟通记录。",
				BizType: "dispute",
				BizID:   &disputeID,
			},
			notification.Entry{
				UserID:  userID,
				Type:    "dispute",
				Title:   "申诉已提交",
				Content: "申诉已进入待处理状态，客服仲裁后会通知双方。",
				BizType: "dispute",
				BizID:   &disputeID,
			},
		); err != nil {
			return err
		}
		createdID = row.ID
		return nil
	})
	if err != nil {
		return nil, err
	}
	return r.FindForUser(userID, createdID)
}

func (r *Repository) ListForUser(userID uint64) ([]DisputeDTO, error) {
	var rows []disputeRow
	err := r.baseQuery().
		Where("d.initiator_id = ? OR d.target_user_id = ?", userID, userID).
		Order("d.id DESC").
		Scan(&rows).Error
	if err != nil {
		return nil, err
	}
	return toDTOs(rows), nil
}

func (r *Repository) FindForUser(userID uint64, id uint64) (*DisputeDTO, error) {
	var row disputeRow
	if err := r.baseQuery().
		Where("d.id = ? AND (d.initiator_id = ? OR d.target_user_id = ?)", id, userID, userID).
		First(&row).Error; err != nil {
		return nil, err
	}
	dto := row.toDTO()
	return &dto, nil
}

func (r *Repository) ListAdmin() ([]DisputeDTO, error) {
	var rows []disputeRow
	err := r.baseQuery().Order("d.id DESC").Limit(200).Scan(&rows).Error
	if err != nil {
		return nil, err
	}
	return toDTOs(rows), nil
}

func (r *Repository) Arbitrate(adminID uint64, id uint64, req ArbitrateRequest) (*DisputeDTO, error) {
	err := r.db.Transaction(func(tx *gorm.DB) error {
		var row model.Dispute
		if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).First(&row, id).Error; err != nil {
			return err
		}
		if row.Status != "open" && row.Status != "processing" {
			return ErrDisputeCannotHandle
		}
		var order model.RentalOrder
		if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).First(&order, row.OrderID).Error; err != nil {
			return err
		}
		var listing model.RentalListing
		if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).First(&listing, order.ListingID).Error; err != nil {
			return err
		}
		var account model.GameAccount
		if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).First(&account, order.AccountID).Error; err != nil {
			return err
		}
		now := time.Now()
		row.Status = "resolved"
		row.ArbitrationResult = req.Result
		row.ArbitrationRemark = req.Remark
		row.HandledBy = &adminID
		row.HandledAt = &now
		order.Status = arbitrateOrderStatus(req.Result)
		order.SettlementStatus = "arbitrated"
		order.SettledAt = &now
		order.OwnerSettledAt = &now
		if order.HandoffStatus != "cancelled" && order.HandoffStatus != "returned" {
			order.HandoffStatus = "arbitrated"
		}
		listing.Status = "published"
		account.Status = "published"
		if err := tx.Save(&row).Error; err != nil {
			return err
		}
		if err := tx.Save(&order).Error; err != nil {
			return err
		}
		if err := tx.Save(&listing).Error; err != nil {
			return err
		}
		if err := tx.Save(&account).Error; err != nil {
			return err
		}
		disputeID := row.ID
		if err := notification.Append(tx,
			notification.Entry{
				UserID:  order.RenterID,
				Type:    "arbitration",
				Title:   "申诉仲裁已完成",
				Content: "客服已给出仲裁结果，请在订单和申诉记录中查看处理说明。",
				BizType: "dispute",
				BizID:   &disputeID,
			},
			notification.Entry{
				UserID:  order.OwnerID,
				Type:    "arbitration",
				Title:   "申诉仲裁已完成",
				Content: "客服已给出仲裁结果，请在订单和申诉记录中查看处理说明。",
				BizType: "dispute",
				BizID:   &disputeID,
			},
		); err != nil {
			return err
		}
		return nil
	})
	if err != nil {
		return nil, err
	}
	var row disputeRow
	if err := r.baseQuery().Where("d.id = ?", id).First(&row).Error; err != nil {
		return nil, err
	}
	dto := row.toDTO()
	return &dto, nil
}

func (r *Repository) baseQuery() *gorm.DB {
	return r.db.Table("disputes AS d").
		Select("d.*, o.order_no, a.title").
		Joins("JOIN rental_orders AS o ON o.id = d.order_id").
		Joins("JOIN game_accounts AS a ON a.id = o.account_id")
}

type disputeRow struct {
	model.Dispute
	OrderNo string
	Title   string
}

func (row disputeRow) toDTO() DisputeDTO {
	return DisputeDTO{
		ID:                row.ID,
		OrderID:           row.OrderID,
		OrderNo:           row.OrderNo,
		Title:             row.Title,
		InitiatorID:       row.InitiatorID,
		TargetUserID:      row.TargetUserID,
		Type:              row.Type,
		Status:            row.Status,
		Description:       row.Description,
		EvidenceURLS:      row.EvidenceURLS,
		ArbitrationResult: row.ArbitrationResult,
		ArbitrationRemark: row.ArbitrationRemark,
		HandledBy:         row.HandledBy,
		HandledAt:         row.HandledAt,
		CreatedAt:         row.CreatedAt,
		UpdatedAt:         row.UpdatedAt,
	}
}

func toDTOs(rows []disputeRow) []DisputeDTO {
	items := make([]DisputeDTO, 0, len(rows))
	for _, row := range rows {
		items = append(items, row.toDTO())
	}
	return items
}

func marshalEvidence(urls []string) (datatypes.JSON, error) {
	if len(urls) == 0 {
		return datatypes.JSON([]byte("[]")), nil
	}
	raw, err := json.Marshal(urls)
	return datatypes.JSON(raw), err
}

func arbitrateOrderStatus(result string) string {
	switch result {
	case "full_refund", "partial_refund", "order_close":
		return "closed"
	default:
		return "completed"
	}
}

func IsNotFound(err error) bool {
	return errors.Is(err, gorm.ErrRecordNotFound)
}