metadata-agregator/internal/service/metadata.go

package service

import (
	"context"
	"errors"

	"github.com/rs/zerolog"

	"github.com/metadata-agregator/internal/domain"
	"github.com/metadata-agregator/internal/metrics"
	"github.com/metadata-agregator/internal/provider"
	"github.com/metadata-agregator/internal/repository"
)

type MetadataService struct {
	artists  repository.ArtistRepository
	albums   repository.AlbumRepository
	tracks   repository.TrackRepository
	provider provider.Provider
}

func NewMetadataService(
	artists repository.ArtistRepository,
	albums repository.AlbumRepository,
	tracks repository.TrackRepository,
	prov provider.Provider,
) *MetadataService {
	return &MetadataService{
		artists:  artists,
		albums:   albums,
		tracks:   tracks,
		provider: prov,
	}
}

func (s *MetadataService) GetArtist(ctx context.Context, id string) (*domain.Artist, error) {
	log := zerolog.Ctx(ctx)

	artist, err := s.artists.GetByExternalID(ctx, s.provider.Name(), id)
	if err == nil {
		log.Debug().Str("artist_id", id).Msg("artist cache hit")
		metrics.CacheHits.WithLabelValues("artist").Inc()
		return artist, nil
	}
	if !errors.Is(err, repository.ErrNotFound) {
		log.Error().Err(err).Str("artist_id", id).Msg("artist cache lookup failed")
		return nil, err
	}

	metrics.CacheMisses.WithLabelValues("artist").Inc()
	log.Debug().Str("artist_id", id).Str("provider", s.provider.Name()).Msg("artist cache miss, fetching from provider")

	artist, err = s.provider.GetArtist(ctx, id)
	if err != nil {
		log.Debug().Err(err).Str("artist_id", id).Msg("provider fetch failed")
		return nil, err
	}

	if saveErr := s.artists.Save(ctx, artist); saveErr != nil {
		log.Warn().Err(saveErr).Str("artist_id", id).Msg("failed to cache artist")
		return artist, nil
	}

	log.Trace().Str("artist_id", id).Msg("artist cached successfully")
	return artist, nil
}

func (s *MetadataService) SearchArtists(ctx context.Context, query string, limit, offset int) (*domain.SearchResult[domain.Artist], error) {
	log := zerolog.Ctx(ctx)

	result, err := s.artists.Search(ctx, query, limit, offset)
	if err == nil && len(result.Items) > 0 {
		log.Debug().Int("count", len(result.Items)).Msg("artist search served from cache")
		metrics.CacheHits.WithLabelValues("artist_search").Inc()
		return result, nil
	}

	metrics.CacheMisses.WithLabelValues("artist_search").Inc()
	log.Debug().Str("query", query).Str("provider", s.provider.Name()).Msg("artist search cache miss, querying provider")
	return s.provider.SearchArtists(ctx, query, limit, offset)
}

func (s *MetadataService) SearchAlbums(ctx context.Context, query string, artist string, limit, offset int) (*domain.SearchResult[domain.Album], error) {
	zerolog.Ctx(ctx).Debug().Str("query", query).Str("artist", artist).Str("provider", s.provider.Name()).Msg("searching albums via provider")
	return s.provider.SearchAlbums(ctx, query, artist, limit, offset)
}

func (s *MetadataService) GetAlbum(ctx context.Context, id string) (*domain.Album, error) {
	log := zerolog.Ctx(ctx)

	album, err := s.albums.GetByExternalID(ctx, s.provider.Name(), id)
	if err == nil {
		log.Debug().Str("album_id", id).Msg("album cache hit")
		metrics.CacheHits.WithLabelValues("album").Inc()
		return album, nil
	}
	if !errors.Is(err, repository.ErrNotFound) {
		log.Error().Err(err).Str("album_id", id).Msg("album cache lookup failed")
		return nil, err
	}

	metrics.CacheMisses.WithLabelValues("album").Inc()
	log.Debug().Str("album_id", id).Str("provider", s.provider.Name()).Msg("album cache miss, fetching from provider")

	album, err = s.provider.GetAlbum(ctx, id)
	if err != nil {
		log.Debug().Err(err).Str("album_id", id).Msg("provider fetch failed")
		return nil, err
	}

	if saveErr := s.albums.Save(ctx, album); saveErr != nil {
		log.Warn().Err(saveErr).Str("album_id", id).Msg("failed to cache album")
		return album, nil
	}

	log.Trace().Str("album_id", id).Msg("album cached successfully")
	return album, nil
}

func (s *MetadataService) GetArtistAlbums(ctx context.Context, artistID string) ([]domain.Album, error) {
	log := zerolog.Ctx(ctx)

	cached, err := s.albums.GetAllByArtistID(ctx, artistID)
	if err == nil && len(cached) > 0 {
		log.Debug().Str("artist_id", artistID).Int("count", len(cached)).Msg("artist albums cache hit")
		metrics.CacheHits.WithLabelValues("artist_albums").Inc()
		return cached, nil
	}

	metrics.CacheMisses.WithLabelValues("artist_albums").Inc()
	log.Debug().Str("artist_id", artistID).Str("provider", s.provider.Name()).Msg("artist albums cache miss, fetching from provider")

	albums, err := s.provider.GetArtistAlbums(ctx, artistID)
	if err != nil {
		return nil, err
	}

	s.ensureArtistsCached(ctx, albums)

	if saveErr := s.albums.SaveAll(ctx, albums); saveErr != nil {
		log.Warn().Err(saveErr).Str("artist_id", artistID).Msg("failed to cache artist albums")
	} else {
		log.Debug().Str("artist_id", artistID).Int("count", len(albums)).Msg("artist albums cached")
	}

	return albums, nil
}

func (s *MetadataService) ensureArtistsCached(ctx context.Context, albums []domain.Album) {
	log := zerolog.Ctx(ctx)
	seen := make(map[string]bool)

	for _, album := range albums {
		for _, ac := range album.Artists {
			id := ac.Artist.ID
			if id == "" || seen[id] {
				continue
			}
			seen[id] = true

			_, err := s.artists.GetByID(ctx, id)
			if err == nil {
				continue
			}

			if _, err := s.GetArtist(ctx, id); err != nil {
				log.Warn().Err(err).Str("artist_id", id).Msg("failed to fetch and cache artist from album credit")
			}
		}
	}
}

func (s *MetadataService) GetTrack(ctx context.Context, id string) (*domain.Track, error) {
	log := zerolog.Ctx(ctx)

	track, err := s.tracks.GetByExternalID(ctx, s.provider.Name(), id)
	if err == nil {
		log.Debug().Str("track_id", id).Msg("track cache hit")
		metrics.CacheHits.WithLabelValues("track").Inc()
		return track, nil
	}
	if !errors.Is(err, repository.ErrNotFound) {
		log.Error().Err(err).Str("track_id", id).Msg("track cache lookup failed")
		return nil, err
	}

	metrics.CacheMisses.WithLabelValues("track").Inc()
	log.Debug().Str("track_id", id).Str("provider", s.provider.Name()).Msg("track cache miss, fetching from provider")

	track, err = s.provider.GetTrack(ctx, id)
	if err != nil {
		log.Debug().Err(err).Str("track_id", id).Msg("provider fetch failed")
		return nil, err
	}

	if saveErr := s.tracks.Save(ctx, track); saveErr != nil {
		log.Warn().Err(saveErr).Str("track_id", id).Msg("failed to cache track")
		return track, nil
	}

	log.Trace().Str("track_id", id).Msg("track cached successfully")
	return track, nil
}

func (s *MetadataService) GetTrackByISRC(ctx context.Context, isrc string) (*domain.Track, error) {
	log := zerolog.Ctx(ctx)

	track, err := s.tracks.GetByISRC(ctx, isrc)
	if err == nil {
		log.Debug().Str("isrc", isrc).Msg("track ISRC cache hit")
		metrics.CacheHits.WithLabelValues("track_isrc").Inc()
		return track, nil
	}
	if !errors.Is(err, repository.ErrNotFound) {
		log.Error().Err(err).Str("isrc", isrc).Msg("track ISRC cache lookup failed")
		return nil, err
	}

	metrics.CacheMisses.WithLabelValues("track_isrc").Inc()
	log.Debug().Str("isrc", isrc).Str("provider", s.provider.Name()).Msg("track ISRC cache miss, fetching from provider")

	track, err = s.provider.GetTrackByISRC(ctx, isrc)
	if err != nil {
		log.Debug().Err(err).Str("isrc", isrc).Msg("provider ISRC fetch failed")
		return nil, err
	}

	if saveErr := s.tracks.Save(ctx, track); saveErr != nil {
		log.Warn().Err(saveErr).Str("isrc", isrc).Msg("failed to cache track")
		return track, nil
	}

	log.Trace().Str("isrc", isrc).Msg("track cached successfully")
	return track, nil
}

func (s *MetadataService) GetAlbumTracks(ctx context.Context, albumID string) ([]domain.Track, error) {
	log := zerolog.Ctx(ctx)

	tracks, err := s.tracks.GetByAlbumID(ctx, albumID)
	if err == nil && len(tracks) > 0 {
		log.Debug().Str("album_id", albumID).Int("count", len(tracks)).Msg("album tracks served from cache")
		metrics.CacheHits.WithLabelValues("album_tracks").Inc()
		return tracks, nil
	}

	metrics.CacheMisses.WithLabelValues("album_tracks").Inc()
	log.Debug().Str("album_id", albumID).Str("provider", s.provider.Name()).Msg("album tracks cache miss, querying provider")
	return s.provider.GetAlbumTracks(ctx, albumID)
}