using System;
using System.Collections.Generic;
using System.Linq;
using MoreLinq;
using Nancy;
using Newtonsoft.Json;
using Sony.Filtr.AdminAPI.ViewModels.Graph;
using Sony.Filtr.Contracts.Abstractions;
using Sony.Filtr.Contracts.Definitions;
using Sony.Filtr.SpotifyAnalytics;
using Sony.Filtr.SpotifyAnalytics.Data;
using Sony.Filtr.SpotifyAnalytics.Models;
using Sony.Filtr.Utility;
using Sony.Filtr.Utility.Extensions;
using Sony.Filtr.Utility.Serialization;

namespace Sony.Filtr.AdminAPI.Modules.SpotifySpecific
{
    public class SpotifyAnalyticsModule : BaseModule
    {
        public SpotifyAnalyticsModule(IApplicationInstanceManager applicationInstanceManager, SpotifyAnalyticsManager spotifyAnalyticsManager) : base(applicationInstanceManager)
        {
            Get["GetSpotifyAnalyticsMarketGraph", "/spotifyAnalytics/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 = spotifyAnalyticsManager.GetStreamSummary(startDate, endDate);
                var apps = applicationInstanceManager.GetApplications().DistinctBy(a => a.SpotifyRegionCode).ToDictionary(a => a.SpotifyRegionCode, b => b.Name);

                var series = streamSummary.GroupBy(p => p.Market).Select(s => new SpotifyStreamsDataSummarySeriesViewModel
                {
                    CountryCode = s.Key,
                    MarketName = apps.GetValueOrDefault(s.Key),
                    Entries = s.GroupBy(d => d.Date).Select(p => new GraphEntry<SpotifyStreamDataSummaryViewModel>()
                    {
                        Date = p.Key,
                        Value = BuildViewModel(p)
                    }).ToList(),
                }).ToList();

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

            Get["GetSpotifyAnalyticsPlaylistDates", "/spotifyAnalytics/playlist/dates"] = parameters =>
            {
                DateTime startDate = Maybe.ToDateTimeOrFallback((string)Request.Query.startDate, DateTime.Today.AddDays(-30));
                DateTime endDate = Maybe.ToDateTimeOrFallback((string)Request.Query.endDate, DateTime.Today);

                var playlistDates = spotifyAnalyticsManager.GetPlaylistProcessedDates(startDate, endDate);
                var viewModels = playlistDates.Where(p=> p.DistributerId == (int)SpotifyAnalyticsAccount.Sony && p.AggregatedTimestamp.HasValue && p.CategoryStreamsSummary.HasValue).GroupBy(d => d.Date).Select(d => BuildSpotifyAnalyticsPlaylistDateViewModel(d));

                return Response.AsJson(viewModels);
            };

            Get["GetSpotifyAnalyticsPlaylistDatesLatest", "/spotifyAnalytics/playlist/dates/latest"] = parameters =>
            {
                var date = spotifyAnalyticsManager.GetLatestProccessedDateWithFullData();

                return Response.AsJson(new SpotifyAnalyticsLatestDateViewModel { Date = date});
            };
        }

        private static SpotifyAnalyticsPlaylistDateViewModel BuildSpotifyAnalyticsPlaylistDateViewModel(IGrouping<DateTime, SpotifyAnalyticsPlaylistProcessedDate> dates)
        {
            var regions = dates.Select(p=> p.CountryCode).Distinct().ToList();

            return new SpotifyAnalyticsPlaylistDateViewModel() { Date = dates.Key, Regions = regions,  RegionCount = regions.Count };
        }

        private SpotifyStreamDataSummaryViewModel BuildViewModel(IGrouping<DateTime, StreamDataSummary> streamDataSummary)
        {
            var sonyStreamsData = streamDataSummary.Where(p => p.AccountId == (int)SpotifyAnalyticsAccount.Sony);

            return new SpotifyStreamDataSummaryViewModel()
            {
                TotalStreams = streamDataSummary.Sum(t => t.TotalStreams),
                DeviceDesktopStreams = streamDataSummary.Sum(t => t.DeviceDesktopStreams),
                DeviceMobileStreams = streamDataSummary.Sum(t => t.DeviceMobileStreams),
                DeviceTabletStreams = streamDataSummary.Sum(t => t.DeviceTabletStreams),
                OSAndroidStreams = streamDataSummary.Sum(t => t.OSAndroidStreams),
                OSMacOSStreams = streamDataSummary.Sum(t => t.OSMacOSStreams),
                OSOtherStreams = streamDataSummary.Sum(t => t.OSOtherStreams),
                OSWindowsStreams = streamDataSummary.Sum(t => t.OSWindowsStreams),
                OSiOSStreams = streamDataSummary.Sum(t => t.OSiOSStreams),
                SourceAlbum = streamDataSummary.Sum(t => t.SourceAlbum),
                SourceArtist = streamDataSummary.Sum(t => t.SourceArtist),
                SourceCollection = streamDataSummary.Sum(t => t.SourceCollection),
                SourceOther = streamDataSummary.Sum(t => t.SourceOther),
                SourcePlaylist = streamDataSummary.Sum(t => t.SourcePlaylist),
                SourceSearch = streamDataSummary.Sum(t => t.SourceSearch),
                UniqueUsers = sonyStreamsData.Sum(t => t.UniqueUsers)
            };
        }
    }

    public class SpotifyAnalyticsLatestDateViewModel
    {
        [JsonConverter(typeof(DateNoTimeConverter))]
        public DateTime? Date { get; set; }
    }
    public class SpotifyAnalyticsPlaylistDateViewModel
    {
        [JsonConverter(typeof(DateNoTimeConverter))]
        public DateTime Date { get; set; }

        public List<string> Regions { get; set; }

        public int RegionCount { get; set; }
    }
}