package rudder

import (
	"context"
	"net/http"
	"net/url"
	"strconv"

	"hub.rudder.build/rudder/rudder-go-sdk/models"
)

type PlayersService struct {
	transport *transport
}

type ListPlayersParameters struct {
	Limit  int
	Offset int
	Search string
}

func (s *PlayersService) List(ctx context.Context, parameters ListPlayersParameters) (*PlayerList, error) {
	query := url.Values{}
	if parameters.Limit > 0 {
		query.Set("limit", strconv.Itoa(parameters.Limit))
	}
	if parameters.Offset > 0 {
		query.Set("offset", strconv.Itoa(parameters.Offset))
	}
	if parameters.Search != "" {
		query.Set("search", parameters.Search)
	}

	var response PlayerList
	if err := s.transport.do(ctx, http.MethodGet, "/players/list", query, nil, &response); err != nil {
		return nil, err
	}
	return &response, nil
}

func (s *PlayersService) Get(ctx context.Context, playerID string) (*PlayerDetails, error) {
	var response PlayerDetails
	if err := s.transport.do(ctx, http.MethodGet, "/players/"+url.PathEscape(playerID), nil, nil, &response); err != nil {
		return nil, err
	}
	return &response, nil
}

func (s *PlayersService) VerifyAuth(ctx context.Context, accessToken string) (*PlayerAuthVerification, error) {
	body := models.VerifyPlayerAuthRequest{AccessToken: accessToken}

	var response PlayerAuthVerification
	if err := s.transport.do(ctx, http.MethodPost, "/players/auth/verify", nil, body, &response); err != nil {
		return nil, err
	}
	return &response, nil
}

type UpdatePlayersParameters struct {
	IdempotencyKey string
	Items          []PlayerUpdate
}

func (s *PlayersService) Update(ctx context.Context, parameters UpdatePlayersParameters) ([]Player, error) {
	body := models.BatchUpdatePlayersRequest{
		IdempotencyKey: parameters.IdempotencyKey,
		Items:          parameters.Items,
	}

	var response models.BatchPlayersResponse
	if err := s.transport.do(ctx, http.MethodPatch, "/players", nil, body, &response); err != nil {
		return nil, err
	}
	return response.Players, nil
}

type BanPlayersParameters struct {
	IdempotencyKey string
	Items          []PlayerBan
}

func (s *PlayersService) Ban(ctx context.Context, parameters BanPlayersParameters) ([]Player, error) {
	body := models.BatchBanPlayersRequest{
		IdempotencyKey: parameters.IdempotencyKey,
		Items:          parameters.Items,
	}

	var response models.BatchPlayersResponse
	if err := s.transport.do(ctx, http.MethodPost, "/players/ban", nil, body, &response); err != nil {
		return nil, err
	}
	return response.Players, nil
}

type UnbanPlayersParameters struct {
	IdempotencyKey string
	PlayerIDs      []string
}

func (s *PlayersService) Unban(ctx context.Context, parameters UnbanPlayersParameters) ([]Player, error) {
	body := models.BatchUnbanPlayersRequest{
		IdempotencyKey: parameters.IdempotencyKey,
		Items:          batchPlayerItems(parameters.PlayerIDs),
	}

	var response models.BatchPlayersResponse
	if err := s.transport.do(ctx, http.MethodPost, "/players/unban", nil, body, &response); err != nil {
		return nil, err
	}
	return response.Players, nil
}

type DeletePlayersParameters struct {
	IdempotencyKey string
	PlayerIDs      []string
}

func (s *PlayersService) Delete(ctx context.Context, parameters DeletePlayersParameters) error {
	body := models.BatchDeletePlayersRequest{
		IdempotencyKey: parameters.IdempotencyKey,
		Items:          batchPlayerItems(parameters.PlayerIDs),
	}
	return s.transport.do(ctx, http.MethodDelete, "/players", nil, body, nil)
}

func batchPlayerItems(playerIDs []string) []models.BatchPlayerItem {
	items := make([]models.BatchPlayerItem, len(playerIDs))
	for i, id := range playerIDs {
		items[i] = models.BatchPlayerItem{PlayerID: id}
	}
	return items
}