scotty/backends/listenbrainz/listenbrainz.go

/*
Copyright © 2023 Philipp Wolfer <phw@uploadedlobster.com>

This file is part of Scotty.

Scotty is free software: you can redistribute it and/or modify it under the
terms of the GNU General Public License as published by the Free Software
Foundation, either version 3 of the License, or (at your option) any later version.

Scotty is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with
Scotty. If not, see <https://www.gnu.org/licenses/>.
*/
package listenbrainz

import (
	"fmt"
	"sort"
	"time"

	"github.com/spf13/viper"
	"go.uploadedlobster.com/scotty/models"
)

type ListenBrainzApiBackend struct {
	client        Client
	username      string
	existingMbids map[string]bool
}

func (b *ListenBrainzApiBackend) Name() string { return "listenbrainz" }

func (b *ListenBrainzApiBackend) FromConfig(config *viper.Viper) models.Backend {
	b.client = NewClient(config.GetString("token"))
	b.client.MaxResults = MaxItemsPerGet
	b.username = config.GetString("username")
	return b
}

func (b *ListenBrainzApiBackend) StartImport() error  { return nil }
func (b *ListenBrainzApiBackend) FinishImport() error { return nil }

func (b *ListenBrainzApiBackend) ExportListens(oldestTimestamp time.Time, results chan models.ListensResult, progress chan models.Progress) {
	startTime := time.Now()
	maxTime := startTime
	minTime := time.Unix(0, 0)

	totalDuration := startTime.Sub(oldestTimestamp)

	defer close(results)
	defer close(progress)

	// FIXME: Optimize by fetching the listens in reverse listen time order
	listens := make(models.ListensList, 0, 2*MaxItemsPerGet)
	p := models.Progress{Total: int64(totalDuration.Seconds())}

out:
	for {
		result, err := b.client.GetListens(b.username, maxTime, minTime)
		if err != nil {
			progress <- p.Complete()
			results <- models.ListensResult{Error: err}
			return
		}

		count := len(result.Payload.Listens)
		if count == 0 {
			break
		}

		// Set maxTime to the oldest returned listen
		maxTime = time.Unix(result.Payload.Listens[count-1].ListenedAt, 0)
		remainingTime := maxTime.Sub(oldestTimestamp)

		for _, listen := range result.Payload.Listens {
			if listen.ListenedAt > oldestTimestamp.Unix() {
				listens = append(listens, listen.ToListen())
			} else {
				// result contains listens older then oldestTimestamp,
				// we can stop requesting more
				p.Total = int64(startTime.Sub(time.Unix(listen.ListenedAt, 0)).Seconds())
				break out
			}
		}

		p.Elapsed = int64(totalDuration.Seconds() - remainingTime.Seconds())
		progress <- p
	}

	sort.Sort(listens)
	progress <- p.Complete()
	results <- models.ListensResult{Listens: listens, OldestTimestamp: oldestTimestamp}
}

func (b *ListenBrainzApiBackend) ExportLoves(oldestTimestamp time.Time, results chan models.LovesResult, progress chan models.Progress) {
	offset := 0
	defer close(results)
	defer close(progress)
	loves := make(models.LovesList, 0, 2*MaxItemsPerGet)
	p := models.Progress{}

out:
	for {
		result, err := b.client.GetFeedback(b.username, 1, offset)
		if err != nil {
			results <- models.LovesResult{Error: err}
			return
		}

		count := len(result.Feedback)
		if count == 0 {
			break out
		}

		for _, feedback := range result.Feedback {
			love := feedback.ToLove()
			if love.Created.Unix() > oldestTimestamp.Unix() {
				loves = append(loves, love)
				p.Elapsed += 1
				progress <- p
			} else {
				break out
			}
		}

		p.Total = int64(result.TotalCount)
		p.Elapsed += int64(count)

		offset += MaxItemsPerGet
	}

	sort.Sort(loves)
	progress <- p.Complete()
	results <- models.LovesResult{Loves: loves}
}

func (b *ListenBrainzApiBackend) ImportLoves(export models.LovesResult, importResult models.ImportResult, progress chan models.Progress) (models.ImportResult, error) {
	if len(b.existingMbids) == 0 {
		existingLovesChan := make(chan models.LovesResult)
		go b.ExportLoves(time.Unix(0, 0), existingLovesChan, progress)
		existingLoves := <-existingLovesChan
		if existingLoves.Error != nil {
			return importResult, existingLoves.Error
		}

		// TODO: Store MBIDs directly
		b.existingMbids = make(map[string]bool, len(existingLoves.Loves))
		for _, love := range existingLoves.Loves {
			b.existingMbids[string(love.RecordingMbid)] = true
		}
	}

	for _, love := range export.Loves {
		recordingMbid := string(love.RecordingMbid)

		if recordingMbid == "" {
			lookup, err := b.client.Lookup(love.TrackName, love.ArtistName())
			if err == nil {
				recordingMbid = lookup.RecordingMbid
			}
		}

		if recordingMbid != "" {
			ok := false
			errMsg := ""
			if b.existingMbids[recordingMbid] {
				ok = true
			} else {
				resp, err := b.client.SendFeedback(Feedback{
					RecordingMbid: recordingMbid,
					Score:         1,
				})
				ok = err == nil && resp.Status == "ok"
				if err != nil {
					errMsg = err.Error()
				}
			}

			if ok {
				importResult.UpdateTimestamp(love.Created)
				importResult.ImportCount += 1
			} else {
				msg := fmt.Sprintf("Failed import of \"%s\" by %s: %v",
					love.TrackName, love.ArtistName(), errMsg)
				importResult.ImportErrors = append(importResult.ImportErrors, msg)
			}
		}

		progress <- models.Progress{}.FromImportResult(importResult)
	}

	return importResult, nil
}

func (lbListen Listen) ToListen() models.Listen {
	track := lbListen.TrackMetadata
	listen := models.Listen{
		ListenedAt: time.Unix(lbListen.ListenedAt, 0),
		UserName:   lbListen.UserName,
		Track: models.Track{
			TrackName:        track.TrackName,
			ReleaseName:      track.ReleaseName,
			ArtistNames:      []string{track.ArtistName},
			Duration:         track.Duration(),
			TrackNumber:      track.TrackNumber(),
			RecordingMbid:    models.MBID(track.RecordingMbid()),
			ReleaseMbid:      models.MBID(track.ReleaseMbid()),
			ReleaseGroupMbid: models.MBID(track.ReleaseGroupMbid()),
			Isrc:             track.Isrc(),
			AdditionalInfo:   track.AdditionalInfo,
		},
	}
	return listen
}

func (f Feedback) ToLove() models.Love {
	track := f.TrackMetadata
	recordingMbid := models.MBID(f.RecordingMbid)
	love := models.Love{
		UserName:      f.UserName,
		RecordingMbid: recordingMbid,
		Created:       time.Unix(f.Created, 0),
		Track: models.Track{
			RecordingMbid: recordingMbid,
		},
	}

	if track != nil {
		love.Track.TrackName = track.TrackName
		love.Track.ReleaseName = track.ReleaseName
		love.ArtistNames = []string{track.ArtistName}
		love.ReleaseMbid = models.MBID(track.MbidMapping.ReleaseMbid)
		love.ArtistMbids = make([]models.MBID, 0, len(track.MbidMapping.ArtistMbids))

		if track.MbidMapping != nil {
			for _, artistMbid := range track.MbidMapping.ArtistMbids {
				love.Track.ArtistMbids = append(love.Track.ArtistMbids, models.MBID(artistMbid))
			}
		}
	}

	return love
}