using System.Collections.Generic;
using System.Linq;
using Nancy;
using Sony.Filtr.AdminAPI.Config;
using Sony.Filtr.Applications;
using Sony.Filtr.Contracts.Definitions;
using Sony.Filtr.Core.SonyMusic;
using Sony.Filtr.Utility.Extensions;

namespace Sony.Filtr.AdminAPI.Modules.SonyTracks
{
    public class SonyTracksModule : BaseModule
    {
        public SonyTracksModule(SonyMusicManager sonyMusicManager, ApplicationInstanceManager applicationInstanceManager)
            : base(applicationInstanceManager)
        {
            Get["IsAlbumSony", "/sonyAlbums/IsSony", true] = async (parameters, ct) =>
            {
                var market = (string)Request.Query.market;
                if (string.IsNullOrWhiteSpace(market))
                    market = (string)Request.Query.region;

                var upcString = (string)Request.Query.upc;
                if (string.IsNullOrWhiteSpace(upcString))
                {
                    throw new NancyStatusException(HttpStatusCode.BadRequest, "Missing upc");
                }

                var upcs = upcString.Split(',').Select(upc=> upc).Where(u=> !string.IsNullOrWhiteSpace(u)).ToList();
                if (!upcs.Any())
                {
                    throw new NancyStatusException(HttpStatusCode.BadRequest, "Missing or invalid upc");
                }

                //var sonyAlbumUpcs = await sonyMusicManager.IsSonyAlbumAsync(upcs, market);
                var sonyAlbumUpcs = await sonyMusicManager.GetSonyAlbumAsync(upcs, MusicService.Spotify,  market);

                var viewModels = upcs.Select(upc => BuildIsSonyAlbumViewModel(upc, sonyAlbumUpcs, market)).ToList();

                return Response.AsJson(viewModels);
            };
            
            Get["GetISRCOverrides", "/sonyTracks/IsrcOverrides/", true] = async (parameters, ct) =>
            {
                var overrides = await sonyMusicManager.GetIsSonyOverridesAsync();

                return Response.AsJson(overrides);
            };

            Post["SetISRCoverride", "/sonyTracks/IsrcOverrides/{isrc}/", true] = async (parameters, ct) =>
            {
                var isrc = (string)parameters.isrc;

                var countryCodeString = (string)Request.Query.countryCodes;

                var setGlobal = (bool?)Request.Query.setGlobal;
                var isSony = (bool)Request.Query.isSony;

                if (!setGlobal.HasValue && string.IsNullOrWhiteSpace(countryCodeString))
                {
                    if (string.IsNullOrWhiteSpace(countryCodeString))
                    {
                        throw new NancyStatusException(HttpStatusCode.BadRequest, "Missing country code parameter");
                    }
                }

                if (!string.IsNullOrWhiteSpace(countryCodeString))
                {
                    var countryCodes = countryCodeString.Split(',').Select(cc => cc).Where(cc => !string.IsNullOrWhiteSpace(cc)).ToList();

                    if (countryCodes.Any())
                    {
                        await sonyMusicManager.SetIsSonyOverrideIsrcAsync(isrc, isSony, countryCodes);
                    }
                }

                if(setGlobal.HasValue && setGlobal.Value)
                {
                    await sonyMusicManager.SetGlobalIsSonyOverrideIsrcAsync(isrc, isSony);
                }
                
                return HttpStatusCode.Accepted;
            };

            Delete["RemoveISRCoverride", "/sonyTracks/IsrcOverrides/{isrc}/", true] = async (parameters, ct) =>
            {
                var isrc = (string)parameters.isrc;

                var countryCodeString = (string)Request.Query.countryCodes;

                var removeAll = (bool?)Request.Query.removeAll;

                if (removeAll.HasValue && removeAll.Value)
                {
                    await sonyMusicManager.RemoveAllIsSonyOverridesForIsrcAsync(isrc);
                    return HttpStatusCode.Accepted;
                }

                var removeGlobal = (bool?)Request.Query.removeGlobal;

                if (!removeGlobal.HasValue && string.IsNullOrWhiteSpace(countryCodeString))
                {
                    if (string.IsNullOrWhiteSpace(countryCodeString))
                    {
                        throw new NancyStatusException(HttpStatusCode.BadRequest, "countryCode or removeGlobal parameter is required.");
                    }
                }

                if (!string.IsNullOrWhiteSpace(countryCodeString))
                {
                    var countryCodes = countryCodeString.Split(',').Select(cc => cc).Where(cc => !string.IsNullOrWhiteSpace(cc)).ToList();

                    if (countryCodes.Any())
                    {
                        await sonyMusicManager.RemoveIsSonyOverrideAsync(isrc, countryCodes);
                    }
                }

                if (removeGlobal.HasValue && removeGlobal.Value)
                {
                    await sonyMusicManager.RemoveGlobalIsSonyOverrideAsync(isrc);
                }

                return HttpStatusCode.Accepted;
            };
        }

        private static IsSonyAlbumViewModel BuildIsSonyAlbumViewModel(string upc, Dictionary<string, SpotifyAnalyticsAccount> sonyAlbumUpcs, string market)
        {
            var sonyAlbum = sonyAlbumUpcs.GetValueOrNull(upc);
            var isSony = sonyAlbum == SpotifyAnalyticsAccount.Sony;
            return new IsSonyAlbumViewModel()
            {
                Upc = upc,
                IsSony = isSony,
                Market = market,
                SonyRelease = sonyAlbum,
            };
        }

        public class IsSonyAlbumViewModel
        {
            public string Upc { get; set; }

            public bool IsSony { get; set; }

            public string Market { get; set; }

            public SpotifyAnalyticsAccount? SonyRelease { get; set; }
        }
    }
}