using Sony.Filtr.Contracts.Entities;
using Sony.Filtr.Contracts.Entities.Buzz;
using Sony.Filtr.Core.EditorialPlaylists;
using Sony.Filtr.Database;
using Sony.Filtr.DistributedCaching;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace Sony.Filtr.Core.Buzz
{
    public class BuzzManager
    {
        private readonly BuzzFactory _buzzFactory;
        private readonly IEditorialPlaylistFactory _editorialPlaylistFactory;
        private readonly DistributedCacheHandler _cacheHandler;

        public BuzzManager(BuzzFactory buzzFactory, IEditorialPlaylistFactory editorialPlaylistFactory, DistributedCacheHandler cacheHandler)
        {
            _buzzFactory = buzzFactory;
            _editorialPlaylistFactory = editorialPlaylistFactory;
            _cacheHandler = cacheHandler;
        }

        public async Task<BuzzImportUser> GetBuzzImportUserByName(string username)
        {
            return await _buzzFactory.GetBuzzImportUserByName(username);
        }

        public async Task<List<BuzzImportUser>> GetBuzzImportUsersById(string ids)
        {
            return await _buzzFactory.GetBuzzImportUsersById(ids);
        }

        public List<BuzzImportUser> GetBuzzImportUsers(Application app)
        {
            return GetBuzzImportUsers().Where(u => app == null || u.ApplicationID == app.ID).ToList();
        }

        public List<BuzzImportUser> GetBuzzImportUsers()
        {
            var cacheKey = GetCacheKeyBuzzImportUsers();
            List<BuzzImportUser> buzzImportUsers = _cacheHandler.GetList<BuzzImportUser>(cacheKey) as List<BuzzImportUser>;
            if (buzzImportUsers == null)
            {
                buzzImportUsers = _buzzFactory.GetBuzzImportUsers();
                _cacheHandler.PutList(cacheKey, buzzImportUsers);
            }

            return buzzImportUsers;
        }

        public void SaveBuzzImportUser(BuzzImportUser user)
        {
            if (user.ID == default(int))
            {
                _buzzFactory.AddBuzzImportUser(user);
            }
            else
            {
                _buzzFactory.UpdateBuzzImportUser(user);
            }
            ClearBuzzImportUserCache();
        }

        public void DeleteBuzzImportUser(BuzzImportUser user)
        {
            _buzzFactory.DeleteBuzzImportUser(user);
            ClearBuzzImportUserCache();
        }

        public async Task<List<EditorialPlaylist>> GetEditorialPlaylistsAsync(IEnumerable<BuzzImportUser> importUsers)
        {
            List<EditorialPlaylist> playlists = new List<EditorialPlaylist>();

            foreach (var buzzImportUser in importUsers)
            {
                var userPlaylist = await GetEditorialPlaylistsAsync(buzzImportUser);
                playlists.AddRange(userPlaylist);
            }
            return playlists;
        }

        public async Task<List<EditorialPlaylist>> GetEditorialPlaylistsAsync(BuzzImportUser buzzImportUser)
        {
            var cacheKey = GetCacheKeyEditorialPlaylistsBuzzUser(buzzImportUser);
            var editorialPlaylists = _cacheHandler.Get(cacheKey) as List<EditorialPlaylist>;
            if (editorialPlaylists == null)
            {
                editorialPlaylists = await _editorialPlaylistFactory.GetEditorialPlaylistsAsync(buzzImportUser.SpotifyUserName, buzzImportUser.ApplicationID);
                _cacheHandler.Put(cacheKey, editorialPlaylists);
            }
            return editorialPlaylists;
        }

        private string GetCacheKeyBuzzImportUsers()
        {
            return "BuzzImportUsers-1.1-" + typeof(BuzzImportUser) + ":" + BuzzImportUser.Version;
        }

        private string GetCacheKeyEditorialPlaylistsBuzzUser(BuzzImportUser importUser)
        {
            return "EditorialPlaylistsBuzzUser-1.3:" + typeof(EditorialPlaylist) + ":" + EditorialPlaylist.Version + ":" + importUser.ApplicationID + ":" + importUser.SpotifyUserName;
        }

        private void ClearBuzzImportUserCache()
        {
            _cacheHandler.Remove(GetCacheKeyBuzzImportUsers());
        }

        public void ClearBuzzImportUserCache(BuzzImportUser user)
        {
            ClearBuzzImportUserCache();
            _cacheHandler.Remove(GetCacheKeyEditorialPlaylistsBuzzUser(user));
        }

        public Dictionary<BuzzCompany, int> GetTopBuzzCompanies()
        {
            var topCompaniesCacheKey = GetTopBuzzCompaniesCacheKey();
            var companies = _cacheHandler.Get(topCompaniesCacheKey) as Dictionary<BuzzCompany, int>;
            if (companies == null)
            {
                companies = _buzzFactory.GetTopBuzzCompanies();
                _cacheHandler.Put(topCompaniesCacheKey, companies, DateTime.Now.AddHours(12));
            }
            return companies;
        }

        public void ClearTopBuzzCompaniesCache()
        {
            _cacheHandler.Remove(GetTopBuzzCompaniesCacheKey());
        }

        public async Task SetSaveTracklistForUserPlaylists(string userName, bool saveTracklist)
        {
            using (var connection = await DatabaseHandler.GetOpenConnectionAsync())
            {
                string sql = "UPDATE tblSpotifyPlaylist SET SaveTracklist = @saveTracklist WHERE User = @user;";

                using (var command = connection.CreateCommand())
                {
                    command.CommandText = sql;
                    command.Parameters.AddWithValue("@user", userName);
                    command.Parameters.AddWithValue("@saveTracklist", saveTracklist);

                    await command.ExecuteNonQueryAsync();
                }
            }
        }

        private string GetTopBuzzCompaniesCacheKey()
        {
            return "TopBuzzCompanies-1.0:" + typeof(BuzzCompany);
        }
    }
}