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

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 lastfm

import (
	"fmt"
	"net/url"
	"sort"
	"strconv"
	"time"

	"github.com/shkh/lastfm-go/lastfm"
	"github.com/spf13/viper"
	"go.uploadedlobster.com/scotty/internal/auth"
	"go.uploadedlobster.com/scotty/internal/models"
	"golang.org/x/oauth2"
)

const MaxItemsPerGet = 50

type LastfmApiBackend struct {
	client   *lastfm.Api
	username string
}

func (b *LastfmApiBackend) Name() string { return "lastfm" }

func (b *LastfmApiBackend) FromConfig(config *viper.Viper) models.Backend {
	clientId := config.GetString("client-id")
	clientSecret := config.GetString("client-secret")
	b.client = lastfm.New(clientId, clientSecret)
	b.username = config.GetString("username")
	return b
}

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

func (b *LastfmApiBackend) OAuth2Strategy(redirectUrl *url.URL) auth.OAuth2Strategy {
	return lastfmStrategy{
		client:      b.client,
		redirectUrl: redirectUrl,
	}
}

func (b *LastfmApiBackend) OAuth2Setup(token oauth2.TokenSource) error {
	t, err := token.Token()
	if err != nil {
		return err
	}
	b.client.SetSession(t.AccessToken)
	return nil
}

func (b *LastfmApiBackend) ExportLoves(oldestTimestamp time.Time, results chan models.LovesResult, progress chan models.Progress) {
	// Choose a high offset, we attempt to search the loves backwards starting
	// at the oldest one.
	page := 1
	perPage := MaxItemsPerGet

	defer close(results)

	loves := make(models.LovesList, 0, 2*MaxItemsPerGet)
	p := models.Progress{Total: int64(perPage)}
	var totalCount int

out:
	for {
		result, err := b.client.User.GetLovedTracks(lastfm.P{
			"user":  b.username,
			"limit": MaxItemsPerGet,
			"page":  page,
		})
		if err != nil {
			progress <- p.Complete()
			results <- models.LovesResult{Error: err}
			return
		}

		p.Total = int64(result.Total)
		count := len(result.Tracks)
		if count == 0 {
			break out
		}

		for _, track := range result.Tracks {
			timestamp, err := strconv.ParseInt(track.Date.Uts, 10, 64)
			if err != nil {
				progress <- p.Complete()
				results <- models.LovesResult{Error: err}
				return
			}
			if timestamp > oldestTimestamp.Unix() {
				totalCount += 1
				love := models.Love{
					Created:       time.Unix(timestamp, 0),
					UserName:      result.User,
					RecordingMbid: models.MBID(track.Mbid),
					Track: models.Track{
						TrackName:     track.Name,
						ArtistNames:   []string{track.Artist.Name},
						RecordingMbid: models.MBID(track.Mbid),
						ArtistMbids:   []models.MBID{models.MBID(track.Artist.Mbid)},
						AdditionalInfo: models.AdditionalInfo{
							"lastfm_url": track.Url,
						},
					},
				}
				loves = append(loves, love)
			} else {
				break out
			}
		}

		p.Elapsed += int64(count)
		progress <- p

		page += 1
	}

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

func (b *LastfmApiBackend) ImportLoves(export models.LovesResult, importResult models.ImportResult, progress chan models.Progress) (models.ImportResult, error) {
	for _, love := range export.Loves {
		err := b.client.Track.Love(lastfm.P{
			"track":  love.TrackName,
			"artist": love.ArtistName(),
		})

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

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

	return importResult, nil
}