tm_back/internal/tender/recommendation_response.go

package tender

import (
	"context"
	"fmt"
	"strings"
	"sync"

	"golang.org/x/sync/errgroup"

	"tm/pkg/ai_summarizer"
)

const recommendationTranslationConcurrency = 8

type rankedRecommendedTender struct {
	tender    Tender
	rank      int
	analysis  string
	tenderRef string
}

type recommendationTranslationCache struct {
	mu    sync.Mutex
	items map[string]ai_summarizer.StoredTranslation
}

func newRecommendationTranslationCache() *recommendationTranslationCache {
	return &recommendationTranslationCache{
		items: make(map[string]ai_summarizer.StoredTranslation),
	}
}

func recommendationTranslationCacheKey(tenderID, language string) string {
	return strings.TrimSpace(tenderID) + "|" + strings.TrimSpace(language)
}

func (c *recommendationTranslationCache) get(tenderID, language string) (ai_summarizer.StoredTranslation, bool) {
	if c == nil {
		return ai_summarizer.StoredTranslation{}, false
	}
	c.mu.Lock()
	defer c.mu.Unlock()
	stored, ok := c.items[recommendationTranslationCacheKey(tenderID, language)]
	return stored, ok
}

func (c *recommendationTranslationCache) set(tenderID, language string, stored ai_summarizer.StoredTranslation) {
	if c == nil {
		return
	}
	c.mu.Lock()
	defer c.mu.Unlock()
	c.items[recommendationTranslationCacheKey(tenderID, language)] = stored
}

func (s *tenderService) buildRecommendedTenderResponsesParallel(
	ctx context.Context,
	items []rankedRecommendedTender,
	language string,
) []TenderResponse {
	if len(items) == 0 {
		return nil
	}

	out := make([]TenderResponse, len(items))
	if len(items) == 1 {
		out[0] = s.buildRecommendedTenderResponse(ctx, items[0].tender, items[0].rank, items[0].analysis, items[0].tenderRef, language, newRecommendationTranslationCache())
		return out
	}

	translationCache := newRecommendationTranslationCache()
	group, groupCtx := errgroup.WithContext(ctx)
	group.SetLimit(recommendationTranslationConcurrency)

	for i := range items {
		i := i
		item := items[i]
		group.Go(func() error {
			out[i] = s.buildRecommendedTenderResponse(
				groupCtx,
				item.tender,
				item.rank,
				item.analysis,
				item.tenderRef,
				language,
				translationCache,
			)
			return nil
		})
	}

	if err := group.Wait(); err != nil {
		s.logger.Warn("Parallel recommendation response build degraded to sequential", map[string]interface{}{
			"error": err.Error(),
			"count": len(items),
		})
		for i, item := range items {
			out[i] = s.buildRecommendedTenderResponse(ctx, item.tender, item.rank, item.analysis, item.tenderRef, language, translationCache)
		}
	}

	return out
}

func (s *tenderService) loadRecommendationExclusions(
	ctx context.Context,
	form *SearchForm,
	companyID string,
	companyIDs []string,
) (map[string]struct{}, map[string]map[string]struct{}, error) {
	if !form.ExcludeRejectedTenders {
		return nil, nil, nil
	}

	if len(companyIDs) > 0 {
		excludedByCompany, err := s.buildRejectedTenderIDSetsForCompanies(ctx, companyIDs)
		if err != nil {
			return nil, nil, fmt.Errorf("failed to build recommendation exclusions: %w", err)
		}
		return nil, excludedByCompany, nil
	}

	excluded, err := s.buildRejectedTenderIDSet(ctx, companyID)
	if err != nil {
		return nil, nil, fmt.Errorf("failed to build recommendation exclusions: %w", err)
	}
	return excluded, nil, nil
}