package service
import (
"context"
"encoding/json"
"fmt"
"strings"
"time"
"github.com/elastic/go-elasticsearch/v8"
"github.com/elastic/go-elasticsearch/v8/esapi"
"github.com/faisalaffan/qcommerce/internal/search/model"
)
// SearchRequest adalah request dari client
type SearchRequest struct {
Query string `json:"query"`
HubID string `json:"hub_id"` // required for stock filtering
Category string `json:"category,omitempty"` // filter by category
Brands []string `json:"brands,omitempty"` // filter by brand
MinPrice int64 `json:"min_price,omitempty"`
MaxPrice int64 `json:"max_price,omitempty"`
SortBy string `json:"sort_by,omitempty"` // relevance, price_asc, price_desc, popularity
Page int `json:"page"`
Size int `json:"size"`
}
// SearchResult adalah hasil pencarian yang sudah difilter stock
type SearchResult struct {
Total int64 `json:"total"`
Products []RankedProduct `json:"products"`
Page int `json:"page"`
Size int `json:"size"`
TotalPages int `json:"total_pages"`
TookMs int64 `json:"took_ms"`
}
type RankedProduct struct {
Product model.ProductDocument `json:"product"`
Score float64 `json:"score"`
InStock bool `json:"in_stock"`
StockQty int `json:"stock_qty,omitempty"`
}
// SearchService handles search operations
type SearchService struct {
es *elasticsearch.Client
stockSvc *StockFilterService
index string
}
func NewSearchService(es *elasticsearch.Client, stockSvc *StockFilterService, index string) *SearchService {
return &SearchService{
es: es,
stockSvc: stockSvc,
index: index,
}
}
// Search melakukan full-text search dengan stock filtering
func (s *SearchService) Search(ctx context.Context, req SearchRequest) (*SearchResult, error) {
start := time.Now()
if req.Page <= 0 {
req.Page = 1
}
if req.Size <= 0 || req.Size > 100 {
req.Size = 20
}
// 1. Build multi-match query dengan fuzziness
query := s.buildSearchQuery(req)
// 2. Execute search ke Elasticsearch
from := (req.Page - 1) * req.Size
searchBody := map[string]interface{}{
"from": from,
"size": req.Size,
"query": query,
"_source": true,
}
// Add sorting
if req.SortBy != "" && req.SortBy != "relevance" {
searchBody["sort"] = s.buildSort(req.SortBy)
}
body, err := json.Marshal(searchBody)
if err != nil {
return nil, fmt.Errorf("marshal search body: %w", err)
}
res, err := s.es.Search(
s.es.Search.WithContext(ctx),
s.es.Search.WithIndex(s.index),
s.es.Search.WithBody(strings.NewReader(string(body))),
)
if err != nil {
return nil, fmt.Errorf("elasticsearch search: %w", err)
}
defer res.Body.Close()
if res.IsError() {
return nil, fmt.Errorf("elasticsearch error: %s", res.String())
}
// 3. Parse response
var esResponse struct {
Hits struct {
Total struct {
Value int64 `json:"value"`
} `json:"total"`
Hits []struct {
Score float64 `json:"_score"`
Source model.ProductDocument `json:"_source"`
} `json:"hits"`
} `json:"hits"`
}
if err := json.NewDecoder(res.Body).Decode(&esResponse); err != nil {
return nil, fmt.Errorf("decode search response: %w", err)
}
// 4. Extract SKUs for stock check
var products []model.ProductDocument
skus := make([]string, 0, len(esResponse.Hits.Hits))
scores := make(map[string]float64)
for _, hit := range esResponse.Hits.Hits {
products = append(products, hit.Source)
skus = append(skus, hit.Source.SKU)
scores[hit.Source.SKU] = hit.Score
}
// 5. Batch stock check via Redis pipeline
stockMap, err := s.stockSvc.BatchCheckStock(ctx, req.HubID, skus)
if err != nil {
// Log error but still return products (without stock info)
fmt.Printf("stock check failed: %v\n", err)
stockMap = make(map[string]StockInfo)
}
// 6. Rank and return
ranked := make([]RankedProduct, 0, len(products))
for _, p := range products {
stock := stockMap[p.SKU]
ranked = append(ranked, RankedProduct{
Product: p,
Score: scores[p.SKU],
InStock: stock.Available,
StockQty: stock.Quantity,
})
}
// 7. Filter out-of-stock if configured
// In Q-commerce, we typically show in-stock first, then out-of-stock
ranked = s.applyStockPriority(ranked)
totalPages := int(esResponse.Hits.Total.Value) / req.Size
if int(esResponse.Hits.Total.Value)%req.Size > 0 {
totalPages++
}
return &SearchResult{
Total: esResponse.Hits.Total.Value,
Products: ranked,
Page: req.Page,
Size: req.Size,
TotalPages: totalPages,
TookMs: time.Since(start).Milliseconds(),
}, nil
}
// buildSearchQuery membangun multi-match query dengan fuzziness
func (s *SearchService) buildSearchQuery(req SearchRequest) map[string]interface{} {
must := make([]map[string]interface{}, 0)
filter := make([]map[string]interface{}, 0)
// Full-text search dengan multi-match
if req.Query != "" {
must = append(must, map[string]interface{}{
"multi_match": map[string]interface{}{
"query": req.Query,
"fields": []string{"name^3", "description", "category_name^2", "brand^2", "tags"},
"type": "best_fields",
"fuzziness": "AUTO",
"prefix_length": 2,
"max_expansions": 50,
"tie_breaker": 0.3,
},
})
} else {
// No query: return all (browse mode)
must = append(must, map[string]interface{}{
"match_all": map[string]interface{}{},
})
}
// Filters
if req.Category != "" {
filter = append(filter, map[string]interface{}{
"term": map[string]interface{}{"category_id": req.Category},
})
}
if len(req.Brands) > 0 {
filter = append(filter, map[string]interface{}{
"terms": map[string]interface{}{"brand": req.Brands},
})
}
if req.MinPrice > 0 || req.MaxPrice > 0 {
rangeFilter := make(map[string]interface{})
if req.MinPrice > 0 {
rangeFilter["gte"] = req.MinPrice
}
if req.MaxPrice > 0 {
rangeFilter["lte"] = req.MaxPrice
}
filter = append(filter, map[string]interface{}{
"range": map[string]interface{}{"price": rangeFilter},
})
}
// Only active products
filter = append(filter, map[string]interface{}{
"term": map[string]interface{}{"is_active": true},
})
query := map[string]interface{}{
"bool": map[string]interface{}{
"must": must,
"filter": filter,
},
}
return query
}
func (s *SearchService) buildSort(sortBy string) []map[string]interface{} {
switch sortBy {
case "price_asc":
return []map[string]interface{}{
{"price": map[string]interface{}{"order": "asc"}},
}
case "price_desc":
return []map[string]interface{}{
{"price": map[string]interface{}{"order": "desc"}},
}
case "popularity":
return []map[string]interface{}{
{"popularity_score": map[string]interface{}{"order": "desc"}},
}
default:
return nil // relevance = default Elasticsearch _score sorting
}
}
// applyStockPriority: in-stock first, then out-of-stock
func (s *SearchService) applyStockPriority(products []RankedProduct) []RankedProduct {
inStock := make([]RankedProduct, 0, len(products))
outOfStock := make([]RankedProduct, 0, len(products))
for _, p := range products {
if p.InStock {
inStock = append(inStock, p)
} else {
outOfStock = append(outOfStock, p)
}
}
return append(inStock, outOfStock...)
}
