using System;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using System.Threading;
using System.Threading.Tasks;
using Sony.Filtr.AdminAPI.ViewModels;
using Sony.Filtr.Buzz;
using Sony.Filtr.Contracts.Abstractions;
using Sony.Filtr.Contracts.Definitions;
using Sony.Filtr.Contracts.Entities;
using Sony.Filtr.Core.EditorialPlaylists;
using Sony.Filtr.Core.Factory;
using Sony.Filtr.Core.SpotifyUserCountries;
using Sony.Filtr.ErrorLogging;
using Sony.Filtr.Tasks.Tasks;
using Sony.Filtr.Utility.Extensions;

namespace Sony.Filtr.AdminAPI.BusinessLogic
{
    public class EditorialPlaylistBusinessLogic
    {
        private readonly EditorialPlaylistManager _editorialPlaylistManager;
        private readonly UpdatePlaylistInfoTask _updatePlaylistInfoTask;
        private readonly ISearchManager _searchManager;
        private readonly PlaylistCategoryManager _playlistCategoryManager;
        private readonly SpotifyUserCountryManager _spotifyUserCountryManager;
        private readonly BuzzAccountManager _buzzAccountManager;
        public ImageFactory ImageFactory { get; set; }

        public EditorialPlaylistBusinessLogic(ImageFactory imageFactory, EditorialPlaylistManager editorialPlaylistManager,
            UpdatePlaylistInfoTask updatePlaylistInfoTask, ISearchManager searchManager, PlaylistCategoryManager playlistCategoryManager, SpotifyUserCountryManager spotifyUserCountryManager,
            BuzzAccountManager buzzAccountManager)
        {
            _editorialPlaylistManager = editorialPlaylistManager;
            _updatePlaylistInfoTask = updatePlaylistInfoTask;
            _searchManager = searchManager;
            _playlistCategoryManager = playlistCategoryManager;
            _spotifyUserCountryManager = spotifyUserCountryManager;
            _buzzAccountManager = buzzAccountManager;
            ImageFactory = imageFactory;
        }

        public async Task<EditorialPlaylist> SavePlaylistAsync(Application application, int? playListId, EditorialPlaylistViewModel playlistViewModel)
        {
            var spotifyLink = new SpotifyLink(playlistViewModel.SpotifyLink);
            EditorialPlaylist playlist;
            if (playListId.HasValue)
            {
                playlist = await _editorialPlaylistManager.GetEditorialPlaylistAsync(playListId.Value);
            }
            else
            {
                //Dupe-check. If playlists with same 
                playlist = await _editorialPlaylistManager.GetEditorialPlaylistAsync(application, spotifyLink);
                if (playlist == null)
                {
                    playlist = new EditorialPlaylist();
                }
            }

            playlist.ApplicationID = application.ID;
            playlist.Priority = playlistViewModel.Priority;
            playlist.PriorityLevel = playlistViewModel.PriorityLevel;
            playlist.SpotifyLink = spotifyLink;
            playlist.Active = playlistViewModel.Active;

            playlist.Name = playlistViewModel.Name;
            playlist.SpotifyDescription = playlistViewModel.SpotifyDescription;
            playlist.Description = playlistViewModel.Description;
            playlist.BackgroundColor = playlistViewModel.BackgroundColor;
            playlist.HeaderBackgroundColor = playlistViewModel.HeaderBackgroundColor;
            playlist.AccentColor = playlistViewModel.AccentColor;
            playlist.TextColor = playlistViewModel.TextColor;
            playlist.ThemeActive = playlistViewModel.ThemeActive;
            playlist.DisplayName = playlistViewModel.DisplayName;
            playlist.OwnerUsername = playlistViewModel.OwnerUsername;
            playlist.SonyCreated = true;

            var username = playlistViewModel.OwnerUsername;
            var buzzUser = await _buzzAccountManager.GetBuzzUserAsync(username, ServiceType.Spotify);
            if (buzzUser != null)
            {
                playlist.BuzzCategoryId = buzzUser.BuzzCategoryId;
                playlist.CountryCode = buzzUser.CountryCode;
            }

            if (string.IsNullOrWhiteSpace(playlist.CountryCode))
            {
                var userCountry = _spotifyUserCountryManager.GetSpotifyUserCountry(username);
                if (userCountry != null && !string.IsNullOrWhiteSpace(userCountry.CountryCode))
                    playlist.CountryCode = userCountry.CountryCode;
            }
            

            playlist = await _editorialPlaylistManager.SaveEditorialPlaylistAsync(playlist);

            //ThreadPool.QueueUserWorkItem(async state =>
            //{
            //    try
            //    {
            //        var playlistAttributes = await _editorialPlaylistManager.GetPlaylistAttributesAsync(playlist.AsEnumerable());
            //        var playlistCategories = await _playlistCategoryManager.GetCategoriesAsync(playlist.AsEnumerable());

            //        await _searchManager.IndexPlaylistsAsync(playlistAttributes, playlistCategories);

            //        var newlyAdded = !playListId.HasValue;
            //        if (newlyAdded)
            //        {
            //            await _updatePlaylistInfoTask.ExecuteCertainPlaylistAsync(new[] {playlist.SpotifyLink.Uri});
            //        }
            //    }
            //    catch (Exception ex)
            //    {
            //        ErrorLoggingManager.Instance.LogError(ex);
            //    }
            //});

            return playlist;
        }

        //public EditorialPlaylist SavePlaylist(Application application, int? playListID, HttpPostedFileBase image, int priority, bool? status, SpotifyLink spotifyLink)
        //{
        //    EditorialPlaylist playlist;
        //    if (playListID.HasValue)
        //    {
        //        playlist = SonyMusicManager.EditorialPlaylistManager.GetEditorialPlaylist(playListID.Value);
        //    }
        //    else
        //    {
        //        //Dupe-check. If playlists with same 
        //        playlist = SonyMusicManager.Instance.EditorialPlaylistManager.GetEditorialPlaylist(application, spotifyLink);
        //        if (playlist == null)
        //        {
        //            playlist = new EditorialPlaylist();
        //            playlist.Name = "-";
        //        }
        //    }

        //    playlist.ApplicationID = application.ID;
        //    playlist.Priority = priority;
        //    playlist.SpotifyLink = spotifyLink;
        //    playlist.Active = status.HasValue && status.Value;
        //    playlist.SonyCreated = true;

        //    playlist = SpotifyPlaylistUtility.AddCountryInfo(playlist);

        //    if (image != null && image.ContentLength != 0)
        //    {
        //        string fileName = playlist.ImageFileName;
        //        //if (!string.IsNullOrWhiteSpace(playlist.ImageFileName))
        //        //    ImageFactory.DeleteImage(playlist.ImageFileName);

        //        fileName = GenerateFileName(image.InputStream);
        //        ImageFactory.SaveResizedAndOrignalImage(fileName, image.InputStream);
        //        playlist.ImageFileName = fileName;
        //    }

        //    playlist = SonyMusicManager.EditorialPlaylistManager.SaveEditorialPlaylist(playlist);
        //    WorkerQueueHandler.AddTask(new WorkerTask(WorkType.UpdateEditorialPlaylist, playlist.ID.ToString()));
        //    return playlist;
        //}

        private string GenerateFileName(Stream imageStream)
        {
            string extension = ".png";
            using (Bitmap bitmap = new Bitmap(imageStream))
            {
                if (bitmap.RawFormat.Equals(ImageFormat.Jpeg))
                    extension = ".jpeg";
                else if (bitmap.RawFormat.Equals(ImageFormat.Png))
                    extension = ".png";
                else if (bitmap.RawFormat.Equals(ImageFormat.Gif))
                    extension = ".gif";
                else if (bitmap.RawFormat.Equals(ImageFormat.Bmp))
                    extension = ".bmp";
            }
            return Guid.NewGuid() + extension;
        }

        public async Task<EditorialPlaylist> SetImageAsync(EditorialPlaylist playlist, Stream requestStream)
        {
            //string fileName = playlist.ImageFileName;
            //if (!string.IsNullOrWhiteSpace(fileName))
            //    ImageFactory.DeleteImage(fileName);

            var fileName = GenerateFileName(requestStream);
            ImageFactory.SaveResizedAndOrignalImage(fileName, requestStream);
            playlist.ImageFileName = fileName;

            playlist = await _editorialPlaylistManager.SaveEditorialPlaylistAsync(playlist);

            return playlist;
        }

        public async Task<EditorialPlaylist> SetHeaderImageAsync(EditorialPlaylist playlist, Stream requestStream)
        {
            //if (!string.IsNullOrWhiteSpace(playlist.ImageFileName))
            //    ImageFactory.DeleteImage(playlist.ImageFileName);

            var fileName = GenerateFileName(requestStream);
            ImageFactory.SaveImageAsync(fileName, requestStream).Wait();
            playlist.HeaderImageUrl = fileName;

            playlist = await _editorialPlaylistManager.SaveEditorialPlaylistAsync(playlist);

            return playlist;
        }

        internal async Task<EditorialPlaylist> RemoveHeaderImageAsync(EditorialPlaylist playlist)
        {
            playlist.HeaderImageUrl = null;

            playlist = await _editorialPlaylistManager.SaveEditorialPlaylistAsync(playlist);

            return playlist;
        }
    }
}