using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Threading.Tasks;
using Sony.Filtr.SoundCloud.Model;
using Newtonsoft.Json;
using Sony.Filtr.Contracts.Abstractions;
using Sony.Filtr.Contracts.Entities;
using Track = Sony.Filtr.SoundCloud.Model.Track;
using Url = Flurl.Url;

namespace Sony.Filtr.SoundCloud
{
    public class SoundCloudApi
    {
        private readonly ServiceAccount _serviceAccount;
        private readonly IServiceAccountManager _serviceAccountManager;
        private const string BaseUrl = "https://api.soundcloud.com";

        private const string ClientId = "22d200cb2449f4028bcf9d6381fb2a6f";
        private const string ClientSecret = "67a49c0de2d126788bbf36e5954cd414";


        public SoundCloudApi(ServiceAccount serviceAccount, IServiceAccountManager serviceAccountManager)
        {
            _serviceAccount = serviceAccount;
            _serviceAccountManager = serviceAccountManager;
        }

        private HttpClient GetDefaultClient()
        {
            var authHandler = new SoundCloudAuthorizationHttpMessageHandler(_serviceAccount, _serviceAccountManager, ClientId, ClientSecret, new HttpClientHandler());
            HttpClient client = new HttpClient(authHandler);
            client.BaseAddress = new Uri(BaseUrl);

            return client;
        }


        private async Task<T> GetAsync<T>(string url)
        {
            var client = GetDefaultClient();
          
            var response = await client.GetStringAsync(url);
            var modelResponse = JsonConvert.DeserializeObject<T>(response);
            return modelResponse;
        }

        private async Task ExecuteRequestAsync(HttpRequestMessage request)
        {
            var client = GetDefaultClient();
            client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
            await client.SendAsync(request);
        }

        public async Task<PlaylistResponse> GetPlaylistAsync(string playlistUrl)
        {
            var url = new Url("/resolve/");
            url.SetQueryParam("url", playlistUrl);
            url.SetQueryParam("client_id", ClientId);

            var client = GetDefaultClient();
            var response = await client.GetAsync(url);

            if (response.StatusCode == HttpStatusCode.NotFound)
                return null;

            if (!response.IsSuccessStatusCode)
            {
                throw SoundCloudException.FromHttpResponseMessage(response);
            }

            var responseString = await response.Content.ReadAsStringAsync();

            var modelResponse = JsonConvert.DeserializeObject<PlaylistResponse>(responseString);
            return modelResponse;
        }
        public async Task<PlaylistResponse> GetPlaylistAsync(int playlistId)
        {
            var url = new Url("/playlists/");
            url.AppendPathSegment(playlistId.ToString());
            url.SetQueryParam("client_id", ClientId);

            var client = GetDefaultClient();
            var response = await client.GetAsync(url);
            if (response.StatusCode == HttpStatusCode.NotFound)
                return null;

            if (!response.IsSuccessStatusCode)
            {
                throw SoundCloudException.FromHttpResponseMessage(response);
            }

            var responseString = await response.Content.ReadAsStringAsync();

            var modelResponse = JsonConvert.DeserializeObject<PlaylistResponse>(responseString);
            return modelResponse;
        }



        public async Task<List<TrackResponse>> GetTrackAsync(string title, string isrc)
        {
            var url = new Url("/tracks");
            url.SetQueryParam("client_id", ClientId);
            url.SetQueryParam("q", title);
            return await GetAsync<List<TrackResponse>>(url);
        }

        public async Task AddTracksToPlayListAsync(int playlistId, List<Track> tracks )
        {
            var url = new Url("/playlists/");
            url.AppendPathSegment(playlistId.ToString());
            url.SetQueryParam("client_id", ClientId);

            var request = new HttpRequestMessage(HttpMethod.Put, url);

            var playlistRequest = new UpdateTracksRequest { playlist = new Playlist { tracks = new List<Track>() } };
            if (tracks.Any())
            {
                playlistRequest.playlist.tracks.AddRange(tracks);
            }
            request.Content = new StringContent(JsonConvert.SerializeObject(playlistRequest), Encoding.UTF8, "application/json");
                
            await ExecuteRequestAsync(request);
        }

        public async Task UpdateTitleAndDescription(string playlistId, UpdatePlaylistInfoRequest playlistInfoRequest)
        {
            var url = new Url("/playlists/");
            url.AppendPathSegment(playlistId);
            url.SetQueryParam("client_id", ClientId);
            
            var request = new HttpRequestMessage(HttpMethod.Put, url);
            request.Content = new StringContent(JsonConvert.SerializeObject(playlistInfoRequest), Encoding.UTF8, "application/json");
            await ExecuteRequestAsync(request);
        }

    }
}