using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Net.Http;
using System.Linq;
using System.Net;
using System.Web;
using System.Threading.Tasks;
using Newtonsoft.Json;
using Sony.Filtr.Contracts.Abstractions;
using Sony.Filtr.DeezerAPI.Model;
using Sony.Filtr.Utility.Extensions;

namespace Sony.Filtr.DeezerAPI
{
    public class DeezerApi
    {
        private readonly IRateLimiter _rateLimiter;

        private static readonly HttpClient _Client = new HttpClient(new HttpClientHandler() { AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate, UseCookies = false})
        {
            BaseAddress = new Uri("http://api.deezer.com"),
        };
        
        public DeezerApi(IRateLimiter rateLimiter)
        {
            _rateLimiter = rateLimiter;
        }

        private async Task<T> GetAsync<T>(string url)
        {
            await _rateLimiter.WaitToProceedAsync();

            var response = await _Client.GetAsync(url);
            if (!response.IsSuccessStatusCode)
            {
                throw DeezerException.FromHttpResponseMessage(response);
            }

            var responseString = await response.Content.ReadAsStringAsync();
            var error = JsonConvert.DeserializeObject<ErrorResponse>(responseString);
            if (error?.error?.type != null)
            {
                throw new DeezerException(error.error);
            }

            var playlistResponse = JsonConvert.DeserializeObject<T>(responseString);

            return playlistResponse;
        }

        private async Task<HttpResponseMessage> ExecuteRequestAsync(HttpRequestMessage request)
        {
            await _rateLimiter.WaitToProceedAsync();

            return await _Client.SendAsync(request);
        }

        public async Task<List<UserDeezerPlaylist>> GetAllUsersPlaylistsAsync(long userId)
        {
            List<UserDeezerPlaylist> playlists = new List<UserDeezerPlaylist>();
            var url = $"/user/{userId}/playlists";

            var playlistResponse = await GetAsync<UserPlaylistsResponse>(url);
            playlists.AddRange(playlistResponse.data);
            if (playlistResponse.next != null)
            {
                var next = playlistResponse.next;
                while (next != null)
                {
                    var nextResponse = await GetAsync<UserPlaylistsResponse>(next);
                    next = nextResponse.next;

                    playlists.AddRange(nextResponse.data);
                }
            }
            return playlists;
        }

        public async Task<PlaylistResponse> GetPlaylistAsync(long playlistId, string accessToken = null)
        {
            string pathAndQuery = $"http://api.deezer.com/playlist/{playlistId}";

            var parameters = System.Web.HttpUtility.ParseQueryString(String.Empty);
            if (accessToken != null)
            {
                parameters["access_token"] = accessToken;
            }

            pathAndQuery += $"?{parameters.ToString()}";

            return await GetAsync<PlaylistResponse>(pathAndQuery);
        }

        public async Task<List<PlaylistTrackItem>> GetAllPlaylistTracksAsync(long playlistId)
        {
            List<PlaylistTrackItem> playlistTrackItems = new List<PlaylistTrackItem>();
            var playlistTracks = await GetAsync<PlaylistTracksResponse>($"/playlist/{playlistId}/tracks");
            if (playlistTracks?.data != null && playlistTracks.data.Any())
            {
                playlistTrackItems.AddRange(playlistTracks.data);
                
                while (playlistTracks.next != null)
                {
                    playlistTracks = await GetAsync<PlaylistTracksResponse>(playlistTracks.next);
                    playlistTrackItems.AddRange(playlistTracks.data);
                }
            }
            return playlistTrackItems;
        }

        public async Task<UserFollowerResponse> GetUserFollowersAsync(long userId)
        {
            return await GetAsync<UserFollowerResponse>($"http://api.deezer.com/user/{userId}/followers");
        }

        public async Task<UserResponse> GetUserAsync(long userId)
        {
            return await GetAsync<UserResponse>($"http://api.deezer.com/user/{userId}");
        }

        public async Task<CreateResponse> SetPlaylistInfoAsync(string accessToken, long playlistId, string title, string description, bool isPublic, bool collaborative)
        {
            string pathAndQuery = $"http://api.deezer.com/playlist/{playlistId}";

            var parameters = HttpUtility.ParseQueryString(String.Empty);
            parameters["access_token"] = accessToken;
            parameters["title"] = title;
            parameters["description"] = description;
            parameters["public"] = isPublic.ToString().ToLower();
            parameters["collaborative"] = collaborative.ToString().ToLower();

            pathAndQuery += $"?{parameters.ToString()}";

            var request = new HttpRequestMessage(HttpMethod.Post, pathAndQuery);

            var response = await _Client.SendAsync(request);
            if (!response.IsSuccessStatusCode)
            {
                throw DeezerException.FromHttpResponseMessage(response);
            }

            //TODO: Verify response data
            //var createResponse = await response.Content.ReadAsAsync<CreateResponse>();

            return new CreateResponse();
        }

        public async Task AddTracksAsync(string accessToken, long deezerPlaylistId, IEnumerable<long> trackIds)
        {
            string pathAndQuery = $"http://api.deezer.com/playlist/{deezerPlaylistId}/tracks";

            var parameters = HttpUtility.ParseQueryString(String.Empty);
            parameters["songs"] = string.Join(",", trackIds);
            parameters["access_token"] = accessToken;

            pathAndQuery += $"?{parameters.ToString()}";

            var request = new HttpRequestMessage(HttpMethod.Post, pathAndQuery) {Content = new StringContent(string.Empty)};
            var response = await ExecuteRequestAsync(request);
            if (!response.IsSuccessStatusCode)
            {
                throw DeezerException.FromHttpResponseMessage(response);
            }
        }

        public async Task DeletePlaylistTracksAsync(string accessToken, long playlistId, IEnumerable<long> trackIds)
        {
            var url = $"http://api.deezer.com/playlist/{playlistId}/tracks";

            var parameters = HttpUtility.ParseQueryString(String.Empty);
            parameters["songs"] = string.Join(",", trackIds);
            parameters["access_token"] = accessToken;

            var request = new HttpRequestMessage(HttpMethod.Delete, url += $"{parameters}");
            var response = await ExecuteRequestAsync(request);
            if (!response.IsSuccessStatusCode)
            {
                throw DeezerException.FromHttpResponseMessage(response);
            }
        }

        public async Task OrderPlaylistTracksAsync(string accessToken, long playlistId, IEnumerable<long> orderedTrackIds)
        {
            var url = $"http://api.deezer.com/playlist/{playlistId}/tracks";

            var parameters = HttpUtility.ParseQueryString(String.Empty);
            parameters["order"] = string.Join(",", orderedTrackIds);
            parameters["access_token"] = accessToken;
            
            var request = new HttpRequestMessage(HttpMethod.Post, url += $"{parameters}") { Content = new StringContent(string.Empty)};
            var response = await ExecuteRequestAsync(request);
            if (!response.IsSuccessStatusCode)
            {
                throw DeezerException.FromHttpResponseMessage(response);
            }
        }

        public async Task<TrackISRCResponse> GetTrackByISRCAsync(string accessToken, string isrc)
        {
            // https://api.deezer.com/2.0/track/isrc:USWB11200587

            var url = $"https://api.deezer.com/2.0/track/isrc:{isrc}";
            var parameters = HttpUtility.ParseQueryString(String.Empty);
            parameters["access_token"] = accessToken;

            var responseString = await _Client.GetStringAsync(url += $"{parameters}");

            var errorResponse = JsonConvert.DeserializeObject<ErrorResponse>(responseString);

            if (errorResponse?.error != null)
            {
                return null;
            }

            return JsonConvert.DeserializeObject<TrackISRCResponse>(responseString);
        }

        public async Task<TrackResponse> GetTrackAsync(long trackId)
        {
            return await GetAsync<TrackResponse>(string.Format("/track/{0}", trackId));
        }

        public async Task<SearchResponse<ArtistSearchResultItem>> SearchArtistsAsync(string searchQuery, int index = 0, int limit = 0, string order = null)
        {
            var url = $"http://api.deezer.com/search/artist";

            var parameters = HttpUtility.ParseQueryString(String.Empty);
            parameters["q"] = searchQuery;

            if (order != null) { parameters["order"] = order; }

            if (index != 0) { parameters["index"] = index.ToString(); }
            if (limit != 0) { parameters["limit"] = limit.ToString(); }

            return await GetAsync<SearchResponse<ArtistSearchResultItem>>(url += $"{parameters}");
        }

        public async Task<TracksResponse> GetArtistTopTracksAsync(string artistId, int? limit = null)
        {
            var url = $"http://api.deezer.com/artist/{artistId}/top";

            var parameters = HttpUtility.ParseQueryString(String.Empty);
            if (limit != null) { parameters["limit"] = limit.ToString(); }

            return await GetAsync<TracksResponse>(url += $"{parameters}");
        }

        public async Task<List<TrackResponse>> GetMultipleTracksAsync(IEnumerable<long> deezerTrackIds)
        {
            ConcurrentBag<TrackResponse> trackResponses = new ConcurrentBag<TrackResponse>();
            await deezerTrackIds.ForEachAsync(5, async deezerTrackId =>
            {
                var trackResponse = await GetTrackAsync(deezerTrackId);
                trackResponses.Add(trackResponse);
            });
            return trackResponses.ToList();
        }
    }
    
}