package engine

import (
	"math/rand"
	"time"

	"github.com/deluan/gosonic/domain"
	"github.com/deluan/gosonic/utils"
)

// TODO Use Entries instead of Albums
type ListGenerator interface {
	GetNewest(offset int, size int) (*domain.Albums, error)
	GetRecent(offset int, size int) (*domain.Albums, error)
	GetFrequent(offset int, size int) (*domain.Albums, error)
	GetHighest(offset int, size int) (*domain.Albums, error)
	GetRandom(offset int, size int) (*domain.Albums, error)
	GetStarred() (*Entries, error)
	GetNowPlaying() (*Entries, error)
}

func NewListGenerator(alr domain.AlbumRepository, mfr domain.MediaFileRepository, npr NowPlayingRepository) ListGenerator {
	return listGenerator{alr, mfr, npr}
}

type listGenerator struct {
	albumRepo    domain.AlbumRepository
	mfRepository domain.MediaFileRepository
	npRepo       NowPlayingRepository
}

func (g listGenerator) query(qo domain.QueryOptions, offset int, size int) (*domain.Albums, error) {
	qo.Offset = offset
	qo.Size = size
	return g.albumRepo.GetAll(qo)
}

func (g listGenerator) GetNewest(offset int, size int) (*domain.Albums, error) {
	qo := domain.QueryOptions{SortBy: "CreatedAt", Desc: true, Alpha: true}
	return g.query(qo, offset, size)
}

func (g listGenerator) GetRecent(offset int, size int) (*domain.Albums, error) {
	qo := domain.QueryOptions{SortBy: "PlayDate", Desc: true, Alpha: true}
	return g.query(qo, offset, size)
}

func (g listGenerator) GetFrequent(offset int, size int) (*domain.Albums, error) {
	qo := domain.QueryOptions{SortBy: "PlayCount", Desc: true}
	return g.query(qo, offset, size)
}

func (g listGenerator) GetHighest(offset int, size int) (*domain.Albums, error) {
	qo := domain.QueryOptions{SortBy: "Rating", Desc: true}
	return g.query(qo, offset, size)
}

func (g listGenerator) GetRandom(offset int, size int) (*domain.Albums, error) {
	ids, err := g.albumRepo.GetAllIds()
	if err != nil {
		return nil, err
	}
	size = utils.MinInt(size, len(*ids))
	perm := rand.Perm(size)
	r := make(domain.Albums, size)

	for i := 0; i < size; i++ {
		v := perm[i]
		al, err := g.albumRepo.Get((*ids)[v])
		if err != nil {
			return nil, err
		}
		r[i] = *al
	}
	return &r, nil
}

func (g listGenerator) GetStarred() (*Entries, error) {
	albums, err := g.albumRepo.GetStarred(domain.QueryOptions{})
	if err != nil {
		return nil, err
	}
	entries := make(Entries, len(*albums))

	for i, al := range *albums {
		entries[i] = FromAlbum(&al)
	}

	return &entries, nil
}

func (g listGenerator) GetNowPlaying() (*Entries, error) {
	npInfo, err := g.npRepo.GetAll()
	if err != nil {
		return nil, err
	}
	entries := make(Entries, len(*npInfo))
	for i, np := range *npInfo {
		mf, err := g.mfRepository.Get(np.TrackId)
		if err != nil {
			return nil, err
		}
		entries[i] = FromMediaFile(mf)
		entries[i].UserName = np.Username
		entries[i].MinutesAgo = int(time.Now().Sub(np.Start).Minutes())
		entries[i].PlayerId = np.PlayerId
		entries[i].PlayerName = np.PlayerName

	}
	return &entries, nil
}