NemAn/SpotifyService/Services/TrackService.cs

using Google.Rpc;
using Grpc.Core;
using GrpcShared;
using GrpcShared.DTO;
using GrpcShared.DTO.Search;
using GrpcShared.DTO.Track;
using GrpcShared.DTO.Track.MultipleTrack;
using GrpcShared.DTO.Track.SaveTracks;
using GrpcShared.DTO.Track.SingleTrack;
using GrpcShared.DTO.TrackByID;
using GrpcShared.Interfaces;
using Microsoft.AspNetCore.Authorization;
using Microsoft.Net.Http.Headers;
using NemAnBlazor.Services;
using Newtonsoft.Json;
using System.Text;
using System.Text.Json;
using System.Web;
using static GrpcShared.DTO.Search.SearchDetails;

namespace SpotifyService.Services
{
    public class TrackService : ITrackService
    {
        private readonly IHttpClientFactory _httpClientFactory;
        private IIdentityService _identityService;
        private IAuthService _authService;

        public TrackService(IHttpClientFactory httpClientFactory, IIdentityService identityService, IAuthService authService)
        {
            _httpClientFactory = httpClientFactory;
            _identityService = identityService;
            _authService = authService;
        }
        public async Task<SearchResponse> ListSearchAsync(SearchRequest request)
        {

            string url = $"search?q={request.Query}&type={request.Type}";

            var response = await HttpUtils.HttpUtils<SearchResponse>
                                  .GetData(_httpClientFactory,
                                           url,
                                           request.UserId!,
                                           _identityService,
                                           _authService);

            //ovo je ako hocemo da dodamo da se prikazuje dal je sacuvana pesma od onih koje se pretrazuju,
            //al ce potencijalno da prepuni requests ako ne optimizujemo  pretragu

            //if (response != null)
            //{
            //    List<string> ids = response.Tracks!.Items!.Select(x => x.Id!).ToList();
            //    var param = new Dictionary<string, List<string>>();
            //    param["ids"] = ids;
            //    var query = UriUtil(param);

            //    string savedUrl = $"tracks/contains{query}";
            //    var isSavedResponse = await HttpUtils.HttpUtils<IsSavedResponse>
            //                                .GetData(_httpClientFactory,
            //                               savedUrl,
            //                               request.UserId!,
            //                               _identityService,
            //                               _authService);

            //    for (int i = 0; i < response.Tracks.Items.Count; i++)
            //    {
            //        response.Tracks.Items[i].IsSaved = isSavedResponse.AreSaved[i];
            //    }

            //}
            return response;
        }



        public async Task<SingleTrackResponse> ListSingleTrackAsync(SingleTrackRequest request)
        {
            string url = $"audio-features/{request.Id}";

            var response = await HttpUtils.HttpUtils<SingleTrackResponse>
                                  .GetData(_httpClientFactory,
                                           url,
                                           request.UserId!,
                                           _identityService,
                                           _authService);
            string savedUrl = $"tracks/contains?ids={request.Id}";
            var savedResponse = await HttpUtils.HttpUtils <List<bool>>
                                  .GetData(_httpClientFactory,
                                           savedUrl,
                                           request.UserId!,
                                           _identityService,
                                           _authService);
            response.IsSaved = savedResponse[0];

            return response;
        }
        public async Task<MultipleTrackResponse> ListMultipleTrackAsync(MultipleTrackRequest request)
        {

            var param = new Dictionary<string, List<string>>();
            param["ids"] = request.Ids!;

            var query = UriUtil(param);
            string url = $"audio-features{query}";

            return await HttpUtils.HttpUtils<MultipleTrackResponse>
                                  .GetData(_httpClientFactory,
                                            url,
                                            request.UserId!,
                                            _identityService,
                                            _authService);
        }
        public async Task SaveTracks(SaveTracksRequest request)
        {
            var client = _httpClientFactory.CreateClient("HttpClient");

            var param = new Dictionary<string, List<string>>();
            param["ids"] = request.Ids!;

            var query = UriUtil(param);
            string url = $"me/tracks/{query}";

            //the response type has nothing to do with the method, it's there so that the method can be called
            await HttpUtils.HttpUtils<StatusCodeMessage>
                           .PutData(client,
                                    url,
                                    request.UserId!,
                                    _identityService,
                                    _authService);

        }
        public static string UriUtil(Dictionary<string, List<string>> param)
        {
            bool startingQuestionMarkAdded = false;
            var sb = new StringBuilder();

            foreach (var id in param)
            {
                sb.Append(startingQuestionMarkAdded ? '&' : '?');
                sb.Append(id.Key);
                sb.Append('=');

                foreach (var Xid in id.Value)
                {
                    sb.Append(Xid);
                    sb.Append("%2C");
                    startingQuestionMarkAdded = true;
                }
            }
            sb.Length = sb.Length - 3;
            return sb.ToString();
        }
        public async Task<TrackResponse> GetById(TrackRequest request)
        {

            string url = $"tracks/{request.TrackID}";

            return await HttpUtils.HttpUtils<TrackResponse>
                                  .GetData(_httpClientFactory,
                                           url,
                                           request.UserId!,
                                           _identityService,
                                           _authService);
        }
    }
}