using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using AutoMapper;
using Nancy;
using Sony.Filtr.AdminAPI.Utility;
using Sony.Filtr.AdminAPI.ViewModels.Spotify.Browse;
using Sony.Filtr.Contracts.Abstractions;
using Sony.Filtr.Core.EditorialPlaylists;
using Sony.Filtr.Core.Factory;
using Sony.Filtr.Core.SpotifyBrowse;
using Sony.Filtr.Core.SpotifyBrowse.Data;
using Sony.Filtr.Playlists.Spotify;
using Sony.Filtr.Utility;

namespace Sony.Filtr.AdminAPI.Modules.SpotifySpecific
{
    public class SpotifyBrowseModule : BaseModule
    {
        private readonly SpotifyBrowseManager _spotifyBrowseManager;
        private readonly SpotifyPlaylistManager _spotifyPlaylistManager;

        public SpotifyBrowseModule(IApplicationInstanceManager applicationInstanceManager, SpotifyBrowseManager spotifyBrowseManager, EditorialPlaylistManager editorialPlaylistManager, StorageFactory storageFactory, SpotifyPlaylistManager spotifyPlaylistManager)
            : base(applicationInstanceManager)
        {
            _spotifyBrowseManager = spotifyBrowseManager;
            _spotifyPlaylistManager = spotifyPlaylistManager;

            //Get["GetSpotifyBrowse", "/SpotifyBrowse", true] = async (parameters, cancellationToken) =>
            //{
            //    DateTime date;
            //    if (!DateTime.TryParse(Request.Query.Date, out date))
            //        return HttpStatusCode.BadRequest;

            //    var viewModels = await GetSpotifyBrowseItemViewModelsAsync(spotifyBrowseManager, editorialPlaylistManager, date);

            //    return Response.AsJson(viewModels);
            //};

            Get["GetSpotifyBrowseDates", "/{countryCode}/SpotifyBrowse/dates", true] = async (parameters, cancellationToken) =>
            {
                if (CurrentApplication == null)
                {
                    return HttpStatusCode.BadRequest;
                }
                var region = CurrentApplication.SpotifyRegionCode;

                var dates = await spotifyBrowseManager.GetSpotifyBrowseDatesAsync(region);

                return Response.AsJson(dates.Select(d => d.Year + "-" + d.Month.ToString("D2") + "-" + d.Day.ToString("D2")));
            };

            Get["GetSpotifyBrowseUtcDates", "/{countryCode}/SpotifyBrowse/utcdates", true] = async (parameters, cancellationToken) =>
            {
                if (CurrentApplication == null)
                {
                    return HttpStatusCode.BadRequest;
                }
                var region = CurrentApplication.SpotifyRegionCode;
                var dates = await spotifyBrowseManager.GetSpotifyBrowseUtcDatesAsync(region);

                var datesViewModel = dates.ToDictionary(d => d.Key.Year + "-" + d.Key.Month.ToString("D2") + "-" + d.Key.Day.ToString("D2"), d => d.Value);
                return Response.AsJson(datesViewModel);
            };

            Get["GetSpotifyBrowseCategoryStats", "/{countryCode}/SpotifyBrowse/{date}/categorystats", true] = async (parameters, cancellationToken) =>
            {
                if (CurrentApplication == null)
                {
                    return HttpStatusCode.BadRequest;
                }

                var browseDate = await DetermineBrowseDateToUseAsync((string)parameters.date);

                var browseData = await spotifyBrowseManager.GetSpotifyBrowseCategoryStatsAsync(browseDate, CurrentApplication);

                return Response.AsJson(browseData);
            };

            Get["GetSpotifyBrowseCategory", "/{countryCode}/SpotifyBrowse/{date}/categorystats/{category}", true] = async (parameters, cancellationToken) =>
            {
                if (CurrentApplication == null)
                {
                    return HttpStatusCode.BadRequest;
                } 

                var browseDate = await DetermineBrowseDateToUseAsync((string)parameters.date);
                var category = (string) parameters.category;

                var browseData = await spotifyBrowseManager.GetSpotifyBrowseCategoryTopListAsync(CurrentApplication, category, browseDate);

                return Response.AsJson(browseData);
            };

            Get["GetSpotifyBrowsePlaylist", "/SpotifyBrowse/{date}/playlists", true] = async (parameters, cancellationToken) =>
            {
                var browseDate = await DetermineBrowseDateToUseAsync((string)parameters.date);

                var playlistId = Request.GetRequiredPlaylistId();
                
                var browseData = await spotifyBrowseManager.GetSpotifyBrowsePlaylistsSummaryAsync(browseDate, new List<string>() { playlistId });

                var viewModel = browseData.GroupBy(b => b.Market).Select(b => new SpotifyBrowsePlaylistSummary
                {
                    Region = b.Key,
                    Categories = b.Select(bi => new SpotifyBrowsePlaylistCategorySummary
                    {
                        CategoryId = bi.CategoryId,
                        CategoryName= bi.CategoryName,
                        Position = bi.Position,
                        PeakPosition = bi.PeakPosition,
                    }).ToList()
                });

                return Response.AsJson(viewModel);
            };

            Get["GetSpotifyBrowseExport", "/{countryCode}/SpotifyBrowse/{date}/categorystats/export/", true] = async (parameters, cancellationToken) =>
            {
                if (CurrentApplication == null)
                {
                    return HttpStatusCode.BadRequest;
                }

                var market = CurrentApplication.SpotifyRegionCode;

                if(!string.IsNullOrWhiteSpace(Request.Query.Global) && ((string)Request.Query.Global).Equals("true", StringComparison.CurrentCultureIgnoreCase))
                {
                    market = null;
                }

                var browseDate = await DetermineBrowseDateToUseAsync((string)parameters.date);
               
                if (market == null)
                {
                    // If global export, get export file from S3 and send to user.
                    var exportFileName = _spotifyBrowseManager.GetSpotifyBrowseExportFileName(browseDate);

                    var fileStream = storageFactory.GetObject(exportFileName, _spotifyBrowseManager.SpotifyBrowseS3BucketName);
                    return ExcelUtility.BuildExcelResponse(fileStream, exportFileName);
                }

                var browseData = await _spotifyBrowseManager.GetSpotifyBrowseForExportAsync(market, browseDate);
                var playlistBrowseFileName = $"SpotifyBrowse-{ExcelUtility.GetFilenameDatePart()}-{market}.xlsx";
                return ExcelUtility.BuildExcelResponse(ExcelFileUtility.GetExcelStream(browseData, browseDate), playlistBrowseFileName);
            };
        }

        private async Task<DateTime> DetermineBrowseDateToUseAsync(string date)
        {
            DateTime browseDate;

            if (date.Equals("latest", StringComparison.CurrentCultureIgnoreCase))
            {
                var region = CurrentApplication?.SpotifyRegionCode;

                var dates = await _spotifyBrowseManager.GetSpotifyBrowseDatesAsync(region);
                browseDate = dates.Max();
            }
            else
            {
                if (!DateTime.TryParse(date, out browseDate))
                {
                    throw new Exception("Invalid date specified in url");
                }
            }
            return browseDate;
        }
    }
}