Moved scrobblerlog parsing to separate package

pkg/scrobblerlog/parser.go

@@ -0,0 +1,256 @@
+/*
+Copyright © 2023-2025 Philipp Wolfer <phw@uploadedlobster.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+// Package to parse and writer .scrobbler.log files as written by Rockbox.
+//
+// See
+// - https://www.rockbox.org/wiki/LastFMLog
+// - https://git.rockbox.org/cgit/rockbox.git/tree/apps/plugins/lastfm_scrobbler.c
+package scrobblerlog
+
+import (
+	"bufio"
+	"encoding/csv"
+	"fmt"
+	"io"
+	"strconv"
+	"strings"
+	"time"
+
+	"go.uploadedlobster.com/mbtypes"
+	"go.uploadedlobster.com/scotty/internal/models"
+)
+
+// TZInfo is the timezone information in the header of the scrobbler log file.
+// It can be "UTC" or "UNKNOWN", if the device writing the scrobbler log file
+// knows the time, but not the timezone.
+type TZInfo string
+
+const (
+	TZ_UNKNOWN TZInfo = "UNKNOWN"
+	TZ_UTC     TZInfo = "UTC"
+)
+
+// Represents a scrobbler log file.
+type ScrobblerLog struct {
+	TZ       TZInfo
+	Client   string
+	Listens  models.ListensList
+	location *time.Location
+}
+
+func (l *ScrobblerLog) Parse(data io.Reader, includeSkipped bool) error {
+	l.Listens = make(models.ListensList, 0)
+
+	reader := bufio.NewReader(data)
+	err := l.ReadHeader(reader)
+	if err != nil {
+		return err
+	}
+
+	tsvReader := csv.NewReader(reader)
+	tsvReader.Comma = '\t'
+	// Row length is often flexible
+	tsvReader.FieldsPerRecord = -1
+
+	for {
+		// A row is:
+		// artistName	releaseName	trackName	trackNumber	duration	rating	timestamp	recordingMBID
+		row, err := tsvReader.Read()
+		if err == io.EOF {
+			break
+		} else if err != nil {
+			return err
+		}
+
+		// fmt.Printf("row: %v\n", row)
+
+		// We consider only the last field (recording MBID) optional
+		if len(row) < 7 {
+			line, _ := tsvReader.FieldPos(0)
+			return fmt.Errorf("invalid record in scrobblerlog line %v", line)
+		}
+
+		rating := row[5]
+		if !includeSkipped && rating == "S" {
+			continue
+		}
+
+		listen, err := l.rowToListen(row)
+		if err != nil {
+			return err
+		}
+
+		l.Listens = append(l.Listens, listen)
+	}
+
+	return nil
+}
+
+func (l *ScrobblerLog) Append(data io.Writer, listens models.ListensList) (lastTimestamp time.Time, err error) {
+	tsvWriter := csv.NewWriter(data)
+	tsvWriter.Comma = '\t'
+
+	for _, listen := range listens {
+		if listen.ListenedAt.Unix() > lastTimestamp.Unix() {
+			lastTimestamp = listen.ListenedAt
+		}
+
+		// A row is:
+		// artistName	releaseName	trackName	trackNumber	duration	rating	timestamp	recordingMBID
+		rating, ok := listen.AdditionalInfo["rockbox_rating"].(string)
+		if !ok || rating == "" {
+			rating = "L"
+		}
+		err = tsvWriter.Write([]string{
+			listen.ArtistName(),
+			listen.ReleaseName,
+			listen.TrackName,
+			strconv.Itoa(listen.TrackNumber),
+			strconv.Itoa(int(listen.Duration.Seconds())),
+			rating,
+			strconv.Itoa(int(listen.ListenedAt.Unix())),
+			string(listen.RecordingMBID),
+		})
+	}
+
+	tsvWriter.Flush()
+	return
+}
+
+func (l *ScrobblerLog) ReadHeader(reader *bufio.Reader) error {
+	// Skip header
+	for i := 0; i < 3; i++ {
+		line, _, err := reader.ReadLine()
+		if err != nil {
+			return err
+		}
+
+		if len(line) == 0 || line[0] != '#' {
+			err = fmt.Errorf("unexpected header (line %v)", i)
+		} else {
+			text := string(line)
+			if i == 0 && !strings.HasPrefix(text, "#AUDIOSCROBBLER/1") {
+				err = fmt.Errorf("not a scrobbler log file")
+			}
+
+			// The timezone can be set to "UTC" or "UNKNOWN", if the device writing
+			// the log knows the time, but not the timezone.
+			timezone, found := strings.CutPrefix(text, "#TZ/")
+			if found {
+				l.TZ = TZInfo(timezone)
+				l.location = locationFromTimezone(l.TZ)
+				continue
+			}
+
+			client, found := strings.CutPrefix(text, "#CLIENT/")
+			if found {
+				l.Client = client
+				continue
+			}
+		}
+
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (l *ScrobblerLog) WriteHeader(writer io.Writer) error {
+	headers := []string{
+		"#AUDIOSCROBBLER/1.1\n",
+		"#TZ/" + string(l.TZ) + "\n",
+		"#CLIENT/" + l.Client + "\n",
+	}
+	for _, line := range headers {
+		_, err := writer.Write([]byte(line))
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (l ScrobblerLog) rowToListen(row []string) (models.Listen, error) {
+	var listen models.Listen
+	trackNumber, err := strconv.Atoi(row[3])
+	if err != nil {
+		return listen, err
+	}
+
+	duration, err := strconv.Atoi(row[4])
+	if err != nil {
+		return listen, err
+	}
+
+	timestamp, err := strconv.ParseInt(row[6], 10, 64)
+	if err != nil {
+		return listen, err
+	}
+
+	client := strings.Split(l.Client, " ")[0]
+	listen = models.Listen{
+		Track: models.Track{
+			ArtistNames: []string{row[0]},
+			ReleaseName: row[1],
+			TrackName:   row[2],
+			TrackNumber: trackNumber,
+			Duration:    time.Duration(duration * int(time.Second)),
+			AdditionalInfo: models.AdditionalInfo{
+				"rockbox_rating": row[5],
+				"media_player":   client,
+			},
+		},
+		ListenedAt: timeFromLocalTimestamp(timestamp, l.location),
+	}
+
+	if len(row) > 7 {
+		listen.Track.RecordingMBID = mbtypes.MBID(row[7])
+	}
+
+	return listen, nil
+}
+
+// Convert the timezone string from the header to a time.Location.
+// Often this is set to "UNKNOWN" in the log file, in which case it defaults
+// to UTC.
+func locationFromTimezone(timezone TZInfo) *time.Location {
+	location, err := time.LoadLocation(string(timezone))
+	if err != nil {
+		return time.UTC
+	}
+	return location
+}
+
+// Convert a Unix timestamp to a time.Time object, but treat the timestamp
+// as being in the given location's timezone instead of UTC.
+func timeFromLocalTimestamp(timestamp int64, location *time.Location) time.Time {
+	t := time.Unix(timestamp, 0)
+
+	// The time is now in UTC. Get the offset to the requested timezone.
+	_, offset := t.In(location).Zone()
+	if offset != 0 {
+		t = t.Add(time.Duration(offset) * time.Second)
+	}
+	return t
+}