using MySql.Data.MySqlClient;
using PetaPoco.Business;
using Sony.Filtr.Contracts.Entities;
using Sony.Filtr.Database;
using Sony.Filtr.NewMusicFriday.Caching;
using Sony.Filtr.NewMusicFriday.Caching.Models;
using Sony.Filtr.Utility.Extensions;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace Sony.Filtr.NewMusicFriday
{
    public class NewMusicFridayManager
    {
        private readonly NewMusicFridayFactory _nmfFactory;
        private readonly NewMusicFridayCacheProvider _cacheProvider;

        public NewMusicFridayManager(NewMusicFridayFactory nmfFactory, NewMusicFridayCacheProvider cacheProvider)
        {
            _nmfFactory = nmfFactory;
            _cacheProvider = cacheProvider;
        }

        public SpotifyNewMusicFridayPlaylistTrack GetMostRecentSpotifyTrackForFriday(DateTime utcFriday, string playlistId)
        {
            return PetaPocoRepository.ReadOnlyInstance.FirstOrDefaultWithSql<SpotifyNewMusicFridayPlaylistTrack>("WHERE Added IS NOT NULL AND Date=@0 AND playlistId=@1 ORDER BY Added DESC", utcFriday.Date, playlistId);
        }

        public SpotifyNewMusicFridayPlaylist AddPlaylist(SpotifyNewMusicFridayPlaylist playlist)
        {
            playlist = _nmfFactory.AddPlaylist(playlist);
            _cacheProvider.SetPlaylistReferences(_nmfFactory.GetPlaylists().ToDictionary(k => k.PlaylistId, v => v.Market));

            return playlist;
        }

        public async Task<IList<DateTime>> GetAvailableFridays()
        {
            var dates = new List<DateTime>();
            var sql = "SELECT DISTINCT Date FROM tblSpotifyNewMusicFridayPlaylistTrack ORDER BY Date DESC";

            using (var conn = await DatabaseHandler.GetOpenReadOnlyConnectionAsync())
            using (var command = new MySqlCommand(sql, conn))
            using (var reader = await command.ExecuteReaderAsync())
            {
                while (reader.Read())
                {
                    dates.Add(reader.GetDateTime("Date"));
                }
            }

            return dates;
        }

        public DateTime GetPrecedingFriday(DateTime utcDate)
        {
            do
            {
                utcDate = utcDate.AddDays(-1);
            } while(utcDate.DayOfWeek != DayOfWeek.Friday);

            return utcDate;
        }

        public DateTime GetPrecedingOrCurrentFriday(DateTime utcDate)
        {
            while (utcDate.DayOfWeek != DayOfWeek.Friday)
            {
                utcDate = utcDate.AddDays(-1);
            }

            return utcDate.Date;
        }

        public DateTime GetNextOrCurrentFriday(DateTime utcDate)
        {
            while (utcDate.DayOfWeek != DayOfWeek.Friday)
            {
                utcDate = utcDate.AddDays(1);
            }

            return utcDate.Date;
        }

        public DateTime GetLogicalFridayForImport(DateTime utcDate)
        {
            if (utcDate.DayOfWeek == DayOfWeek.Thursday)
                return GetNextOrCurrentFriday(utcDate);

            return GetPrecedingOrCurrentFriday(utcDate);
        }

        public bool IsTrackListChanged(IList<SpotifyNewMusicFridayPlaylistTrack> existingTracklist, IList<SpotifyNewMusicFridayPlaylistTrack> newTracks)
        {
            if (existingTracklist.Count != newTracks.Count)
                return true;

            existingTracklist = existingTracklist.OrderBy(x => x.PlaylistIndex).ToList();
            newTracks = newTracks.OrderBy(x => x.PlaylistIndex).ToList();

            for (int playlistIndex = 0; playlistIndex < existingTracklist.Count; playlistIndex++)
            {
                var oldTrack = existingTracklist[playlistIndex];
                var newTrack = newTracks[playlistIndex];
                if (oldTrack.TrackId != newTrack.TrackId || oldTrack.Added != newTrack.Added)
                    return true;
            }

            return false;
        }

        public async Task<IDictionary<string, List<NewMusicFridayPlaylistTrackCacheModel>>> GetTracklists(IEnumerable<string> playlistIds, DateTime date)
        {
            var playlistCollections = new ConcurrentDictionary<string, List<NewMusicFridayPlaylistTrackCacheModel>>();

            await playlistIds.ForEachAsync(20, async playlistId =>
            {
                var tracks = await GetPlaylistTracksAsync(playlistId, date);

                playlistCollections.TryAdd(playlistId, tracks);
            });

            return playlistCollections;
        }

        private async Task<List<NewMusicFridayPlaylistTrackCacheModel>> GetPlaylistTracksAsync(string playlistId, DateTime date)
        {
            var playlistCollection = _cacheProvider.GetPlaylistCollection(playlistId, date);
            if (playlistCollection == null)
            {
                playlistCollection = await _nmfFactory.GetPlaylistTracksAsync(playlistId, date);
                _cacheProvider.SetPlaylistCollection(playlistId, date, playlistCollection);
            }

            return playlistCollection;
        }

        public IDictionary<string, string> GetPlaylistReferenceCacheItems()
        {
            var playlistReferences = _cacheProvider.GetPlaylistReferences();
            if (playlistReferences == null)
            {
                playlistReferences = PetaPocoRepository.ReadOnlyInstance.Fetch<SpotifyNewMusicFridayPlaylist>().ToDictionary(k => k.PlaylistId, v => v.Market);
                _cacheProvider.SetPlaylistReferences(playlistReferences);
            }
            return playlistReferences;
        }
    }
}