package handlers

import (
	"awesomeProject/internal/common"
	"awesomeProject/internal/models"
	"fmt"
	"net/http"
	"strconv"
	"time"

	"github.com/gin-gonic/gin"
	"gorm.io/gorm"
)

// UserOrderHandler 用户订单处理器
type UserOrderHandler struct{}

// CreatePurchaseOrder 创建买单
func (h *UserOrderHandler) CreatePurchaseOrder(c *gin.Context) {
	currentUser, _ := c.Get("current_user")
	user := currentUser.(models.User)

	var req struct {
		ProductID         uint    `json:"product_id" binding:"required"`
		ProductType       uint8   `json:"product_type" binding:"required"` // 1一级商品，2二级商品
		ProductName       string  `json:"product_name" binding:"required"`
		ProductImages     string  `json:"product_images"`
		UnitPrice         float64 `json:"unit_price" binding:"required"`
		Quantity          int     `json:"quantity" binding:"required"`
		TotalAmount       float64 `json:"total_amount" binding:"required"`
		AddressID         uint    `json:"address_id" binding:"required"`
		PaymentProofImage string  `json:"payment_proof_image"` // 不再强制要求
		Remark            string  `json:"remark"`
	}

	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusOK, common.Error(400, "请求参数错误"))
		return
	}

	// 验证商品类型
	if req.ProductType != 1 && req.ProductType != 2 {
		c.JSON(http.StatusOK, common.Error(400, "商品类型无效"))
		return
	}

	// 验证数量和金额
	if req.Quantity <= 0 {
		c.JSON(http.StatusOK, common.Error(400, "购买数量必须大于0"))
		return
	}

	if req.TotalAmount != req.UnitPrice*float64(req.Quantity) {
		c.JSON(http.StatusOK, common.Error(400, "订单金额计算错误"))
		return
	}

	db := common.GetDB()

	// 开启事务
	tx := db.Begin()

	// 验证收货地址是否属于当前用户
	var address models.UserAddress
	if err := tx.Where("id = ? AND user_id = ?", req.AddressID, user.ID).First(&address).Error; err != nil {
		tx.Rollback()
		c.JSON(http.StatusOK, common.Error(404, "收货地址不存在"))
		return
	}

	var sellerID *uint
	//var productInfo interface{}

	// 根据商品类型进行不同的处理
	if req.ProductType == 1 { // 一级商品
		var primaryProduct models.PrimaryProduct
		if err := tx.First(&primaryProduct, req.ProductID).Error; err != nil {
			tx.Rollback()
			if err == gorm.ErrRecordNotFound {
				c.JSON(http.StatusOK, common.Error(404, "商品不存在"))
			} else {
				c.JSON(http.StatusOK, common.Error(500, "查询商品失败"))
			}
			return
		}

		// 检查商品状态和库存
		if primaryProduct.Status != 1 {
			tx.Rollback()
			c.JSON(http.StatusOK, common.Error(400, "商品已下架"))
			return
		}

		if primaryProduct.StockQuantity < req.Quantity {
			tx.Rollback()
			c.JSON(http.StatusOK, common.Error(400, "库存不足"))
			return
		}

		// 减少库存，增加销量
		if err := tx.Model(&primaryProduct).Updates(map[string]interface{}{
			"stock_quantity": primaryProduct.StockQuantity - req.Quantity,
			"sales_count":    primaryProduct.SalesCount + req.Quantity,
		}).Error; err != nil {
			tx.Rollback()
			c.JSON(http.StatusOK, common.Error(500, "更新商品库存失败"))
			return
		}

		//productInfo = primaryProduct

	} else { // 二级商品
		var secondaryProduct models.SecondaryProduct
		if err := tx.Preload("Seller").First(&secondaryProduct, req.ProductID).Error; err != nil {
			tx.Rollback()
			if err == gorm.ErrRecordNotFound {
				c.JSON(http.StatusOK, common.Error(404, "商品不存在"))
			} else {
				c.JSON(http.StatusOK, common.Error(500, "查询商品失败"))
			}
			return
		}

		// 检查商品状态和库存
		if secondaryProduct.Status != 1 {
			tx.Rollback()
			c.JSON(http.StatusOK, common.Error(400, "商品已下架"))
			return
		}

		if secondaryProduct.Quantity < req.Quantity {
			tx.Rollback()
			c.JSON(http.StatusOK, common.Error(400, "库存不足"))
			return
		}

		// 检查是否是自己的商品
		if secondaryProduct.SellerID == user.ID {
			tx.Rollback()
			c.JSON(http.StatusOK, common.Error(400, "不能购买自己的商品"))
			return
		}
		var config models.SystemConfig
		tx.Where("config_key=?", "limit_days").First(&config)
		value, _ := strconv.Atoi(config.ConfigValue)

		if value > 0 {
			fiveDaysAgo := time.Now().AddDate(0, 0, -value)
			var existingOrderCount int64
			if err := tx.Model(&models.PurchaseOrder{}).Where(
				"buyer_id = ? AND seller_id = ? AND product_type = 2 AND created_at > ? AND order_status != 3",
				user.ID, secondaryProduct.SellerID, fiveDaysAgo,
			).Count(&existingOrderCount).Error; err != nil {
				tx.Rollback()
				c.JSON(http.StatusOK, common.Error(500, "检查购买记录失败"))
				return
			}

			if existingOrderCount > 0 {
				tx.Rollback()
				c.JSON(http.StatusOK, common.Error(400, fmt.Sprintf("%v天内只能向同一个卖家购买一次商品", value)))
				return
			}
		}

		// 减少库存，增加浏览量
		if err := tx.Model(&secondaryProduct).Updates(map[string]interface{}{
			"quantity":   secondaryProduct.Quantity - req.Quantity,
			"view_count": secondaryProduct.ViewCount + 1,
		}).Error; err != nil {
			tx.Rollback()
			c.JSON(http.StatusOK, common.Error(500, "更新商品库存失败"))
			return
		}

		sellerID = &secondaryProduct.SellerID
		//productInfo = secondaryProduct
	}

	// 生成订单编号
	orderNo := fmt.Sprintf("PO%d%d", time.Now().Unix(), user.ID)

	// 创建买单
	orderStatus := 0 // 默认待付款
	if req.PaymentProofImage != "" {
		orderStatus = 1 // 如果有付款凭证，设为待确认
	}

	purchaseOrder := models.PurchaseOrder{
		OrderNo:           orderNo,
		BuyerID:           user.ID,
		SellerID:          sellerID,
		ProductID:         req.ProductID,
		ProductType:       req.ProductType,
		ProductName:       req.ProductName,
		ProductImages:     req.ProductImages,
		UnitPrice:         req.UnitPrice,
		Quantity:          req.Quantity,
		TotalAmount:       req.TotalAmount,
		AddressID:         &req.AddressID,
		OrderStatus:       uint8(orderStatus),
		PaymentProofImage: req.PaymentProofImage,
		Remark:            req.Remark,
	}

	if err := tx.Create(&purchaseOrder).Error; err != nil {
		tx.Rollback()
		c.JSON(http.StatusOK, common.Error(500, "创建订单失败"))
		return
	}

	//如果是二级商品，创建对应的卖单
	if req.ProductType == 2 {
		salesOrder := models.SalesOrder{
			OrderNo:            fmt.Sprintf("SO%d%d", time.Now().Unix(), *sellerID),
			SellerID:           *sellerID,
			BuyerID:            user.ID,
			SecondaryProductID: req.ProductID,
			ProductName:        req.ProductName,
			ProductImages:      req.ProductImages,
			SellingPrice:       req.UnitPrice,
			Quantity:           req.Quantity,
			TotalAmount:        req.TotalAmount,
			AddressID:          &req.AddressID,
			OrderStatus:        0, // 待付款
			PaymentProofImage:  req.PaymentProofImage,
			PurchaseOrderID:    purchaseOrder.ID,
		}

		if err := tx.Create(&salesOrder).Error; err != nil {
			tx.Rollback()
			c.JSON(http.StatusOK, common.Error(500, "创建卖单失败"))
			return
		}
	}

	// 提交事务
	tx.Commit()

	// 返回订单信息
	result := map[string]interface{}{
		"order_id": purchaseOrder.ID,
		"order_no": purchaseOrder.OrderNo,
		"status":   "订单已提交，等待确认",
		"message":  "订单创建成功",
	}

	c.JSON(http.StatusOK, common.Success(result))
}

// GetPurchaseOrders 获取买单列表
func (h *UserOrderHandler) GetPurchaseOrders(c *gin.Context) {
	currentUser, _ := c.Get("current_user")
	user := currentUser.(models.User)

	// 分页参数
	page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
	pageSize, _ := strconv.Atoi(c.DefaultQuery("page_size", "10"))
	if page < 1 {
		page = 1
	}
	if pageSize < 1 || pageSize > 50 {
		pageSize = 10
	}
	order_id, _ := strconv.Atoi(c.DefaultQuery("order_id", "0"))
	// 状态过滤
	status := c.Query("status")
	startDate := c.Query("start_date")
	endDate := c.Query("end_date")

	db := common.GetDB()
	var orders []models.PurchaseOrder
	var total int64

	// 构建查询条件
	query := db.Model(&models.PurchaseOrder{}).Where("buyer_id = ?", user.ID).
		Preload("Address").Preload("Seller")

	// 添加状态过滤
	if status != "" && status != "all" {
		switch status {
		case "pending":
			query = query.Where("order_status = 0")
		case "confirming":
			query = query.Where("order_status = 1")
		case "completed":
			query = query.Where("order_status = 2")
		case "cancelled":
			query = query.Where("order_status = 3")
		}
	}

	// 添加日期过滤
	if startDate != "" {
		query = query.Where("created_at >= ?", startDate+" 00:00:00")
	}
	if endDate != "" {
		query = query.Where("created_at <= ?", endDate+" 23:59:59")
	}
	if order_id > 0 {
		query = query.Where("id = ?", order_id)
	}
	// 获取总数
	query.Count(&total)

	// 分页查询
	offset := (page - 1) * pageSize
	err := query.Order("created_at DESC").Offset(offset).Limit(pageSize).Find(&orders).Error
	if err != nil {
		c.JSON(http.StatusOK, common.Error(500, "查询订单列表失败"))
		return
	}

	// 计算总金额
	var totalAmount float64
	db.Model(&models.PurchaseOrder{}).Where("buyer_id = ? AND order_status = 2", user.ID).Select("COALESCE(SUM(total_amount), 0)").Scan(&totalAmount)

	// 构建返回数据
	result := map[string]interface{}{
		"list":         orders,
		"total":        total,
		"page":         page,
		"page_size":    pageSize,
		"total_amount": totalAmount,
	}

	c.JSON(http.StatusOK, common.Success(result))
}

// GetSalesOrders 获取卖单列表
func (h *UserOrderHandler) GetSalesOrders(c *gin.Context) {
	currentUser, _ := c.Get("current_user")
	user := currentUser.(models.User)

	// 分页参数
	page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
	pageSize, _ := strconv.Atoi(c.DefaultQuery("page_size", "10"))
	if page < 1 {
		page = 1
	}
	if pageSize < 1 || pageSize > 50 {
		pageSize = 10
	}

	// 状态过滤
	status := c.Query("status")
	startDate := c.Query("start_date")
	endDate := c.Query("end_date")

	db := common.GetDB()
	var orders []models.SalesOrder
	var total int64

	// 构建查询条件
	query := db.Model(&models.SalesOrder{}).Where("seller_id = ?", user.ID).Preload("Buyer").Preload("Address")

	// 添加状态过滤
	if status != "" && status != "all" {
		switch status {
		case "pending":
			query = query.Where("order_status = 0")
		case "confirming":
			query = query.Where("order_status = 1")
		case "completed":
			query = query.Where("order_status = 2")
		case "cancelled":
			query = query.Where("order_status = 3")
		}
	}

	// 添加日期过滤
	if startDate != "" {
		query = query.Where("created_at >= ?", startDate+" 00:00:00")
	}
	if endDate != "" {
		query = query.Where("created_at <= ?", endDate+" 23:59:59")
	}

	// 获取总数
	query.Count(&total)

	// 分页查询
	offset := (page - 1) * pageSize
	err := query.Order("created_at DESC").Offset(offset).Limit(pageSize).Find(&orders).Error
	if err != nil {
		c.JSON(http.StatusOK, common.Error(500, "查询卖单列表失败"))
		return
	}

	// 计算总金额
	var totalAmount float64
	db.Model(&models.SalesOrder{}).Where("seller_id = ? AND order_status = 2", user.ID).Select("COALESCE(SUM(total_amount), 0)").Scan(&totalAmount)

	// 构建返回数据
	result := map[string]interface{}{
		"list":         orders,
		"total":        total,
		"page":         page,
		"page_size":    pageSize,
		"total_amount": totalAmount,
	}

	c.JSON(http.StatusOK, common.Success(result))
}

// GetOrderStats 获取订单统计信息（待付款和待确认数量）
func (h *UserOrderHandler) GetOrderStats(c *gin.Context) {
	currentUser, _ := c.Get("current_user")
	user := currentUser.(models.User)

	db := common.GetDB()
	stats := make(map[string]interface{})

	// 买单统计
	var purchasePendingCount int64   // 待付款
	var purchaseConfirmingCount int64 // 待确认
	db.Model(&models.PurchaseOrder{}).Where("buyer_id = ? AND order_status = ?", user.ID, 0).Count(&purchasePendingCount)
	db.Model(&models.PurchaseOrder{}).Where("buyer_id = ? AND order_status = ?", user.ID, 1).Count(&purchaseConfirmingCount)

	// 卖单统计
	var salesPendingCount int64   // 待付款
	var salesConfirmingCount int64 // 待确认
	db.Model(&models.SalesOrder{}).Where("seller_id = ? AND order_status = ?", user.ID, 0).Count(&salesPendingCount)
	db.Model(&models.SalesOrder{}).Where("seller_id = ? AND order_status = ?", user.ID, 1).Count(&salesConfirmingCount)

	stats["purchase_pending_count"] = purchasePendingCount
	stats["purchase_confirming_count"] = purchaseConfirmingCount
	stats["sales_pending_count"] = salesPendingCount
	stats["sales_confirming_count"] = salesConfirmingCount

	c.JSON(http.StatusOK, common.Success(stats))
}

// ConfirmPurchaseOrder 确认买单（买家确认收货）
func (h *UserOrderHandler) ConfirmPurchaseOrder(c *gin.Context) {
	currentUser, _ := c.Get("current_user")
	user := currentUser.(models.User)

	orderID, err := strconv.ParseUint(c.Param("id"), 10, 32)
	if err != nil {
		c.JSON(http.StatusOK, common.Error(400, "订单ID无效"))
		return
	}

	db := common.GetDB()
	tx := db.Begin()

	// 买家确认买单（确认收货）
	var order models.PurchaseOrder
	if err := tx.Where("id = ? AND buyer_id = ?", orderID, user.ID).First(&order).Error; err != nil {
		tx.Rollback()
		if err == gorm.ErrRecordNotFound {
			c.JSON(http.StatusOK, common.Error(404, "订单不存在"))
		} else {
			c.JSON(http.StatusOK, common.Error(500, "查询订单失败"))
		}
		return
	}

	if order.OrderStatus != 1 {
		tx.Rollback()
		c.JSON(http.StatusOK, common.Error(400, "订单状态不允许确认"))
		return
	}

	// 更新订单状态为已完成
	now := time.Now()
	if err := tx.Model(&order).Updates(map[string]interface{}{
		"order_status": 2,
		"confirm_time": &now,
	}).Error; err != nil {
		tx.Rollback()
		c.JSON(http.StatusOK, common.Error(500, "确认订单失败"))
		return
	}

	// 商品入库
	if err := h.addToWarehouse(tx, user.ID, &order); err != nil {
		tx.Rollback()
		c.JSON(http.StatusOK, common.Error(500, "商品入库失败"))
		return
	}

	tx.Commit()

	result := map[string]interface{}{
		"message": "订单确认成功，商品已入库",
	}

	c.JSON(http.StatusOK, common.Success(result))
}

// ConfirmSalesOrder 确认卖单（卖家确认发货）
func (h *UserOrderHandler) ConfirmSalesOrder(c *gin.Context) {
	currentUser, _ := c.Get("current_user")
	user := currentUser.(models.User)

	orderID, err := strconv.ParseUint(c.Param("id"), 10, 32)
	if err != nil {
		c.JSON(http.StatusOK, common.Error(400, "订单ID无效"))
		return
	}

	// 卖家确认卖单
	var order models.SalesOrder
	tx := common.GetDB().Begin()
	if err := tx.Where("id = ? AND seller_id = ?", orderID, user.ID).First(&order).Error; err != nil {
		tx.Rollback()
		if err == gorm.ErrRecordNotFound {
			c.JSON(http.StatusOK, common.Error(404, "订单不存在"))
		} else {
			c.JSON(http.StatusOK, common.Error(500, "查询订单失败"))
		}
		return
	}

	if order.OrderStatus != 1 {
		tx.Rollback()
		c.JSON(http.StatusOK, common.Error(400, "订单状态不允许确认"))
		return
	}

	// 更新卖单状态为已完成
	now := time.Now()
	if err := tx.Model(&order).Updates(models.SalesOrder{
		OrderStatus:  2,
		CompleteTime: &now,
	}).Error; err != nil {
		tx.Rollback()
		c.JSON(http.StatusOK, common.Error(500, "确认订单失败"))
		return
	}

	// 同时更新对应的买单状态
	if err := tx.Model(&models.PurchaseOrder{}).Where(
		"id=?",
		order.PurchaseOrderID,
	).Updates(models.PurchaseOrder{
		OrderStatus: 2,
		ConfirmTime: &now,
	}).Error; err != nil {
		tx.Rollback()
		c.JSON(http.StatusOK, common.Error(500, "更新买单状态失败"))
		return
	}

	var config models.SystemConfig
	tx.Where("config_key=?", "warehouse_price_rate").First(&config)
	vaule, _ := strconv.Atoi(config.ConfigValue)
	newRecord := models.ScoreRecord{
		UserID:       user.ID,
		Note:         "系统策略",
		ChangeNumber: -vaule,
	}

	if err := tx.Create(&newRecord).Error; err != nil {
		tx.Rollback()
		c.JSON(http.StatusOK, common.Error(500, "创建积分记录失败"))
		return
	}

	// 更新用户积分
	newPoints := user.CurrentPoints + newRecord.ChangeNumber
	if newPoints < 0 {
		tx.Rollback()
		c.JSON(http.StatusOK, common.Error(400, "用户积分不足"))
		return
	}

	if err := tx.Model(&user).Update("current_points", newPoints).Error; err != nil {
		tx.Rollback()
		c.JSON(http.StatusOK, common.Error(500, "更新用户积分失败"))
		return
	}

	tx.Commit()

	var purcharseOrder models.PurchaseOrder
	db := common.GetDB()
	db.Where("id=?", order.PurchaseOrderID).First(&purcharseOrder)
	err = h.addToWarehouse(db, order.BuyerID, &purcharseOrder)
	if err != nil {
		c.JSON(http.StatusOK, common.Error(400, "添加用户仓库失败"))
	}
	result := map[string]interface{}{
		"message": "订单确认成功",
	}

	c.JSON(http.StatusOK, common.Success(result))
}

// addToWarehouse 添加商品到买家仓库
func (h *UserOrderHandler) addToWarehouse(tx *gorm.DB, buyerID uint, order *models.PurchaseOrder) error {

	fmt.Println("order::", order)
	// 检查该订单是否已经入库（防止重复入库）
	var existingByOrder models.UserWarehouse
	err := tx.Where("user_id = ? AND source_order_id = ? and  product_type=? and product_id=?",
		buyerID, order.ID, order.ProductType, order.ProductID).First(&existingByOrder).Error

	if err == nil {
		// 该订单已经入库，直接返回
		return nil
	} else if err != gorm.ErrRecordNotFound {
		// 查询出错
		return err
	}

	var config models.SystemConfig
	tx.Where("config_key=?", "warehouse_price_rate").First(&config)
	value, _ := strconv.Atoi(config.ConfigValue)
	// 计算入库价格（根据系统配置增值）
	warehousePrice := order.UnitPrice + float64(value)

	// 检查仓库中是否已有相同商品（不同订单的相同商品）
	var existingWarehouse models.UserWarehouse
	//err = tx.Where("user_id = ? AND product_id = ? AND product_type = ?",
	//	buyerID, order.ProductID, order.ProductType).First(&existingWarehouse).Error

	if err == gorm.ErrRecordNotFound {
		// 创建新的仓库记录
		warehouse := models.UserWarehouse{
			UserID:         buyerID,
			ProductID:      order.ProductID,
			ProductType:    order.ProductType,
			ProductName:    order.ProductName,
			ProductImages:  order.ProductImages,
			PurchasePrice:  order.UnitPrice,
			WarehousePrice: warehousePrice,
			Quantity:       order.Quantity,
			SourceOrderID:  &order.ID,
			Status:         1, // 库存中
		}

		return tx.Create(&warehouse).Error
	} else if err != nil {
		return err
	} else {
		// 更新现有仓库记录的数量（累加不同订单的相同商品）
		return tx.Model(&existingWarehouse).Update("quantity", existingWarehouse.Quantity+order.Quantity).Error
	}

}

// UploadPaymentProof 上传付款凭证
func (h *UserOrderHandler) UploadPaymentProof(c *gin.Context) {
	currentUser, _ := c.Get("current_user")
	user := currentUser.(models.User)

	orderID, err := strconv.ParseUint(c.Param("id"), 10, 32)
	if err != nil {
		c.JSON(http.StatusOK, common.Error(400, "订单ID无效"))
		return
	}

	var req struct {
		PaymentProofImage string `json:"payment_proof_image" binding:"required"`
		ProductType       uint   `json:"product_type" binding:"required"`
	}

	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusOK, common.Error(400, "请求参数错误"))
		return
	}

	db := common.GetDB()
	tx := db.Begin()

	// 查询订单
	var order models.PurchaseOrder
	if err := tx.Where("id = ? AND buyer_id = ?", orderID, user.ID).First(&order).Error; err != nil {
		tx.Rollback()
		if err == gorm.ErrRecordNotFound {
			c.JSON(http.StatusOK, common.Error(404, "订单不存在"))
		} else {
			c.JSON(http.StatusOK, common.Error(500, "查询订单失败"))
		}
		return
	}

	// 检查订单状态
	if order.OrderStatus != 0 {
		tx.Rollback()
		c.JSON(http.StatusOK, common.Error(400, "订单状态不允许上传付款凭证"))
		return
	}

	// 更新订单状态为待确认，并保存付款凭证
	if err := tx.Model(&order).Updates(map[string]interface{}{
		"payment_proof_image": req.PaymentProofImage,
		"order_status":        1, // 待确认
	}).Error; err != nil {
		tx.Rollback()
		c.JSON(http.StatusOK, common.Error(500, "更新订单失败"))
		return
	}

	var saleOrder models.SalesOrder
	if req.ProductType == 2 {

		if err := tx.Where("purchase_order_id = ?", order.ID).First(&saleOrder).Error; err != nil {
			tx.Rollback()
			c.JSON(200, common.Error(400, "查找不到有效订单"))
		}

		// 再更新，这里可以使用 Model 指定要更新的对象
		// 注意：这仍然会基于 saleOrder 的主键 ID 更新，但因为我们刚查出来，所以是安全的。
		// 但更清晰的方式是直接用 Where。

		// 更好的方式是：直接基于原始条件更新
		if err := tx.Where("purchase_order_id = ?", order.ID).Updates(models.SalesOrder{
			OrderStatus:       1,
			PaymentProofImage: req.PaymentProofImage,
		}).Error; err != nil {
			tx.Rollback()
			c.JSON(200, common.Error(400, "更新错误"))
		}
	}

	tx.Commit()

	result := map[string]interface{}{
		"message": "付款凭证上传成功，订单已提交等待确认",
	}

	c.JSON(http.StatusOK, common.Success(result))
}

// CancelOrder 取消订单
func (h *UserOrderHandler) CancelOrder(c *gin.Context) {
	currentUser, _ := c.Get("current_user")
	user := currentUser.(models.User)

	orderID, err := strconv.ParseUint(c.Param("id"), 10, 32)
	if err != nil {
		c.JSON(http.StatusOK, common.Error(400, "订单ID无效"))
		return
	}

	db := common.GetDB()
	tx := db.Begin()

	// 查询订单
	var order models.PurchaseOrder
	if err := tx.Where("id = ? AND buyer_id = ?", orderID, user.ID).First(&order).Error; err != nil {
		tx.Rollback()
		if err == gorm.ErrRecordNotFound {
			c.JSON(http.StatusOK, common.Error(404, "订单不存在"))
		} else {
			c.JSON(http.StatusOK, common.Error(500, "查询订单失败"))
		}
		return
	}

	// 检查订单状态（只有待付款和待确认的订单可以取消）
	if order.OrderStatus != 0 && order.OrderStatus != 1 {
		tx.Rollback()
		c.JSON(http.StatusOK, common.Error(400, "订单状态不允许取消"))
		return
	}

	// 更新订单状态为已取消
	if err := tx.Model(&order).Update("order_status", 3).Error; err != nil {
		tx.Rollback()
		c.JSON(http.StatusOK, common.Error(500, "取消订单失败"))
		return
	}

	// 恢复商品库存
	if order.ProductType == 1 { // 一级商品
		if err := tx.Model(&models.PrimaryProduct{}).Where("id = ?", order.ProductID).
			Update("stock_quantity", gorm.Expr("stock_quantity + ?", order.Quantity)).Error; err != nil {
			tx.Rollback()
			c.JSON(http.StatusOK, common.Error(500, "恢复库存失败"))
			return
		}
	} else { // 二级商品
		if err := tx.Model(&models.SecondaryProduct{}).Where("id = ?", order.ProductID).
			Update("quantity", gorm.Expr("quantity + ?", order.Quantity)).Error; err != nil {
			tx.Rollback()
			c.JSON(http.StatusOK, common.Error(500, "恢复库存失败"))
			return
		}
	}

	tx.Commit()

	result := map[string]interface{}{
		"message": "订单已取消",
	}

	c.JSON(http.StatusOK, common.Success(result))
}

// GetPurchaseOrderDetail 获取买单详情
func (h *UserOrderHandler) GetPurchaseOrderDetail(c *gin.Context) {
	orderID, err := strconv.ParseUint(c.Param("id"), 10, 32)
	if err != nil {
		c.JSON(http.StatusOK, common.Error(400, "订单ID无效"))
		return
	}

	currentUser, _ := c.Get("current_user")
	user := currentUser.(models.User)

	var order models.PurchaseOrder
	query := common.GetDB().Where("buyer_id = ?", user.ID).
		Preload("Buyer").
		Preload("Seller").
		Preload("Address")

	err = query.First(&order, uint(orderID)).Error
	if err != nil {
		if err == gorm.ErrRecordNotFound {
			c.JSON(http.StatusOK, common.Error(404, "订单不存在"))
		} else {
			c.JSON(http.StatusOK, common.Error(500, "查询订单详情失败"))
		}
		return
	}
	adminID := uint(1)
	if order.ProductType == 1 {
		if order.SellerID == nil {
			order.SellerID = &adminID
			var seller models.User

			common.GetDB().Where("id=?", order.SellerID).First(&seller)
			order.Seller = &seller
		}
	}

	c.JSON(http.StatusOK, common.Success(order))
}

// GetSalesOrderDetail 获取卖单详情
func (h *UserOrderHandler) GetSalesOrderDetail(c *gin.Context) {
	orderID, err := strconv.ParseUint(c.Param("id"), 10, 32)
	if err != nil {
		c.JSON(http.StatusOK, common.Error(400, "订单ID无效"))
		return
	}

	currentUser, _ := c.Get("current_user")
	user := currentUser.(models.User)

	var order models.SalesOrder
	query := common.GetDB().Where("seller_id = ?", user.ID).
		Preload("Seller").
		Preload("Buyer").
		Preload("Address")

	err = query.First(&order, uint(orderID)).Error
	if err != nil {
		if err == gorm.ErrRecordNotFound {
			c.JSON(http.StatusOK, common.Error(404, "订单不存在"))
		} else {
			c.JSON(http.StatusOK, common.Error(500, "查询订单详情失败"))
		}
		return
	}

	c.JSON(http.StatusOK, common.Success(order))
}