veza/veza-backend-api/internal/services/search_service.go

package services

import (
	"context"
	"fmt"

	"veza-backend-api/internal/database"

	"go.uber.org/zap"
)

// SearchService handles search operations
type SearchService struct {
	db     *database.Database
	logger *zap.Logger
}

// SearchResult represents search results (artists = users for frontend compatibility)
type SearchResult struct {
	Tracks    []TrackResult    `json:"tracks"`
	Users     []UserResult     `json:"artists"` // Frontend expects "artists" for user search results
	Playlists []PlaylistResult `json:"playlists"`
}

type TrackResult struct {
	ID            string `json:"id"`
	Title         string `json:"title"`
	Artist        string `json:"artist"`
	URL           string `json:"url"`
	CoverArtPath  string `json:"cover_art_path,omitempty"`
}

type UserResult struct {
	ID        string `json:"id"`
	Username  string `json:"username"`
	AvatarURL string `json:"avatar_url"` // Frontend MinimalArtist expects avatar_url
}

type PlaylistResult struct {
	ID    string `json:"id"`
	Name  string `json:"name"`
	Cover string `json:"cover"`
}

// NewSearchService creates a new search service
func NewSearchService(db *database.Database, logger *zap.Logger) *SearchService {
	return &SearchService{
		db:     db,
		logger: logger,
	}
}

// Search performs a full-text search
func (ss *SearchService) Search(query string, types []string) (*SearchResult, error) {
	ctx := context.Background()
	results := &SearchResult{}

	// Build search types - if empty, search all
	searchAll := len(types) == 0
	searchTracks := searchAll || contains(types, "track")
	searchUsers := searchAll || contains(types, "user")
	searchPlaylists := searchAll || contains(types, "playlist")

	// Search tracks (v0.203 Lot K: boolean operators)
	if searchTracks {
		parsed := ParseSearchQuery(query)
		cond, args := BuildWhereCondition(parsed, []string{"title", "artist", "album"})
		if cond == "" {
			cond = "(title ILIKE $1 OR artist ILIKE $1)"
			args = []interface{}{"%" + query + "%"}
		}
		sql := `SELECT id::text, title, COALESCE(artist, ''), COALESCE(stream_manifest_url, file_path), COALESCE(cover_art_path, '')
			FROM tracks
			WHERE (` + cond + `) AND deleted_at IS NULL AND status = 'active'
			LIMIT 10`
		rows, err := ss.db.QueryContext(ctx, sql, args...)
		if err != nil {
			return nil, fmt.Errorf("failed to search tracks: %w", err)
		}
		defer rows.Close()

		for rows.Next() {
			var track TrackResult
			if err := rows.Scan(&track.ID, &track.Title, &track.Artist, &track.URL, &track.CoverArtPath); err != nil {
				continue
			}
			results.Tracks = append(results.Tracks, track)
		}
	}

	// Search users (v0.203 Lot K: boolean operators)
	if searchUsers {
		parsed := ParseSearchQuery(query)
		cond, args := BuildWhereCondition(parsed, []string{"username"})
		if cond == "" {
			cond = "username ILIKE $1"
			args = []interface{}{"%" + query + "%"}
		}
		sql := `SELECT id::text, username, COALESCE(avatar, '')
			FROM users
			WHERE ` + cond + ` AND deleted_at IS NULL
			LIMIT 10`
		rows, err := ss.db.QueryContext(ctx, sql, args...)
		if err != nil {
			return nil, fmt.Errorf("failed to search users: %w", err)
		}
		defer rows.Close()

		for rows.Next() {
			var user UserResult
			if err := rows.Scan(&user.ID, &user.Username, &user.AvatarURL); err != nil {
				continue
			}
			results.Users = append(results.Users, user)
		}
	}

	// Search playlists (v0.203 Lot K: boolean operators)
	if searchPlaylists {
		parsed := ParseSearchQuery(query)
		cond, args := BuildWhereCondition(parsed, []string{"name"})
		if cond == "" {
			cond = "name ILIKE $1"
			args = []interface{}{"%" + query + "%"}
		}
		sql := `SELECT id::text, name, COALESCE(cover_url, '')
			FROM playlists
			WHERE (` + cond + `) AND (is_public = TRUE OR visibility = 'public') AND deleted_at IS NULL
			LIMIT 10`
		rows, err := ss.db.QueryContext(ctx, sql, args...)
		if err != nil {
			return nil, fmt.Errorf("failed to search playlists: %w", err)
		}
		defer rows.Close()

		for rows.Next() {
			var playlist PlaylistResult
			if err := rows.Scan(&playlist.ID, &playlist.Name, &playlist.Cover); err != nil {
				continue
			}
			results.Playlists = append(results.Playlists, playlist)
		}
	}

	return results, nil
}

// Suggestions returns autocomplete suggestions for tracks, users, and playlists.
func (ss *SearchService) Suggestions(query string, limit int) (*SearchResult, error) {
	ctx := context.Background()
	if limit <= 0 {
		limit = 5
	}
	pattern := "%" + query + "%"
	results := &SearchResult{}

	// Tracks
	trackRows, err := ss.db.QueryContext(ctx, `
		SELECT id::text, title, COALESCE(artist, ''), COALESCE(stream_manifest_url, file_path), COALESCE(cover_art_path, '')
		FROM tracks
		WHERE (title ILIKE $1 OR artist ILIKE $1) AND deleted_at IS NULL AND status = 'active'
		LIMIT $2
	`, pattern, limit)
	if err != nil {
		return nil, fmt.Errorf("failed to suggest tracks: %w", err)
	}
	defer trackRows.Close()
	for trackRows.Next() {
		var t TrackResult
		if err := trackRows.Scan(&t.ID, &t.Title, &t.Artist, &t.URL, &t.CoverArtPath); err != nil {
			continue
		}
		results.Tracks = append(results.Tracks, t)
	}

	// Users
	userRows, err := ss.db.QueryContext(ctx, `
		SELECT id::text, username, COALESCE(avatar, '')
		FROM users
		WHERE username ILIKE $1 AND deleted_at IS NULL
		LIMIT $2
	`, pattern, limit)
	if err != nil {
		return nil, fmt.Errorf("failed to suggest users: %w", err)
	}
	defer userRows.Close()
	for userRows.Next() {
		var u UserResult
		if err := userRows.Scan(&u.ID, &u.Username, &u.AvatarURL); err != nil {
			continue
		}
		results.Users = append(results.Users, u)
	}

	// Playlists
	playlistRows, err := ss.db.QueryContext(ctx, `
		SELECT id::text, name, COALESCE(cover_url, '')
		FROM playlists
		WHERE name ILIKE $1 AND (is_public = TRUE OR visibility = 'public') AND deleted_at IS NULL
		LIMIT $2
	`, pattern, limit)
	if err != nil {
		return nil, fmt.Errorf("failed to suggest playlists: %w", err)
	}
	defer playlistRows.Close()
	for playlistRows.Next() {
		var p PlaylistResult
		if err := playlistRows.Scan(&p.ID, &p.Name, &p.Cover); err != nil {
			continue
		}
		results.Playlists = append(results.Playlists, p)
	}

	return results, nil
}

func contains(slice []string, item string) bool {
	for _, s := range slice {
		if s == item {
			return true
		}
	}
	return false
}