using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using Nancy;
using Sony.Filtr.AdminAPI.ViewModels.Graph;
using Sony.Filtr.AppleMusic;
using Sony.Filtr.AppleMusic.Data.Internal;
using Sony.Filtr.AppleMusic.Playlists;
using Sony.Filtr.Contracts.Abstractions;
using Sony.Filtr.Contracts.Definitions;
using Sony.Filtr.Utility;
using Sony.Filtr.Utility.Extensions;

namespace Sony.Filtr.AdminAPI.Modules.AppleMusic
{
    public class AppleMusicStreamsModule : BaseModule
    {
        public AppleMusicStreamsModule(IApplicationInstanceManager applicationInstanceManager, AppleMusicStreamsManager appleMusicStreamsManager, AppleMusicApi appleMusicApi, AppleMusicPlaylistManager playlistManager)
            : base(applicationInstanceManager)
        {
            Get["GetAppleMusicAnalyticsMarketOverview", "/appleMusic/analytics/marketOverview", true] = async (parameters, cx) =>
            {
                var startDate = Maybe.ToDateTimeOrFallback((string)Request.Query.startDate, DateTime.Today.AddDays(-56));
                var endDate = Maybe.ToDateTimeOrFallback((string)Request.Query.endDate, startDate.AddDays(56));

                var streamSummary = appleMusicStreamsManager.GetStorefrontStreams(startDate, endDate);
                var streamSummaryDic = streamSummary.GroupBy(p => p.Storefront).ToDictionary(k => k.Key, v => v, StringComparer.InvariantCultureIgnoreCase);

                var playlistStreams = await appleMusicStreamsManager.GetMarketPlaylistStreamsAsync(startDate, endDate);
                var playlistStreamsDic = playlistStreams.GroupBy(p => p.Storefront).ToDictionary(k => k.Key, v => v, StringComparer.InvariantCultureIgnoreCase);

                var playlistOverview = await playlistManager.GetPlaylistCountryOverviewAsync(StaticBuzzCategory.SonyMusic);
                var playlistOverviewDic = playlistOverview.ToDictionary(k => k.CountryCode, v => v, StringComparer.InvariantCultureIgnoreCase);

                var allStorefronts = streamSummaryDic.Select(p=> p.Key).Union(playlistStreamsDic.Select(p=> p.Key)).Distinct(StringComparer.InvariantCultureIgnoreCase).ToList();
                List<AppleMusicMarketAnalyticsOverviewViewModel> storefrontOverviews = new List<AppleMusicMarketAnalyticsOverviewViewModel>();
                
                foreach(var storefront in allStorefronts)
                {
                    var streamsummaryForStorefront = streamSummaryDic.GetValueOrDefault(storefront);
                    var playlistStreamSummaryForStorefront = playlistStreamsDic.GetValueOrDefault(storefront);

                    var daysAgo28 = endDate.AddDays(-28);
                    var daysAgo56 = endDate.AddDays(-56);

                    var summaries28Days = streamsummaryForStorefront?.Where(p => p.Date > daysAgo28).ToList();
                    var summaries56Days = streamsummaryForStorefront?.Where(p => p.Date > daysAgo56).ToList();

                    var playlistSummaries28Days = playlistStreamSummaryForStorefront?.Where(p => p.Date > daysAgo28).ToList();
                    var playlistSummaries56Days = playlistStreamSummaryForStorefront?.Where(p => p.Date > daysAgo56).ToList();

                    var viewModel = new AppleMusicMarketAnalyticsOverviewViewModel()
                    {
                        MarketCode = storefront.ToLowerInvariant(),
                        Streams28Days = summaries28Days?.Sum(pi => pi.TotalStreams),
                        Streams56Days = summaries56Days?.Sum(pi => pi.TotalStreams),
                        PlaylistStreams28Days = summaries28Days?.Sum(pi => GetOtherPlaylistsStreams(pi)),
                        PlaylistStreams56Days = summaries56Days?.Sum(pi => GetOtherPlaylistsStreams(pi)),
                        Users28Days = summaries28Days?.Sum(p => p.TotalListeners),
                        Users56Days = summaries56Days?.Sum(p => p.TotalListeners),
                        
                        PlaylistCount = playlistOverviewDic.GetValueOrDefault(storefront)?.PlaylistCount,

                        MarketOwnedSonyPlaylistStreams28Days = playlistSummaries28Days?.Where(p=> p.BuzzCategoryId == (int)StaticBuzzCategory.SonyMusic).Sum(p=> p.LocalStreams),
                        MarketOwnedSonyPlaylistStreams56Days = playlistSummaries56Days?.Where(p => p.BuzzCategoryId == (int)StaticBuzzCategory.SonyMusic).Sum(p => p.LocalStreams),
                        MarketOwnedSonyPlaylistUsers28Days = playlistSummaries28Days?.Where(p => p.BuzzCategoryId == (int)StaticBuzzCategory.SonyMusic).Sum(p => p.LocalUniqueUsers),
                        MarketOwnedSonyPlaylistUsers56Days = playlistSummaries56Days?.Where(p => p.BuzzCategoryId == (int)StaticBuzzCategory.SonyMusic).Sum(p => p.LocalUniqueUsers),
                        SonyPlaylistStreams28Days = playlistSummaries28Days?.Where(p => p.BuzzCategoryId == (int)StaticBuzzCategory.SonyMusic).Sum(p => p.TotalStreams),
                        SonyPlaylistStreams56Days = playlistSummaries56Days?.Where(p => p.BuzzCategoryId == (int)StaticBuzzCategory.SonyMusic).Sum(p => p.TotalStreams),
                        SonyPlaylistUsers28Days = playlistSummaries28Days?.Where(p => p.BuzzCategoryId == (int)StaticBuzzCategory.SonyMusic).Sum(p => p.TotalUniqueUsers),
                        SonyPlaylistUsers56Days = playlistSummaries56Days?.Where(p => p.BuzzCategoryId == (int)StaticBuzzCategory.SonyMusic).Sum(p => p.TotalUniqueUsers),
                        PlaylistUsers28Days = summaries28Days?.Sum(pi=> pi.ContainerOtherPlaylistsUsers), 
                        PlaylistUsers56Days = summaries56Days?.Sum(pi => pi.ContainerOtherPlaylistsUsers),
                    };
                    storefrontOverviews.Add(viewModel);
                }

                return Response.AsJson(storefrontOverviews);
            };
            Get["GetAppleMusicAnalyticsMarketGraph", "/appleMusic/analytics/marketGraph"] = parameters =>
            {
                DateTime startDate = Maybe.ToDateTimeOrFallback((string)Request.Query.startDate, DateTime.Today.AddDays(-30));
                DateTime endDate = Maybe.ToDateTimeOrFallback((string)Request.Query.endDate, DateTime.Today);

                var streamSummary = appleMusicStreamsManager.GetStorefrontStreams(startDate, endDate);

                var series = streamSummary.GroupBy(p => p.Storefront).Select(s => new AppleMusicDataSummarySeriesViewModel
                {
                    CountryCode = s.Key,
                    MarketName = null,
                    Entries = s.GroupBy(d => d.Date).Select(p => new GraphEntry<AppleMusicStreamDataSummaryViewModel>()
                    {
                        Date = p.Key,
                        Value = new AppleMusicStreamDataSummaryViewModel()
                        {
                            TotalStreams = p.Sum(t=> t.TotalStreams),
                            ContainerPlaylistStreams = p.Sum(t => t.ContainerPlaylistStreams),
                            ContainerOtherPlaylistsUsers = p.Sum(t => t.ContainerOtherPlaylistsUsers),
                            ContainerSubTypeArtistPlaylist = p.Sum(t => t.ContainerSubTypeArtistPlaylist),
                            ContainerSubTypeCuratorPlaylist = p.Sum(t => t.ContainerSubTypeCuratorPlaylist),
                            ContainerSubTypeEditorialPlaylist = p.Sum(t => t.ContainerSubTypeEditorialPlaylist),
                            ContainerSubTypeEditorialStation = p.Sum(t => t.ContainerSubTypeEditorialStation),
                            ContainerSubTypeFormatStation = p.Sum(t => t.ContainerSubTypeFormatStation),
                            ContainerSubTypeNonApplicable = p.Sum(t => t.ContainerSubTypeNonApplicable),
                            ContainerSubTypePersonalMixPlaylist = p.Sum(t => t.ContainerSubTypePersonalMixPlaylist),
                            ContainerSubTypePrivateUserPlaylist = p.Sum(t => t.ContainerSubTypePrivateUserPlaylist),
                            ContainerSubTypeSeeded = p.Sum(t => t.ContainerSubTypeSeeded),
                            
                            ContainerAlbumStreams = p.Sum(t => t.ContainerAlbumStreams),
                            ContainerRadioStreams = p.Sum(t => t.ContainerRadioStreams),
                            ContainerNoneStreams = p.Sum(t => t.ContainerNoneStreams),
                            SourceDiscoveryStreams = p.Sum(t => t.SourceDiscoveryStreams),
                            SourceSearchStreams = p.Sum(t => t.SourceSearchStreams),
                            SourceLibraryStreams = p.Sum(t => t.SourceLibraryStreams),
                            SourceOtherStreams = p.Sum(t => t.SourceOtherStreams),
                            TotalListeners = p.Sum(t => t.TotalListeners),
                        }
                    }).ToList(),
                }).ToList();

                var viewModel = new AppleMusicStreamsDataSummaryViewModel()
                {
                    Series = series,
                    Filter = new DateFilter()
                    {
                        StartDate = startDate,
                        EndDate = endDate
                    }
                };
                return Response.AsJson(viewModel);
            };

            Get["GetAppleAnalyticsMarketGraph", "/appleMusic/analytics/playlistGraph"] = parameters =>
            {
                string playlistId = (string)Request.Query.playlistId;
                DateTime startDate = Maybe.ToDateTimeOrFallback((string)Request.Query.startDate, DateTime.Today.AddDays(-30));
                DateTime endDate = Maybe.ToDateTimeOrFallback((string)Request.Query.endDate, DateTime.Today);

                var streamSummary = appleMusicStreamsManager.GetPlaylistStreams();
                streamSummary = streamSummary.Where(p => p.Date > startDate && p.Date < endDate && p.PlaylistId == playlistId).ToList(); //TODO: Database

                var series = streamSummary.GroupBy(p => p.Storefront).Select(s => new SpotifyStreamsDataSummarySeriesViewModel
                {
                    CountryCode = s.Key,
                    MarketName = null,
                    Entries = s.GroupBy(d => d.Date).Select(p => new GraphEntry<SpotifyStreamDataSummaryViewModel>()
                    {
                        Date = p.Key,
                        Value = new SpotifyStreamDataSummaryViewModel()
                        {
                            TotalStreams = (int)p.Sum(t => t.TotalStreams),
                        }
                    }).ToList(),
                }).ToList();

                var viewModel = new SpotifyStreamsDataSummaryViewModel()
                {
                    Series = series,
                    Filter = new DateFilter()
                    {
                        StartDate = startDate,
                        EndDate = endDate
                    }
                };
                return Response.AsJson(viewModel);
            };
        }

        private static long GetOtherPlaylistsStreams(AppleMusicStreamSummary pi)
        {
            return pi.ContainerSubTypeArtistPlaylist + pi.ContainerSubTypeEditorialPlaylist + pi.ContainerSubTypeCuratorPlaylist;
        }
    }

    public class AppleMusicMarketAnalyticsOverviewViewModel
    {
        public string MarketCode { get; set; }

        public long? PlaylistCount { get; set; }

        public long? MarketOwnedSonyPlaylistUsers28Days { get; set; }
        public long? MarketOwnedSonyPlaylistUsers56Days { get; set; }

        public long? MarketOwnedSonyPlaylistStreams28Days { get; set; }

        public long? MarketOwnedSonyPlaylistStreams56Days { get; set; }

        public long? SonyPlaylistUsers28Days { get; set; }
        public long? SonyPlaylistUsers56Days { get; set; }

        public long? SonyPlaylistStreams28Days { get; set; }

        public long? SonyPlaylistStreams56Days { get; set; }

        public long? Streams28Days { get; set; }

        public long? Streams56Days { get; set; }

        public long? PlaylistStreams28Days { get; set; }

        public long? PlaylistStreams56Days { get; set; }

        public long? Users28Days { get; set; }

        public long? Users56Days { get; set; }

        public long? PlaylistUsers28Days { get; set; }

        public long? PlaylistUsers56Days { get; set; }
    }
}