using System;
using System.Collections.Generic;
using System.Linq;
using Nancy;
using Sony.Filtr.AdminAPI.Modules.TrackPlaylistAdds.ViewModels;
using Sony.Filtr.Contracts.Abstractions;
using Sony.Filtr.Contracts.Entities;
using Sony.Filtr.DistributedCaching;
using Sony.Filtr.Playlists.Spotify;
using Sony.Filtr.Playlists.Spotify.Model;
using Sony.Filtr.Utility;
using Sony.Filtr.Utility.Extensions;

namespace Sony.Filtr.AdminAPI.Modules.TrackPlaylistAdds
{
    public class TrackPlaylistAddsModule : BaseModule
    {
        public TrackPlaylistAddsModule(IApplicationInstanceManager applicationInstanceManager, 
            SpotifyTrackManager spotifyTrackManager, ISonyMusicManager sonyMusicManager, DistributedCacheHandler distributedCacheHandler,
            SpotifyTrackAddManager spotifyTrackAddManager) : base(applicationInstanceManager)
        {

            Get["TrackPlaylistAdds", "/TrackPlaylistAdds", true] = async (parameters, cx) =>
            {
                var uri = (string)Request.Query.uri;
                if (string.IsNullOrWhiteSpace(uri))
                    return HttpStatusCode.BadRequest;

                var region = (string)Request.Query.region;

                var limit = Maybe.ToIntOrFallback((string)Request.Query.limit, 1000);
                var offset = Maybe.ToIntOrFallback((string)Request.Query.offset, 0);

                var cacheKey = "TrackPlaylistAdds-1.0:" + uri + ":" + region;
                var trackViewModels = distributedCacheHandler.Get(cacheKey) as List<TrackPlaylistAddViewModel>;
                if (trackViewModels == null)
                {
                    var link = new SpotifyLink(uri);
                    if (link.IsArtist())
                    {
                        var trackAdds = await spotifyTrackAddManager.GetArtistTrackSummaryAsync(link, region);
                        trackViewModels = trackAdds.Select(BuildTrackAddViewModel).ToList();

                        var isrcs = trackViewModels.Select(t => t.SpotifyTrack.ISRC).Distinct().FilterNull().ToArray();
                        if (isrcs.Any())
                        {
                            var localTracks = await spotifyTrackManager.GetFullLocalTracksByIsrcAsync(isrcs);

                            var localTracksDic = localTracks.ToDictionary(k => k.ISRC, v => v);

                            foreach (var trackPlaylistAdd in trackViewModels)
                            {
                                var isrc = trackPlaylistAdd.SpotifyTrack.ISRC;

                                var localTrack = localTracksDic.GetValueOrDefault(isrc);
                                if (localTrack != null)
                                {
                                    trackPlaylistAdd.SpotifyTrack = BuildViewModel(localTrack);
                                }
                            }
                        }
                    }
                    else if (link.IsAlbum())
                    {
                        var trackAdds = await spotifyTrackAddManager.GetAlbumTrackSummaryAsync(link);
                        trackViewModels = trackAdds.Select(BuildTrackAddViewModel).ToList();

                        var trackIds = trackViewModels.Select(t => t.SpotifyTrack.TrackId).Distinct().FilterNull().ToList();
                        if (trackIds.Any())
                        {
                            var localTracks = await spotifyTrackManager.GetFullLocalTracksAsync(trackIds);

                            var isSony = false;
                            if (!string.IsNullOrWhiteSpace(region))
                            {
                                var upc = localTracks.First().Album?.Upc;
                                
                                if (upc != null)
                                {
                                    var sonyUpc = await sonyMusicManager.IsSonyAlbumAsync(new List<string>() { upc }, null, region);
                                    isSony = sonyUpc.Any();
                                }
                            }
                                                        
                            var localTracksDic = localTracks.ToDictionary(k => k.TrackId, v => v);

                            foreach (var trackPlaylistAdd in trackViewModels)
                            {
                                var trackId = trackPlaylistAdd.SpotifyTrack.TrackId;
                                var localTrack = localTracksDic.GetValueOrDefault(trackId);
                                if (localTrack != null)
                                {
                                    trackPlaylistAdd.SpotifyTrack = BuildViewModel(localTrack);
                                    trackPlaylistAdd.IsSony = trackPlaylistAdd.SpotifyTrack.IsSony = isSony;
                                }
                            }
                        }
                    }
                    distributedCacheHandler.Put(cacheKey, trackViewModels, DateTime.Now.AddMinutes(5));

                }
                var paginatedContent = trackViewModels.Paginate(limit, offset);

                return Response.AsJson(paginatedContent);
            };
        }

        private TrackPlaylistAddViewModel BuildTrackAddViewModel(TrackPlaylistAdd trackPlaylistAdd)
        {
            return new TrackPlaylistAddViewModel()
            {
                Playlists = trackPlaylistAdd.Playlists,
                TotalPlaylistSubscribers = trackPlaylistAdd.TotalPlaylistSubscribers,
                SpotifyTrack = new LocalSpotifyTrackViewModel()
                {
                    TrackId = trackPlaylistAdd.TrackId,
                    ISRC = trackPlaylistAdd.TrackIsrc,
                }
            };
        }

        private LocalSpotifyTrackViewModel BuildViewModel(LocalSpotifyTrack spotifyTrack)
        {
            var viewModel = AutoMapper.Mapper.Map<LocalSpotifyTrackViewModel>(spotifyTrack);

            return viewModel;
        }
    }
}