using Nancy;
using Sony.Filtr.AdminAPI.Modules.MostPlaylistedTracks.ViewModels;
using Sony.Filtr.ApolloAPI;
using Sony.Filtr.Contracts.Abstractions;
using Sony.Filtr.Contracts.Entities;
using Sony.Filtr.Core.TopLists;
using Sony.Filtr.Playlists.Spotify;
using Sony.Filtr.Utility;
using Sony.Filtr.Utility.Extensions;
using Sony.Filtr.Utility.Logging;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace Sony.Filtr.AdminAPI.Modules.MostPlaylistedTracks
{
    public class MostPlaylistedTracksModule : BaseModule
    {
        private readonly SpotifyPlaylistManager _spotifyPlaylistManager;
        private readonly IApolloWebApi _apolloWebApi;

        public MostPlaylistedTracksModule(IApplicationInstanceManager applicationInstanceManager, TopListManager topListManager,
            SpotifyPlaylistManager spotifyPlaylistManager, SpotifyTrackManager spotifyTrackManager,
            ISonyMusicManager sonyMusicManager, ILogger logger, IApolloWebApi apolloWebApi) : base(applicationInstanceManager, logger)
        {
            _spotifyPlaylistManager = spotifyPlaylistManager;
            _apolloWebApi = apolloWebApi;

            Get["MostPlaylistedTrack", "/MostPlaylistedTrack", true] = async (parameters, cx) =>
            {
                MostPlaylistedTracksViewModel result =
                    await LogActionWrapper.Execute(
                         async () => await MostPlaylistedTrack(topListManager, spotifyTrackManager, sonyMusicManager, Request),
                        Logger, "/MostPlaylistedTrack -> MostPlaylistedTrack", ExtractRequestData(Request));

                return Response.AsJson(result);
            };
        }

        private async Task<MostPlaylistedTracksViewModel> MostPlaylistedTrack(
            TopListManager topListManager,
            SpotifyTrackManager spotifyTrackManager,
            ISonyMusicManager sonyMusicManager,
            Request request)
        {
            var trackReleaseType = Maybe.ToEnumOrDefault<TrackReleaseType>((string)Request.Query.trackReleaseType) ?? TrackReleaseType.Both;
            var topListType = GetTopListTypeFromRequest(request);
            var buzzCategoryId = (int?)request.Query.buzzCategoryId;
            var limit = Maybe.ToIntOrFallback((string)request.Query.limit, 250);
            var offset = Maybe.ToIntOrFallback((string)request.Query.offset, 0);
            var market = (string)request.Query.region;
            
            var toplist = await topListManager.GetToplistAsync(trackReleaseType, market, topListType, buzzCategoryId);

            var viewModel = new MostPlaylistedTracksViewModel(toplist.Paginate(limit, offset))
            {
                Filter = new MostPlaylistedTracksFilter()
                {
                    TrackReleaseType = trackReleaseType,
                    TopListType = topListType,
                    BuzzCategoryId = buzzCategoryId,
                    CountryCode = market
                },
            };

            if (viewModel.Items.Any())
            {
                await FillViewModelAsync(viewModel, market);
            }

            return viewModel;
        }

        private TopListType GetTopListTypeFromRequest(Request request)
        {
            string timePeriod = (string)request.Query.timePeriod;
            if (string.IsNullOrWhiteSpace(timePeriod))
            {
                return TopListType.TopPlaylists;
            }

            switch (timePeriod)
            {
                case "3": return TopListType.TopPlaylistsAdded3Days;
                case "7": return TopListType.TopPlaylistsAdded7Days;
                case "30": return TopListType.TopPlaylistsAdded1Month;
                case "90": return TopListType.TopPlaylistsAdded3Month;
                default: return TopListType.TopPlaylists;
            }
        }

        private async Task FillViewModelAsync(MostPlaylistedTracksViewModel viewModel, string market)
        {
            var topListEntries = viewModel.Items;

            var trackIds = topListEntries.Select(x => new SpotifyLink(x.TrackUri).ExtractTrackID()).OfType<string>().ToList();

            Dictionary<string, bool> trackIdIsASonyMap = (await this._apolloWebApi.IsSonyTrack(trackIds, market))
                .ToDictionary(t => t.TrackId, t => t.IsSony);

            var spotifyTracks = await this._apolloWebApi.GetSpotifyTracks(trackIds, market);

            foreach (var item in topListEntries)
            {
                var apiEntity = spotifyTracks.tracks.FirstOrDefault(x => x.external_ids != null && x.external_ids.isrc == item.ISRC);
                if (apiEntity != null)
                {
                    item.TrackName = apiEntity.name;
                    item.PreviewUrl = apiEntity.preview_url;
                    item.TrackUri = apiEntity.uri;
                    item.AlbumUri = apiEntity.album?.uri;
                    item.AlbumImageUrl = apiEntity.album?.images?.FirstOrDefault()?.url;
                    item.IsSony = trackIdIsASonyMap.ContainsKey(apiEntity.id) ? trackIdIsASonyMap[apiEntity.id] : false;
                }

                item.ArtistName = string.Join(", ", item.Artists.Select(p => p.Name));
            };
        }
    }
}