yandex-music-api-go/internal/client/queue.go

package client

import (
	"context"
	"fmt"

	"gitea.mrixs.me/Mrixs/yandex-music-api-go/internal/models"
)

// GetQueuesList gets the queues list (GET /queues).
func (c *Client) GetQueuesList(ctx context.Context) ([]*models.QueueItem, error) {
	var result []models.QueueItem
	if err := c.request.Get(ctx, "/queues", nil, &result); err != nil {
		return nil, err
	}

	items := make([]*models.QueueItem, len(result))
	for i := range result {
		result[i].SetClient(c)
		items[i] = &result[i]
	}
	return items, nil
}

// GetQueue gets the current queue
func (c *Client) GetQueue(ctx context.Context) (*models.Queue, error) {
	var result models.Queue
	if err := c.request.Get(ctx, "/queues", nil, &result); err != nil {
		return nil, err
	}
	result.SetClient(c)
	return &result, nil
}

// CreateQueue creates a new playback queue (POST /queues).
// The queueType parameter specifies the type of queue (e.g., "radio", "album", "playlist").
func (c *Client) CreateQueue(ctx context.Context, trackID string, queueType string) (*models.Queue, error) {
	params := map[string]string{
		"track_id":   trackID,
		"queue_type": queueType, // "radio", "album", "playlist", etc.
	}

	var result models.Queue
	if err := c.request.Post(ctx, "/queues", params, &result); err != nil {
		return nil, err
	}
	result.SetClient(c)
	return &result, nil
}

// GetQueueItem gets a queue item by queue ID (GET /queues/{queue_id}).
func (c *Client) GetQueueItem(ctx context.Context, queueID string) (*models.QueueItem, error) {
	var result models.QueueItem
	if err := c.request.Get(ctx, fmt.Sprintf("/queues/%s", queueID), nil, &result); err != nil {
		return nil, err
	}
	result.SetClient(c)
	return &result, nil
}

// AddToQueue adds a track to the queue at the given position (POST /queues/{queue_id}/add).
func (c *Client) AddToQueue(ctx context.Context, queueID, trackID string, position int) (*models.Queue, error) {
	params := map[string]string{
		"track_id": trackID,
		"position": fmt.Sprintf("%d", position),
	}

	var result models.Queue
	if err := c.request.Post(ctx, fmt.Sprintf("/queues/%s/add", queueID), params, &result); err != nil {
		return nil, err
	}
	result.SetClient(c)
	return &result, nil
}

// RemoveFromQueue removes a track from the queue (DELETE /queues/{queue_id}/remove).
func (c *Client) RemoveFromQueue(ctx context.Context, queueID, trackID string) (*models.Queue, error) {
	params := map[string]string{
		"track_id": trackID,
	}

	var result models.Queue
	if err := c.request.Delete(ctx, fmt.Sprintf("/queues/%s/remove", queueID), params, &result); err != nil {
		return nil, err
	}
	result.SetClient(c)
	return &result, nil
}

// ReorderQueue reorders items in the queue from one position to another (PUT /queues/{queue_id}/reorder).
func (c *Client) ReorderQueue(ctx context.Context, queueID string, from, to int) (*models.Queue, error) {
	params := map[string]string{
		"from": fmt.Sprintf("%d", from),
		"to":   fmt.Sprintf("%d", to),
	}

	var result models.Queue
	if err := c.request.Put(ctx, fmt.Sprintf("/queues/%s/reorder", queueID), params, &result); err != nil {
		return nil, err
	}
	result.SetClient(c)
	return &result, nil
}

// ClearQueue clears the queue (DELETE /queues/{queue_id}/clear).
func (c *Client) ClearQueue(ctx context.Context, queueID string) error {
	var result map[string]any
	return c.request.Delete(ctx, fmt.Sprintf("/queues/%s/clear", queueID), nil, &result)
}

// NextTrack moves to the next track in the queue (POST /queues/{queue_id}/next).
func (c *Client) NextTrack(ctx context.Context, queueID string) (*models.Queue, error) {
	var result models.Queue
	if err := c.request.Post(ctx, fmt.Sprintf("/queues/%s/next", queueID), nil, &result); err != nil {
		return nil, err
	}
	result.SetClient(c)
	return &result, nil
}

// PreviousTrack moves to the previous track in the queue (POST /queues/{queue_id}/prev).
func (c *Client) PreviousTrack(ctx context.Context, queueID string) (*models.Queue, error) {
	var result models.Queue
	if err := c.request.Post(ctx, fmt.Sprintf("/queues/%s/prev", queueID), nil, &result); err != nil {
		return nil, err
	}
	result.SetClient(c)
	return &result, nil
}

// Seek seeks to a specific position in the current track (POST /queues/{queue_id}/seek).
// The positionMs parameter is the position in milliseconds.
func (c *Client) Seek(ctx context.Context, queueID string, positionMs int) (*models.Queue, error) {
	params := map[string]string{
		"position": fmt.Sprintf("%d", positionMs),
	}

	var result models.Queue
	if err := c.request.Post(ctx, fmt.Sprintf("/queues/%s/seek", queueID), params, &result); err != nil {
		return nil, err
	}
	result.SetClient(c)
	return &result, nil
}

// SetRepeatMode sets the repeat mode for the queue (POST /queues/{queue_id}/repeat).
// The mode parameter can be "off", "one", or "all".
func (c *Client) SetRepeatMode(ctx context.Context, queueID, mode string) (*models.Queue, error) {
	params := map[string]string{
		"mode": mode,
	}

	var result models.Queue
	if err := c.request.Post(ctx, fmt.Sprintf("/queues/%s/repeat", queueID), params, &result); err != nil {
		return nil, err
	}
	result.SetClient(c)
	return &result, nil
}

// SetShuffle enables or disables shuffle for the queue (POST /queues/{queue_id}/shuffle).
func (c *Client) SetShuffle(ctx context.Context, queueID string, enabled bool) (*models.Queue, error) {
	params := map[string]string{
		"enabled": fmt.Sprintf("%t", enabled),
	}

	var result models.Queue
	if err := c.request.Post(ctx, fmt.Sprintf("/queues/%s/shuffle", queueID), params, &result); err != nil {
		return nil, err
	}
	result.SetClient(c)
	return &result, nil
}

// SetVolume sets the volume for the queue (POST /queues/{queue_id}/volume).
// The volume parameter should be between 0 and 100.
func (c *Client) SetVolume(ctx context.Context, queueID string, volume int) (*models.Queue, error) {
	params := map[string]string{
		"volume": fmt.Sprintf("%d", volume),
	}

	var result models.Queue
	if err := c.request.Post(ctx, fmt.Sprintf("/queues/%s/volume", queueID), params, &result); err != nil {
		return nil, err
	}
	result.SetClient(c)
	return &result, nil
}

// GetCurrentTrack gets the currently playing track from the queue (GET /queues/{queue_id}/current).
func (c *Client) GetCurrentTrack(ctx context.Context, queueID string) (*models.QueueItem, error) {
	var result models.QueueItem
	if err := c.request.Get(ctx, fmt.Sprintf("/queues/%s/current", queueID), nil, &result); err != nil {
		return nil, err
	}
	result.SetClient(c)
	return &result, nil
}

// GetQueueHistory gets the queue history (recently played tracks) (GET /queues/{queue_id}/history).
func (c *Client) GetQueueHistory(ctx context.Context, queueID string, limit int) ([]*models.QueueItem, error) {
	params := map[string]string{
		"limit": fmt.Sprintf("%d", limit),
	}

	var result []models.QueueItem
	if err := c.request.Get(ctx, fmt.Sprintf("/queues/%s/history", queueID), params, &result); err != nil {
		return nil, err
	}

	items := make([]*models.QueueItem, len(result))
	for i := range result {
		result[i].SetClient(c)
		items[i] = &result[i]
	}
	return items, nil
}

// GetPlayContexts gets play contexts (GET /play-contexts).
func (c *Client) GetPlayContexts(ctx context.Context) ([]*models.PlayContext, error) {
	var result []models.PlayContext
	if err := c.request.Get(ctx, "/play-contexts", nil, &result); err != nil {
		return nil, err
	}

	contexts := make([]*models.PlayContext, len(result))
	for i := range result {
		result[i].SetClient(c)
		contexts[i] = &result[i]
	}
	return contexts, nil
}

// GetPlayContextsData gets play contexts data (GET /play-contexts/data).
func (c *Client) GetPlayContextsData(ctx context.Context) (*models.PlayContextsData, error) {
	var result models.PlayContextsData
	if err := c.request.Get(ctx, "/play-contexts/data", nil, &result); err != nil {
		return nil, err
	}
	return &result, nil
}