NemAn/gRPCServer/Services/TrackService.cs

using Google.Rpc;
using Grpc.Core;
using GrpcShared;
using GrpcShared.DTO.Search;
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;
        public TrackService(IHttpClientFactory httpClientFactory)
        {
            _httpClientFactory = httpClientFactory;
        }
        public async Task<SearchResponse> ListSearchAsync(SearchRequest request)
        {

            var client = _httpClientFactory.CreateClient("HttpClient");

            client.DefaultRequestHeaders.Add(HeaderNames.Authorization, "Bearer " + request.Token );

            var searchResult = await client.GetAsync($"search?q={request.Query}&type={request.Type}");

            var responses = JsonConvert.DeserializeObject<SearchResponse>(await searchResult.Content.ReadAsStringAsync())!;

            return new SearchResponse
            {
                Tracks = responses!.Tracks
            };


        }

        public async Task<SingleTrackResponse> ListSingleTrackAsync(SingleTrackRequest request)
        {
            var client = _httpClientFactory.CreateClient("HttpClient");

            client.DefaultRequestHeaders.Add(HeaderNames.Authorization, "Bearer " + request.Token);

            var trackResult = await client.GetAsync($"audio-features/{request.Id}");

            var responses = JsonConvert.DeserializeObject<SingleTrackResponse>(await trackResult.Content.ReadAsStringAsync())!;

            return new SingleTrackResponse
            {
                Id = responses!.Id,
                Danceability = responses!.Danceability,
                Key = responses!.Key,
                Loudness = responses!.Loudness,
                Mode = responses!.Mode,
                Speechiness = responses!.Speechiness,
                Acousticness = responses!.Acousticness,
                Instrumentalness = responses!.Instrumentalness,
                Liveness = responses!.Liveness,
                Valence = responses!.Valence,
                Tempo = responses!.Tempo,
                Type = responses!.Type,
                Uri = responses!.Uri,
                TrackHref = responses!.TrackHref,
                AnalysisUrl = responses!.AnalysisUrl,
                DurationMs = responses!.DurationMs,
                TimeSignature = responses!.TimeSignature,
            };
        }
        public async Task<MultipleTrackResponse> ListMultipleTrackAsync(MultipleTrackRequest request)
        {
            var client = _httpClientFactory.CreateClient("HttpClient");

            client.DefaultRequestHeaders.Add(HeaderNames.Authorization, "Bearer " + request.Token);

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

            var query = UriUtil(param);

            var trackMultipleResult = await client.GetAsync($"audio-features{query}");

            var responses = JsonConvert.DeserializeObject<MultipleTrackResponse>(await trackMultipleResult.Content.ReadAsStringAsync())!;

            return new MultipleTrackResponse
            {
                Audio_Features = responses!.Audio_Features
            };
        }

        public async Task SaveTracks(SaveTracksRequest request)
        {
            var client = _httpClientFactory.CreateClient("HttpClient");

            client.DefaultRequestHeaders.Add(HeaderNames.Authorization, "Bearer " + request.Token);

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

            var query = UriUtil(param);


            await client.PutAsync($"me/tracks/{query}", null); 


        }

        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)
        {
            var client = _httpClientFactory.CreateClient("HttpClient");

            client.DefaultRequestHeaders.Add(HeaderNames.Authorization, "Bearer " + request.Token);
            var track = await client.GetAsync($"tracks/{request.TrackID}");

             var response = JsonConvert.DeserializeObject<TrackResponse>(await track!.Content.ReadAsStringAsync())!;
            return response;
        }
    }
}