package service

import (
	"encoding/json"
	"psi/database"
	"psi/models"
	systemReq "psi/models/request"
	systemRes "psi/models/response"
	"psi/utils"

	"gorm.io/gorm"
)

type ReceivingService struct{}

// GetReceivingOrderList 获取入库单列表
func (s *ReceivingService) GetReceivingOrderList(req systemReq.GetReceivingOrderListRequest, creatorID int64, role int64, db ...*gorm.DB) (*systemRes.ReceivingOrderListResponse, error) {
	databaseConn := database.OptionalDB(db...)

	if req.Page < 1 {
		req.Page = 1
	}
	if req.PageSize < 1 || req.PageSize > 100 {
		req.PageSize = 20
	}

	query := databaseConn.Model(&models.ReceivingOrder{}).Where("receiving_order.is_del = ?", 0)
	if role == 128 {
		query = query.Where("receiving_order.operator_id = ?", creatorID)
	}

	if req.Status > 0 {
		query = query.Where("receiving_order.status = ?", req.Status)
	}
	if req.SupplierID > 0 {
		query = query.Where("receiving_order.supplier_id = ?", req.SupplierID)
	}
	if req.WarehouseID > 0 {
		query = query.Where("receiving_order.warehouse_id = ?", req.WarehouseID)
	}
	if req.PurchaseOrderID > 0 {
		query = query.Where("receiving_order.purchase_order_id = ?", req.PurchaseOrderID)
	}
	if req.WaveTaskID > 0 {
		query = query.Where("receiving_order.wave_task_id = ?", req.WaveTaskID)
	}
	if req.ReceivingNo != "" {
		query = query.Where("receiving_order.receiving_no LIKE ?", "%"+req.ReceivingNo+"%")
	}
	if req.StartDate > 0 {
		query = query.Where("receiving_order.created_at >= ?", req.StartDate)
	}
	if req.EndDate > 0 {
		query = query.Where("receiving_order.created_at <= ?", req.EndDate)
	}

	var total int64
	if err := query.Count(&total).Error; err != nil {
		return nil, utils.NewError("查询总数失败")
	}

	if total == 0 {
		return &systemRes.ReceivingOrderListResponse{
			List:     []systemRes.ReceivingOrderItem{},
			Total:    0,
			Page:     req.Page,
			PageSize: req.PageSize,
		}, nil
	}

	var orders []systemRes.ReceivingOrderWithInfo
	offset := (req.Page - 1) * req.PageSize
	if err := query.Select("receiving_order.*, s.name as supplier_name, w.name as warehouse_name, p.po_no,wt.task_no").
		Joins("LEFT JOIN supplier s ON receiving_order.supplier_id = s.id AND s.is_del = 0").
		Joins("LEFT JOIN warehouse w ON receiving_order.warehouse_id = w.id AND w.is_del = 0").
		Joins("LEFT JOIN purchase_order p ON receiving_order.purchase_order_id = p.id AND p.is_del = 0").
		Joins("LEFT JOIN wave_task wt ON receiving_order.wave_task_id = wt.id AND wt.is_del = 0").
		Order("receiving_order.created_at DESC").
		Offset(offset).
		Limit(req.PageSize).
		Find(&orders).Error; err != nil {
		return nil, utils.NewError("查询入库单列表失败")
	}

	orderItems := make([]systemRes.ReceivingOrderItem, 0, len(orders))
	for _, order := range orders {
		orderItems = append(orderItems, systemRes.ConvertReceivingOrderToItem(
			order.ReceivingOrder,
			order.SupplierName,
			order.WarehouseName,
			order.PoNo,
			order.TaskNo,
		))
	}

	return &systemRes.ReceivingOrderListResponse{
		List:     orderItems,
		Total:    total,
		Page:     req.Page,
		PageSize: req.PageSize,
	}, nil
}

// GetReceivingOrderDetail 获取入库单详情
func (s *ReceivingService) GetReceivingOrderDetail(id int64, creatorID int64, role int64, db ...*gorm.DB) (*systemRes.ReceivingOrderDetailResponse, error) {
	databaseConn := database.OptionalDB(db...)

	query := databaseConn.Model(&models.ReceivingOrder{}).
		Select("receiving_order.*, s.name as supplier_name, w.name as warehouse_name, p.po_no").
		Joins("LEFT JOIN supplier s ON receiving_order.supplier_id = s.id AND s.is_del = 0").
		Joins("LEFT JOIN warehouse w ON receiving_order.warehouse_id = w.id AND w.is_del = 0").
		Joins("LEFT JOIN purchase_order p ON receiving_order.purchase_order_id = p.id AND p.is_del = 0").
		Where("receiving_order.id = ? AND receiving_order.is_del = ?", id, 0)

	if role == 128 {
		query = query.Where("receiving_order.operator_id = ?", creatorID)
	}

	var order systemRes.ReceivingOrderWithInfo
	result := query.First(&order)

	if result.Error != nil {
		return nil, utils.NewError("入库单不存在")
	}

	var items []systemRes.ReceivingOrderItemWithProduct
	databaseConn.Model(&models.ReceivingOrderItem{}).
		Select("receiving_order_item.*, p.name as product_name, p.barcode as product_code, p.category_id, c.name as category_name, p.live_image, l.code as location_code").
		Joins("LEFT JOIN product p ON receiving_order_item.product_id = p.id AND p.is_del = 0").
		Joins("LEFT JOIN product_category c ON p.category_id = c.id AND c.is_del = 0").
		Joins("LEFT JOIN location l ON receiving_order_item.location_id = l.id AND l.is_del = 0").
		Where("receiving_order_item.receiving_order_id = ? AND receiving_order_item.is_del = ?", order.ID, 0).
		Find(&items)

	detailItems := make([]systemRes.ReceivingOrderDetailItem, 0, len(items))
	for _, item := range items {
		var imageList []string
		if len(item.LiveImage) > 0 {
			json.Unmarshal(item.LiveImage, &imageList)
		}

		detailItems = append(detailItems, systemRes.ReceivingOrderDetailItem{
			ID:               item.ID,
			ReceivingOrderID: item.ReceivingOrderID,
			ProductID:        item.ProductID,
			ProductName:      item.ProductName,
			ProductCode:      item.ProductCode,
			CategoryID:       item.CategoryID,
			CategoryName:     item.CategoryName,
			LiveImage:        imageList,
			LocationID:       item.LocationID,
			LocationCode:     item.LocationCode,
			BatchNo:          item.BatchNo,
			ProductionDate:   item.ProductionDate,
			ExpiryDate:       item.ExpiryDate,
			Quantity:         item.Quantity,
			CreatedAt:        item.CreatedAt,
			UpdatedAt:        item.UpdatedAt,
		})
	}

	detail := systemRes.ConvertReceivingOrderToDetail(order.ReceivingOrder, order.SupplierName, order.WarehouseName, order.PoNo, detailItems)
	return &detail, nil
}