package service

import (
	"assets/consts/procurement"
	"assets/dao/procurement"
	"assets/model/dto/procurement"
	"assets/model/entity/procurement"
	"context"
	"github.com/gogf/gf/v2/os/gtime"

	"github.com/gogf/gf/v2/errors/gerror"
	"go.mongodb.org/mongo-driver/v2/bson"
)

type purchaseOrder struct{}

// PurchaseOrder 采购订单服务
var PurchaseOrder = new(purchaseOrder)

// CreatePurchaseOrder 创建采购订单
func (s *purchaseOrder) CreatePurchaseOrder(ctx context.Context, req *dto.CreatePurchaseOrderReq) (*dto.CreatePurchaseOrderRes, error) {

	// 保存到数据库
	ids, err := dao.PurchaseOrder.Insert(ctx, req)
	if err != nil {
		return nil, gerror.Wrap(err, "创建采购订单失败")
	}

	var id *bson.ObjectID
	if len(ids) > 0 {
		if objectID, ok := ids[0].(bson.ObjectID); ok {
			id = &objectID
		}
	}

	return &dto.CreatePurchaseOrderRes{ID: id}, nil
}

// BatchCreatePurchaseOrders 批量创建采购订单
func (s *purchaseOrder) BatchCreatePurchaseOrders(ctx context.Context, req *dto.BatchCreatePurchaseOrdersReq) (*dto.BatchCreatePurchaseOrdersRes, error) {
	// 保存到数据库
	ids, err := dao.PurchaseOrder.BatchInsert(ctx, req)
	if err != nil {
		return nil, gerror.Wrap(err, "批量创建采购订单失败")
	}

	// 转换ID列表
	idList := make([]*bson.ObjectID, 0, len(ids))
	for _, id := range ids {
		if objectID, ok := id.(bson.ObjectID); ok {
			idList = append(idList, &objectID)
		}
	}

	return &dto.BatchCreatePurchaseOrdersRes{IDs: idList}, nil
}

// UpdatePurchaseOrder 更新采购订单
func (s *purchaseOrder) UpdatePurchaseOrder(ctx context.Context, req *dto.UpdatePurchaseOrderReq) error {
	// 更新到数据库
	err := dao.PurchaseOrder.Update(ctx, req)
	if err != nil {
		return gerror.Wrap(err, "更新采购订单失败")
	}

	return nil
}

// DeletePurchaseOrder 删除采购订单
func (s *purchaseOrder) DeletePurchaseOrder(ctx context.Context, id *bson.ObjectID) error {
	return dao.PurchaseOrder.DeleteFake(ctx, id)
}

// GetPurchaseOrder 获取采购订单详情
func (s *purchaseOrder) GetPurchaseOrder(ctx context.Context, id *bson.ObjectID) (*dto.GetPurchaseOrderRes, error) {
	order, err := dao.PurchaseOrder.GetOne(ctx, id)
	if err != nil {
		return nil, gerror.Wrap(err, "获取采购订单失败")
	}

	// 转换为响应
	res := &dto.GetPurchaseOrderRes{
		ID:               order.Id,
		OrderNo:          order.OrderNo,
		Title:            order.Title,
		Description:      order.Description,
		OrderType:        order.OrderType,
		BuyerId:          order.BuyerId,
		BuyerName:        order.BuyerName,
		BuyerType:        order.BuyerType,
		Status:           order.Status,
		StatusText:       consts.GetPurchaseOrderStatusText(order.Status),
		Priority:         order.Priority,
		ExpectedDelivery: formatGTime(order.ExpectedDelivery),
		ExpiryTime:       formatGTime(order.ExpiryTime),
		CreatedAt:        order.CreatedAt.Format("2006-01-02 15:04:05"),
		UpdatedAt:        order.UpdatedAt.Format("2006-01-02 15:04:05"),
	}

	// 转换指定供应商模式信息
	if order.DirectPurchase != nil {
		res.DirectPurchase = &dto.DirectPurchaseInfoRes{
			SupplierId:      order.DirectPurchase.SupplierId,
			SupplierName:    order.DirectPurchase.SupplierName,
			SupplierCode:    order.DirectPurchase.SupplierCode,
			AssignReason:    order.DirectPurchase.AssignReason,
			DeliveryAddress: order.DirectPurchase.DeliveryAddress,
			ContactPerson:   order.DirectPurchase.ContactPerson,
			ContactPhone:    order.DirectPurchase.ContactPhone,
			ResponseStatus:  order.DirectPurchase.ResponseStatus,
			AssignedAt:      formatGTime(order.DirectPurchase.AssignedAt),
			AcceptedAt:      formatGTime(order.DirectPurchase.AcceptedAt),
			RejectedAt:      formatGTime(order.DirectPurchase.RejectedAt),
			DeliveredAt:     formatGTime(order.DirectPurchase.DeliveredAt),
		}
	}

	// 转换竞价模式信息
	if order.BiddingInfo != nil {
		res.BiddingInfo = &dto.BiddingInfoRes{
			BidMode:           order.BiddingInfo.BidMode,
			BidModeText:       consts.GetBidModeText(order.BiddingInfo.BidMode),
			MinSuppliers:      order.BiddingInfo.MinSuppliers,
			MaxSuppliers:      order.BiddingInfo.MaxSuppliers,
			BidDuration:       order.BiddingInfo.BidDuration,
			BidSupplierCount:  order.BiddingInfo.BidSupplierCount,
			BidStartAt:        formatGTime(order.BiddingInfo.BidStartAt),
			BidEndAt:          formatGTime(order.BiddingInfo.BidEndAt),
			ResultPublishedAt: formatGTime(order.BiddingInfo.ResultPublishedAt),
		}
	}

	return res, nil
}

// ListPurchaseOrders 获取采购订单列表
func (s *purchaseOrder) ListPurchaseOrders(ctx context.Context, req *dto.ListPurchaseOrdersReq) (*dto.ListPurchaseOrdersRes, error) {
	// 获取数据
	orders, total, err := dao.PurchaseOrder.List(ctx, req)
	if err != nil {
		return nil, gerror.Wrap(err, "获取采购订单列表失败")
	}

	// 转换为响应
	listItems := make([]*dto.PurchaseOrderListItem, 0, len(orders))
	for _, order := range orders {
		listItems = append(listItems, &dto.PurchaseOrderListItem{
			ID:               order.Id,
			OrderNo:          order.OrderNo,
			Title:            order.Title,
			OrderType:        order.OrderType,
			OrderTypeText:    consts.GetPurchaseOrderTypeText(order.OrderType),
			BuyerName:        order.BuyerName,
			BuyerType:        order.BuyerType,
			Status:           order.Status,
			StatusText:       consts.GetPurchaseOrderStatusText(order.Status),
			Priority:         order.Priority,
			ExpectedDelivery: formatGTime(order.ExpectedDelivery),
			ExpiryTime:       formatGTime(order.ExpiryTime),
			CreatedAt:        order.CreatedAt.Format("2006-01-02 15:04:05"),
			UpdatedAt:        order.UpdatedAt.Format("2006-01-02 15:04:05"),
		})
	}

	return &dto.ListPurchaseOrdersRes{
		List:  listItems,
		Total: total,
	}, nil
}

// ListByBuyerId 根据采购方ID获取采购订单列表
func (s *purchaseOrder) ListByBuyerId(ctx context.Context, buyerId *bson.ObjectID) ([]*entity.PurchaseOrder, error) {
	orders, err := dao.PurchaseOrder.ListByBuyerId(ctx, buyerId)
	if err != nil {
		return nil, gerror.Wrap(err, "获取订单列表失败")
	}
	return orders, nil
}

// GenerateTestData 生成测试数据
func (s *purchaseOrder) GenerateTestData(ctx context.Context) error {

	testData := &dto.BatchCreatePurchaseOrdersReq{}

	_, err := s.BatchCreatePurchaseOrders(ctx, testData)
	if err != nil {
		return gerror.Wrap(err, "生成测试数据失败")
	}

	return nil
}

// formatGTime 格式化时间
func formatGTime(t *gtime.Time) string {
	if t == nil {
		return ""
	}
	return t.Format("2006-01-02 15:04:05")
}