using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using AutoMapper;
using MoreLinq;
using Nancy;
using Sony.Filtr.AdminAPI.Utility;
using Sony.Filtr.AdminAPI.ViewModels;
using Sony.Filtr.Applications;
using Sony.Filtr.Contracts.Entities;
using Sony.Filtr.Contracts.Entities.Buzz;
using Sony.Filtr.Core.Buzz;
using Sony.Filtr.Core.EditorialPlaylists;
using Sony.Filtr.Database;
using Sony.Filtr.Playlists.Spotify;

namespace Sony.Filtr.AdminAPI.Modules.Buzz
{
    public class BuzzPlaylistModule : BaseModule
    {
        private readonly EditorialPlaylistManager _editorialPlaylistManager;
        private readonly EditorialPlaylistStatsManager _editorialPlaylistStatsManager;
        private readonly SpotifyPlaylistManager _spotifyPlaylistManager;

        public BuzzPlaylistModule(BuzzManager buzzManager, EditorialPlaylistManager editorialPlaylistManager, EditorialPlaylistStatsManager editorialPlaylistStatsManager, ApplicationInstanceManager applicationInstanceManager, SpotifyPlaylistManager spotifyPlaylistManager)
            : base(applicationInstanceManager)
        {
            _editorialPlaylistManager = editorialPlaylistManager;
            _editorialPlaylistStatsManager = editorialPlaylistStatsManager;
            _spotifyPlaylistManager = spotifyPlaylistManager;

            Get["GetBuzzPlaylists", "/{countryCode}/buzz/users/{buzzId}/playlists", true] = async (parameters, cx) =>
            {
                int buzzId;

                BuzzImportUser buzzImportUser;
                if (string.IsNullOrWhiteSpace(parameters.buzzId))
                    return HttpStatusCode.BadRequest;

                if (!int.TryParse((string)parameters.buzzId, out buzzId))
                {
                    buzzImportUser = await buzzManager.GetBuzzImportUserByName(parameters.buzzId);
                }
                else
                {
                    buzzImportUser = (await buzzManager.GetBuzzImportUsersById(buzzId.ToString())).FirstOrDefault();
                }

                if (buzzImportUser == null)
                    return HttpStatusCode.NotFound;

                var buzzPlaylistViewModels = await GetBuzzPlaylistViewModelsAsync(buzzImportUser);

                return Response.AsJson(buzzPlaylistViewModels.OrderBy(x=>x.Subscribers).ThenBy(x=>x.Name));
            };

            Get["GetBulkBuzzUsersPlaylists", "/{countryCode}/buzz/users/playlists", true] = async (parameters, cx) =>
            {
                string buzzIds = (string)Request.Query.ids;

                if (string.IsNullOrWhiteSpace(buzzIds))
                    return HttpStatusCode.BadRequest;

                var buzzImportUsers = await buzzManager.GetBuzzImportUsersById(buzzIds);
                if (buzzImportUsers == null)
                    return HttpStatusCode.NotFound;

                var buzzPlaylistViewModels = await GetBuzzPlaylistViewModelsAsync(buzzImportUsers);

                return Response.AsJson(buzzPlaylistViewModels);
            };

            //Get["GetBuzzPlaylistExcel", "/{countryCode}/buzz/users/{buzzId}/playlists/excel", true] = async (parameters, cx) =>
            //{
            //    int buzzId;
            //    if (!int.TryParse((string)parameters.buzzId, out buzzId))
            //        return HttpStatusCode.BadRequest;

            //    var buzzImportUser = buzzManager.GetBuzzImportUser(buzzId);
            //    if (buzzImportUser == null)
            //        return HttpStatusCode.NotFound;

            //    var playlistStats = await GetPlaylistStats(buzzImportUser);

            //    var playlistExportFileName = $"BuzzPlaylistExport-{CurrentApplication.Name}-{buzzImportUser.SpotifyUserName}-{ExcelUtility.GetFilenameDatePart()}.xlsx";

            //    return ExcelUtility.BuildExcelResponse(playlistStats, playlistExportFileName);
            //};

            //Get["GetBuzzPlaylistForCompanyInMarket", "/{countryCode}/buzz/companies/{companyId}/playlists", true] = async (parameters, cx) =>
            //{
            //    var companyId = (string)parameters.companyId;
            //    var app = CurrentApplication;

            //    var companyUsers = GetBuzzImportUserByCompanyId(buzzManager, app, companyId);
            //    if (!companyUsers.Any())
            //        return HttpStatusCode.NotFound;

            //    var buzzPlaylistViewModels = await GetBuzzPlaylistViewModels(companyUsers);
            //    return Response.AsJson(buzzPlaylistViewModels);
            //};

            Get["GetBuzzPlaylistForCompanyInMarketExcel", "/{countryCode}/buzz/companies/{companyId}/playlists/excel", true] = async (parameters, cx) =>
            {
                var companyId = (string)parameters.companyId;

                var app = CurrentApplication;
                var companyUsers = GetBuzzImportUserByCompanyId(buzzManager, app, companyId);
                if (!companyUsers.Any())
                    return HttpStatusCode.NotFound;

                var playlists = (await GetBuzzPlaylistViewModelsAsync(companyUsers)).Select(x=>x.Playlists); ;

                var company = companyUsers.First().CompanyName;
                var playlistExportFileName = $"BuzzPlaylistExport-{app.Name}-{company}-{ExcelUtility.GetFilenameDatePart()}.xlsx";
                List<BuzzPlaylistViewModel> globalPlaylist = new List<BuzzPlaylistViewModel>();
                foreach (var pl in playlists)
                {
                    globalPlaylist.AddRange(pl);
                }

                return ExcelUtility.BuildExcelResponse(globalPlaylist, playlistExportFileName);

            };
            //Get["/buzz/companies/{companyId}/playlists", true] = async (parameters, cx) =>
            //{
            //    var companyId = (string)parameters.companyId;

            //    var companyUsers = GetBuzzImportUserByCompanyId(buzzManager, null, companyId);
            //    if (!companyUsers.Any())
            //        return HttpStatusCode.NotFound;

            //    var buzzPlaylistViewModels = await GetBuzzPlaylistViewModels(companyUsers);
            //    return Response.AsJson(buzzPlaylistViewModels);
            //};

            //Get["/buzz/companies/{companyId}/playlists/excel", true] = async (parameters, cx) =>
            //{
            //    var companyId = (string)parameters.companyId;

            //    var companyUsers = GetBuzzImportUserByCompanyId(buzzManager, null, companyId);
            //    if (!companyUsers.Any())
            //        return HttpStatusCode.NotFound;

            //    var playlistStats = await GetPlaylistStats(companyUsers);

            //    var company = companyUsers.First().CompanyName;
            //    var playlistExportFileName = $"BuzzPlaylistExport-{"All"}-{company}-{ExcelUtility.GetFilenameDatePart()}.xlsx";

            //    return ExcelUtility.BuildExcelResponse(playlistStats, playlistExportFileName);
            //};

        }

        private async Task<IEnumerable<BuzzPlaylistViewModel>> GetBuzzPlaylistViewModelsAsync(BuzzImportUser buzzImportUser)
        {
            var playlists = await _spotifyPlaylistManager.GetPlaylistsForUserAsync(buzzImportUser.SpotifyUserName, null);

            return playlists.Select(p => new BuzzPlaylistViewModel()
            {
                Id = p.PlaylistId,
                SpotifyLink = p.PlaylistUri,
                Name = p.Name,
                Subscribers = p.Followers,
                PreviousSubscribers = p.Followers1dayAgo,
                FollowersChange30 = p.Followers28daysAgo - p.Followers,
                FollowersChange15 = p.Followers14daysAgo - p.Followers,
                FollowersChange7 = p.Followers7daysAgo - p.Followers,
                ImageFileName = p.Image,
            });
        }

        private async Task<List<BuzzUsersPlaylistViewModel>> GetBuzzPlaylistViewModelsAsync(List<BuzzImportUser> buzzImportUsers)
        {
            List<BuzzUsersPlaylistViewModel> playlistViewModels = new List<BuzzUsersPlaylistViewModel>();
            foreach(var user in buzzImportUsers)
            {
                playlistViewModels.Add(new BuzzUsersPlaylistViewModel()
                {
                    UserId = user.ID.ToString(),
                    Playlists = new List<BuzzPlaylistViewModel>(await GetBuzzPlaylistViewModelsAsync(user))
                });
               
            }

            return playlistViewModels;
        }
        
        private async Task<List<EditorialPlaylistWithStats>> GetPlaylistStats(List<BuzzImportUser> companyUsers)
        {
            var playlists = await GetEditorialPlaylistsAsync(companyUsers);
            var playlistStats = await _editorialPlaylistStatsManager.GetPlaylistStatsAsync(playlists);
            return playlistStats;
        }

        //private async Task<IEnumerable<BuzzPlaylistViewModel>> GetBuzzPlaylistViewModels(List<BuzzImportUser> companyUsers)
        //{
        //    var playlists = await GetEditorialPlaylistsAsync(companyUsers);
        //    var playlistAttributes = await _editorialPlaylistManager.GetPlaylistAttributesAsync(playlists);
        //    var buzzPlaylistViewModels = playlistAttributes.DistinctBy(p => p.EditorialPlaylist.SpotifyLink).Select(p => BuildBuzzPlaylistViewModel(p.EditorialPlaylist, p.Attributes));
        //    return buzzPlaylistViewModels;
        //}

        //private async Task<List<EditorialPlaylistWithStats>> GetPlaylistStats(BuzzImportUser buzzImportUser)
        //{
        //    var playlists = await _editorialPlaylistManager.GetEditorialPlaylistsAsync(buzzImportUser.SpotifyUserName, buzzImportUser.ApplicationID);
        //    var playlistStats = await _editorialPlaylistStatsManager.GetPlaylistStatsAsync(playlists);
        //    return playlistStats;
        //}

        private async Task<List<Contracts.Entities.EditorialPlaylist>> GetEditorialPlaylistsAsync(List<BuzzImportUser> companyUsers)
        {
            List<Contracts.Entities.EditorialPlaylist> playlists = new List<Contracts.Entities.EditorialPlaylist>();
            foreach(var buzzImportUser in companyUsers)
            {
                var userPlaylists = await _editorialPlaylistManager.GetEditorialPlaylistsAsync(buzzImportUser.SpotifyUserName, buzzImportUser.ApplicationID);
                playlists.AddRange(userPlaylists);
            }
            return playlists;
        }

        private BuzzPlaylistViewModel BuildBuzzPlaylistViewModel(Contracts.Entities.EditorialPlaylist playlist, EditorialPlaylistAttributes playlistAttribute)
        {
            return new BuzzPlaylistViewModel()
            {
                Id = playlist.ID.ToString(),
                Name = playlist.Name,
                SpotifyLink = playlist.SpotifyLink.Uri,
                Subscribers = playlistAttribute.Followers,
                PreviousSubscribers = playlistAttribute.LastFollowers,
                ImageFileName = playlist.ImageFileName,
                FollowersChange7 = playlistAttribute.FollowerChange7,
                FollowersChange15 = playlistAttribute.FollowerChange15,
                FollowersChange30 = playlistAttribute.FollowerChange30,
            };
        }


        //private BuzzPlaylistViewModel BuildBuzzPlaylistViewModel(EditorialPlaylistWithStats playlist)
        //{
        //    return new BuzzPlaylistViewModel()
        //    {
        //        Id = playlist.Playlist.ID,
        //        Name = playlist.Playlist.Name,
        //        SpotifyLink = playlist.Playlist.SpotifyLink.Uri,
        //        Subscribers = playlist.LatestSubscribers,
        //        PreviousSubscribers = playlist.SecondLatestSubscribers,
        //        ImageFileName = playlist.Playlist.ImageFileName,
        //        //Stats = playlist.Stats,
        //    };
        //}

        private List<BuzzImportUser> GetBuzzImportUserByCompanyId(BuzzManager buzzManager, Application app, string companyId)
        {
            var buzzImportUsers = buzzManager.GetBuzzImportUsers(app);
            var companyUsers = buzzImportUsers.Where(b=> Mapper.Map<BuzzImportUserViewModel>(b).CompanyId.Equals(companyId, StringComparison.CurrentCultureIgnoreCase))
                .ToList();
            return companyUsers;
        }
    }
}