using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Web.Hosting;
using Amazon.IdentityManagement.Model;
using Sony.Filtr.Database;
using SpreadsheetLight;
using MySql.Data.MySqlClient;
using Sony.Filtr.DistributedCaching;

namespace Sony.Filtr.Core.InfluentialPlaylists
{
    public class InfluentialPlaylistsManager
    {
        private readonly InfluentialPlaylistsFactory _influentialPlaylistsFactory;
        private readonly DistributedCacheHandler _cacheHandler;

        private const string _cacheKeyMarkets = "InfluentialPlaylists_Markets";
        private const string _cacheKeyMarketDates = "InfluentialPlaylists_MarketDates";
        private const string _cacheKeyChart = "InfluentialPlaylists_Chart";


        public InfluentialPlaylistsManager(InfluentialPlaylistsFactory influentialPlaylistsFactory, DistributedCacheHandler cacheHandler)
        {
            _influentialPlaylistsFactory = influentialPlaylistsFactory;
            _cacheHandler = cacheHandler;
        }

        public void ImportPlaylistFile(Stream uploadedFileStream, int year, int month)
        {
            _influentialPlaylistsFactory.ImportPlaylistFile(uploadedFileStream, year, month);
        }

        public List<string> GetMarkets()
        {
            var chartMarkets = _cacheHandler.Get(_cacheKeyMarkets) as List<string>;

            if (chartMarkets == null)
            {
                chartMarkets = _influentialPlaylistsFactory.GetMarkets();
                _cacheHandler.Put(_cacheKeyMarkets, chartMarkets, DateTime.Now.AddDays(1));
            }

            return chartMarkets;
        }

        public List<TopPlaylistDate> GetMarketDates(string market)
        {
            var cacheKey = _cacheKeyMarketDates + "_" + market;

            var dates = _cacheHandler.Get(cacheKey) as List<TopPlaylistDate>;

            if (dates == null)
            {
                dates = _influentialPlaylistsFactory.GetMarketDates(market);
                _cacheHandler.Put(cacheKey, dates, DateTime.Now.AddDays(1));
            }

            return dates;
        }

        public List<PlaylistRankItem> GetChart(string market, TopPlaylistDate date)
        {
            var cacheKey = _cacheKeyChart + "_" + market + "_" + date.Year + "_" + date.Month;

            var chart = _cacheHandler.Get(cacheKey) as List<PlaylistRankItem>;

            if (chart == null)
            {
                chart = _influentialPlaylistsFactory.GetChart(market, date);
                _cacheHandler.Put(cacheKey, chart, DateTime.Now.AddDays(1));
            }

            return chart;
        }

        private TopPlaylistDate GetPreviousDate(List<TopPlaylistDate> playListChartDates, TopPlaylistDate latestDate)
        {
            if (!playListChartDates.Any()
                || !playListChartDates.Any(date => date.Year == latestDate.Year && date.Month == latestDate.Month)
                || playListChartDates.First().Year == latestDate.Year && playListChartDates.First().Month == latestDate.Month)
                return null;

            var currentIndex = playListChartDates.FindIndex(p => p.Year == latestDate.Year && p.Month == latestDate.Month);
            return playListChartDates[currentIndex - 1];
        }

        public List<PlaylistRankItem> GetPlaylistChartWithStats(string market, TopPlaylistDate selectedDate)
        {
            var chart = GetChart(market, selectedDate);

            var playListChartDates = GetMarketDates(market);

            var previousDate = GetPreviousDate(playListChartDates, selectedDate);

            if (previousDate != null)
            {
                var previousChart = GetChart(market, previousDate);

                if (previousChart != null && previousChart.Any())
                {
                    foreach (var chartItem in chart)
                    {
                        var previousChartItem = previousChart.FirstOrDefault(i => i.PlaylistUri == chartItem.PlaylistUri);

                        if (previousChartItem != null)
                        {
                            chartItem.New = false;
                            chartItem.Move = previousChartItem.Rank - chartItem.Rank;
                        }
                        else
                        {
                            chartItem.New = true;
                        }
                    }

                    return chart;
                }

            }

            chart.ForEach(i =>
            {
                i.Move = 0;
                i.New = true;
            });

            return chart;
        } 

    }
}