using System.Collections.Generic;
using System.Linq;
using AutoMapper;
using Nancy;
using Nancy.ModelBinding;
using Sony.Filtr.AdminAPI.ViewModels;
using Sony.Filtr.Applications;
using Sony.Filtr.Contracts.Entities;
using Sony.Filtr.Core.EditorialPlaylists;
using Sony.Filtr.Utility.Extensions;

namespace Sony.Filtr.AdminAPI.Modules.EditorialPlaylist
{
    public class PlaylistCategoryModule : BaseModule
    {
        public PlaylistCategoryModule(PlaylistCategoryManager playlistCategoryManager, EditorialPlaylistManager editorialPlaylistManager, EditorialPlaylistStatsManager editorialPlaylistStatsManager, ApplicationInstanceManager applicationInstanceManager)
            : base(applicationInstanceManager)
        {
            Get["GetPlaylistCategories", "/{countryCode}/playlistcategories/"] = parameters =>
            {
                var categories = playlistCategoryManager.GetCategories(CurrentApplication);
                return Response.AsJson(categories);
            };

            Post["AddPlaylistCategory", "/{countryCode}/playlistcategories/"] = parameters =>
            {
                var category = this.Bind<PlaylistCategory>(p => p.ID, p => p.ApplicationId);
                if (category == null)
                    return HttpStatusCode.BadRequest;

                category.ApplicationId = CurrentApplication.ID;

                category = playlistCategoryManager.SaveCategory(category);
                return Response.AsJson(category);
            };

            Post["SetPlaylistCategoryOrder", "/{countryCode}/playlistcategories/Order"] = parameters =>
            {
                var categoryOrder = this.Bind<PlaylistCategoryPostObject>();
                if (categoryOrder == null || categoryOrder.Ids == null || !categoryOrder.Ids.Any())
                    return HttpStatusCode.BadRequest;

                var categories = new List<PlaylistCategory>();

                var existingCategories = playlistCategoryManager.GetCategories(CurrentApplication).ToDictionary(k => k.ID, v => v);
                foreach (var playlistCategoryIdOrder in categoryOrder.Ids.ItemIndex())
                {
                    int playlistCategoryId;
                    if (int.TryParse(playlistCategoryIdOrder.Item, out playlistCategoryId) &&
                        existingCategories.ContainsKey(playlistCategoryId))
                    {
                        var category = existingCategories[playlistCategoryId];
                        category.Order = playlistCategoryIdOrder.Index;
                        category = playlistCategoryManager.SaveCategory(category);
                        categories.Add(category);
                    }
                }
                
                return Response.AsJson(categories);
            };

            Get["GetPlaylistInCategory", "/{countryCode}/playlistcategories/{id}/playlists", true] = async (parameters, cx) =>
            {
                int id;
                if (!int.TryParse((string) parameters.id, out id))
                    return HttpStatusCode.BadRequest;
                var existingCategory = playlistCategoryManager.GetCategory(id);
                if (existingCategory == null)
                    return HttpStatusCode.NotFound;

                var playlists = playlistCategoryManager.GetPlaylists(existingCategory);
                var playlistStats = await editorialPlaylistStatsManager.GetPlaylistStatsAsync(playlists);

                return Response.AsJson(playlistStats.Select(BuildPlaylistViewModel));
            };
            Put["UpdatePlaylistCategory", "/{countryCode}/playlistcategories/{id}"] = parameters =>
            {
                int id;
                if (!int.TryParse((string) parameters.id, out id))
                    return HttpStatusCode.BadRequest;

                var category = this.Bind<PlaylistCategory>(p => p.ID, p => p.ApplicationId);
                if (category == null)
                    return HttpStatusCode.BadRequest;

                var existingCategory = playlistCategoryManager.GetCategory(id);

                category.ID = existingCategory.ID;
                category.ApplicationId = CurrentApplication.ID;

                category = playlistCategoryManager.SaveCategory(category);
                return Response.AsJson(category);
            };
            Delete["DeletePlaylistCategory", "/{countryCode}/playlistcategories/{id}"] = parameters =>
            {
                int id;
                if (!int.TryParse((string)parameters.id, out id))
                    return HttpStatusCode.BadRequest;

                var existingCategory = playlistCategoryManager.GetCategory(id);
                if (existingCategory == null)
                    return HttpStatusCode.NotFound;

                playlistCategoryManager.DeleteCategory(existingCategory);
                return HttpStatusCode.OK;
            };

            Put["SetIconForPlaylistCategory", "/{countryCode}/playlistcategories/{id}/icon"] = parameters =>
            {
                int id;
                if (!int.TryParse((string)parameters.id, out id))
                    return HttpStatusCode.BadRequest;

                var existingCategory = playlistCategoryManager.GetCategory(id);
                if (existingCategory == null)
                    return HttpStatusCode.NotFound;

                var category = playlistCategoryManager.SetIcon(existingCategory, Request.Body);
                return Response.AsJson(category);
            };
            Get["GetCategoriesForPlaylist", "/{countryCode}/editorialPlaylist/{id}/categories", true] = async (parameters, cx) =>
            {
                int playlistId;
                if (!int.TryParse((string)parameters.id, out playlistId))
                    return HttpStatusCode.BadRequest;

                var playlist = await editorialPlaylistManager.GetEditorialPlaylistAsync(playlistId);
                if (playlist == null)
                    return HttpStatusCode.BadRequest;

                var categories = playlistCategoryManager.GetCategories(playlist);

                return Response.AsJson(categories);
            };
            //POST adds categories
            Post["AddCategoriesForPlaylist", "/{countryCode}/editorialPlaylist/{id}/categories", true ] = async (parameters, cx) =>
            {
                int playlistId;
                if (!int.TryParse((string)parameters.id, out playlistId))
                    return HttpStatusCode.BadRequest;

                var playlistCategoryPostObject = this.Bind<PlaylistCategoryPostObject>();
                if (playlistCategoryPostObject == null)
                    return HttpStatusCode.BadRequest;

                var categoriesToAdd = playlistCategoryPostObject.Ids.Select(id => playlistCategoryManager.GetCategory(int.Parse(id))).ToList();

                var playlist = await editorialPlaylistManager.GetEditorialPlaylistAsync(playlistId);
                if (playlist == null)
                    return HttpStatusCode.BadRequest;

                var existingCategories = playlistCategoryManager.GetCategories(playlist);
                var categories = categoriesToAdd.Union(existingCategories).ToList();
                playlistCategoryManager.SetCategories(playlist, categoriesToAdd);

                return Response.AsJson(categories);
            };
            //PUT sets categories
            Put["SetCategoriesForPlaylist", "/{countryCode}/editorialPlaylist/{id}/categories", true] = async (parameters, cx) =>
            {
                int playlistId;
                if (!int.TryParse((string) parameters.id, out playlistId))
                    return HttpStatusCode.BadRequest;

                var playlistCategoryPostObject = this.Bind<PlaylistCategoryPostObject>();
                if (playlistCategoryPostObject == null)
                    return HttpStatusCode.BadRequest;

                var realPlaylistCategories = playlistCategoryPostObject.Ids.Select(id => playlistCategoryManager.GetCategory(int.Parse(id))).ToList();

                var playlist = await editorialPlaylistManager.GetEditorialPlaylistAsync(playlistId);
                if (playlist == null)
                    return HttpStatusCode.BadRequest;

                playlistCategoryManager.SetCategories(playlist, realPlaylistCategories);
                
                return Response.AsJson(realPlaylistCategories);
            };
        }
        private EditorialPlaylistViewModel BuildPlaylistViewModel(EditorialPlaylistWithStats playlistStat)
        {
            var viewModel = Mapper.Map<EditorialPlaylistViewModel>(playlistStat.Playlist);
            viewModel.Subscribers = playlistStat.LatestSubscribers;
            viewModel.PreviousSubscribers = playlistStat.SecondLatestSubscribers;
            //viewModel.SubscribersTrend = playlistStat.Stats;
            return viewModel;
        }
    }

    public class PlaylistCategoryPostObject
    {
        public List<string> Ids { get; set; }
    }
}