package service

import (
	"reflect"
	req "sghgogs.com/micro/shopping-service/domain/model/request"
	pb "sghgogs.com/micro/shopping-service/proto"
	"sghgogs.com/micro/shopping-service/utils"
	"time"
)

func (svc *Service) getPaymentRes(payment *req.Payment) *pb.Payment {
	var updatedAt int64
	if payment.UpdatedAt != nil {
		if payment.CreatedAt.Truncate(time.Second) == payment.UpdatedAt.Truncate(time.Second) {
			payment.UpdatedAt = nil
		} else {
			updatedAt = utils.ConvertTimeToInt64(*payment.UpdatedAt)
		}
	}
	return &pb.Payment{
		Id:            payment.ID,
		OrderId:       payment.OrderID,
		Amount:        payment.Amount,
		Status:        payment.Status,
		PaymentMethod: payment.PaymentMethod,
		CreatedAt:     utils.ConvertTimeToInt64(payment.CreatedAt),
		UpdatedAt:     updatedAt,
	}
}

func (svc *Service) getUserRes(user *req.User) *pb.User {
	var updatedAt int64
	if user.UpdatedAt != nil {
		if user.CreatedAt.Truncate(time.Second) == user.UpdatedAt.Truncate(time.Second) {
			user.UpdatedAt = nil
		} else {
			updatedAt = utils.ConvertTimeToInt64(*user.UpdatedAt)
		}
	}
	return &pb.User{
		Id:          user.ID,
		Username:    user.Username,
		Password:    user.Password,
		PhoneNumber: user.PhoneNumber,
		Email:       user.Email,
		Avatar:      user.Avatar,
		CreatedAt:   utils.ConvertTimeToInt64(user.CreatedAt),
		CreatedBy:   user.CreatedBy,
		UpdatedAt:   updatedAt,
		UpdatedBy:   user.UpdatedBy,
		Status:      user.Status,
	}
}

// func (svc *Service) getOrdersRes() []*pb.Order {
// }

func (svc *Service) getShoppingCarts(cart req.ShoppingCart) *pb.ShoppingCart {
	return &pb.ShoppingCart{
		Id:        cart.ID,
		UserId:    cart.UserID,
		CreatedAt: utils.ConvertTimeToInt64(cart.CreatedAt),
		UpdatedAt: utils.ConvertTimeToInt64(*cart.UpdatedAt),
		Quantity:  cart.Quantity,
		Items:     svc.getShoppingCartItem(cart.Items),
	}
}

func (svc *Service) getShoppingCartItem(items []req.ShoppingCartItem) []*pb.ShoppingCartItem {
	cartItems := make([]*pb.ShoppingCartItem, 0)
	for _, item := range items {
		cartItems = append(cartItems, &pb.ShoppingCartItem{
			Id:             item.ID,
			ShoppingCartId: item.ShoppingCartID,
			ProductId:      item.ProductID,
			Product:        svc.getProduct(item.Product),
			Quantity:       item.Quantity,
			TotalPrice:     item.TotalPrice,
		})
	}
	return cartItems
}

func (svc *Service) getProduct(product req.Product) *pb.Product {
	return &pb.Product{
		Id:            product.ID,
		Name:          product.Name,
		Description:   product.Description,
		Price:         product.Price,
		StockQuantity: product.StockQuantity,
		CreatedAt:     utils.ConvertTimeToInt64(product.CreatedAt),
		UpdatedAt:     utils.ConvertTimeToInt64(*product.UpdatedAt),
		CategoryId:    product.CategoryID,
		Category:      svc.getCategory(product.Category),
	}
}

func (svc *Service) getCategory(category req.Category) *pb.Category {
	return &pb.Category{
		Id:        category.ID,
		Name:      category.Name,
		CreatedAt: utils.ConvertTimeToInt64(category.CreatedAt),
		UpdatedAt: utils.ConvertTimeToInt64(*category.UpdatedAt),
	}
}

func (svc *Service) getAddresses(address []req.Address) []*pb.Address {
	addresses := make([]*pb.Address, 0)
	for _, item := range address {
		addresses = append(addresses, &pb.Address{
			Id:        item.ID,
			UserId:    item.UserID,
			Country:   item.Country,
			Province:  item.Province,
			City:      item.City,
			District:  item.District,
			Remark:    item.Remark,
			IsDefault: item.IsDefault,
		})
	}
	return addresses
}
func (svc *Service) filterNilFields(m map[string]interface{}) map[string]interface{} {
	result := make(map[string]interface{})
	for key, value := range m {
		// 判断是否为布尔值或数值类型的默认零值
		if value != reflect.Zero(reflect.TypeOf(value)).Interface() {
			result[key] = value
		}
	}
	return result
}

func (svc *Service) getOrdersRes(orders []req.Order) []*pb.Order {
	items := make([]*pb.Order, 0)
	for _, item := range orders {
		items = append(items, svc.getOrderRes(item))
	}
	return items
}
func (svc *Service) getOrderRes(order req.Order) *pb.Order {
	var updatedAt int64
	if order.UpdatedAt != nil {
		if order.CreatedAt.Truncate(time.Second) == order.UpdatedAt.Truncate(time.Second) {
			order.UpdatedAt = nil
		} else {
			updatedAt = utils.ConvertTimeToInt64(*order.UpdatedAt)
		}
	}
	return &pb.Order{
		Id:            order.ID,
		UserId:        order.UserID,
		AddressId:     order.AddressID,
		Address:       svc.getAddressRes(order.Address),
		TotalAmount:   order.TotalAmount,
		Status:        order.Status,
		PaymentMethod: order.PaymentMethod,
		CreatedAt:     utils.ConvertTimeToInt64(order.CreatedAt),
		UpdatedAt:     updatedAt,
		Payment:       svc.getPaymentRes(&order.Payment),
	}
}