package client

import (
	"context"
	"fmt"

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

// GetRadioStations gets radio stations
func (c *Client) GetRadioStations(ctx context.Context) ([]*models.RadioStation, error) {
	var result []models.RadioStation
	if err := c.request.Get(ctx, "/radio/stations", nil, &result); err != nil {
		return nil, err
	}

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

// GetRadioStation gets a radio station by ID
// GET /rotor/station/{stationID}/info
func (c *Client) GetRadioStation(ctx context.Context, stationID string) (*models.RadioStation, error) {
	var result models.RadioStation
	if err := c.request.Get(ctx, fmt.Sprintf("/rotor/station/%s/info", stationID), nil, &result); err != nil {
		return nil, err
	}
	result.SetClient(c)
	return &result, nil
}

// GetStationTracks gets tracks for a radio station
// GET /rotor/station/{stationID}/tracks
func (c *Client) GetStationTracks(ctx context.Context, stationID string, limit int) (*models.StationTracksResult, error) {
	params := map[string]string{}
	if limit > 0 {
		params["limit"] = fmt.Sprintf("%d", limit)
	}

	var result models.StationTracksResult
	if err := c.request.Get(ctx, fmt.Sprintf("/rotor/station/%s/tracks", stationID), params, &result); err != nil {
		return nil, err
	}
	return &result, nil
}

// GetRotorStations gets rotor stations (generative)
func (c *Client) GetRotorStations(ctx context.Context) ([]*models.RotorStation, error) {
	var result []models.RotorStation
	if err := c.request.Get(ctx, "/rotor/stations", nil, &result); err != nil {
		return nil, err
	}

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

// GetRotorStation gets a rotor station by ID
// GET /rotor/station/{stationID}/info
func (c *Client) GetRotorStation(ctx context.Context, stationID string) (*models.RotorStation, error) {
	var result models.RotorStation
	if err := c.request.Get(ctx, fmt.Sprintf("/rotor/station/%s/info", stationID), nil, &result); err != nil {
		return nil, err
	}
	result.SetClient(c)
	return &result, nil
}

// GetRotorStationTracks gets tracks for a rotor station
// GET /rotor/station/{stationID}/tracks
func (c *Client) GetRotorStationTracks(ctx context.Context, stationID string, limit int) (*models.RotorStationTracksResult, error) {
	params := map[string]string{}
	if limit > 0 {
		params["limit"] = fmt.Sprintf("%d", limit)
	}

	var result models.RotorStationTracksResult
	if err := c.request.Get(ctx, fmt.Sprintf("/rotor/station/%s/tracks", stationID), params, &result); err != nil {
		return nil, err
	}
	return &result, nil
}

// StartRotorSession starts a rotor session
// POST /rotor/station/{stationID}/session/start
func (c *Client) StartRotorSession(ctx context.Context, stationID string) (*models.RotorSession, error) {
	var result models.RotorSession
	if err := c.request.Post(ctx, fmt.Sprintf("/rotor/station/%s/session/start", stationID), nil, &result); err != nil {
		return nil, err
	}
	result.SetClient(c)
	return &result, nil
}

// GetRotorSession gets rotor session info
// GET /rotor/session?session_id={sessionID}
func (c *Client) GetRotorSession(ctx context.Context, sessionID string) (*models.RotorSession, error) {
	params := map[string]string{
		"session_id": sessionID,
	}

	var result models.RotorSession
	if err := c.request.Get(ctx, "/rotor/session", params, &result); err != nil {
		return nil, err
	}
	result.SetClient(c)
	return &result, nil
}

// RotorSessionFeedback sends feedback for a rotor session track
// POST /rotor/station/{stationID}/feedback
func (c *Client) RotorSessionFeedback(ctx context.Context, sessionID, trackID, feedbackType string) error {
	params := map[string]string{
		"track_id": trackID,
		"feedback": feedbackType, // "like", "dislike", "skip"
	}

	var result map[string]any
	return c.request.Post(ctx, fmt.Sprintf("/rotor/station/%s/feedback", sessionID), params, &result)
}