using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using MoreLinq;
using Sony.Filtr.Contracts.Entities;
using Sony.Filtr.Core.EditorialPlaylists;
using Sony.Filtr.Core.SpotifyBrowse;
using Sony.Filtr.Utility.Extensions;

namespace Sony.Filtr.Worker.Onetime
{
    public class ExportBrowseDataForPlaylists
    {
        private readonly SpotifyBrowseManager _spotifyBrowseManager;
        private readonly EditorialPlaylistManager _editorialPlaylistManager;
        private readonly EditorialPlaylistStatsManager _editorialPlaylistStatsManager;

        public ExportBrowseDataForPlaylists(SpotifyBrowseManager spotifyBrowseManager, EditorialPlaylistManager editorialPlaylistManager, EditorialPlaylistStatsManager editorialPlaylistStatsManager)
        {
            _spotifyBrowseManager = spotifyBrowseManager;
            _editorialPlaylistManager = editorialPlaylistManager;
            _editorialPlaylistStatsManager = editorialPlaylistStatsManager;
        }

        public async Task ExecuteAsync()
        {
            var file = new FileInfo("AllFiltrPlaylistInTop1000.csv");
            List<string> playlists = new List<string>();
            using(var textStream = file.OpenText())
            {
                while (!textStream.EndOfStream)
                {
                    playlists.Add(textStream.ReadLine());
                }
            }

            var startDate = new DateTime(2016, 4, 1);
            var endDate = new DateTime(2016, 6, 30);

            var browseData = await _spotifyBrowseManager.GetSpotifyBrowsePlaylistsAsync(playlists, startDate, endDate);
            var spotifyBrowseCategoryStatItems = browseData.DistinctBy(k=> new { k.Date, k.PlaylistUri}).ToDictionary(k => new MultiValueKey<DateTime, string>(k.Date, k.PlaylistUri), v => v);
            
            var playlistStats = _editorialPlaylistStatsManager.GetPlaylistStats(playlists.Select(p => new SpotifyLink(p)).ToList(), startDate, endDate);
            List<string> output = new List<string>();
            foreach (var playlist in playlists)
            {
                foreach(var date in GetDates(startDate, endDate))
                {
                    var key = new MultiValueKey<DateTime, string>(date, playlist);

                    var browseDataForPlaylistAndDay = spotifyBrowseCategoryStatItems.GetValueOrDefault(key);

                    var followerStatForPlaylistAndDay = playlistStats.FirstOrDefault(p => p.SpotifyUri == playlist && p.Date == date);
                    output.Add($"{playlist};{date.ToShortDateString()};{browseDataForPlaylistAndDay?.Position};{followerStatForPlaylistAndDay?.Subscribers}");
                }
            }

        }

        private IEnumerable<DateTime> GetDates(DateTime startDate, DateTime endDate)
        {
            if (endDate < startDate)
                throw new ArgumentException("endDate must be greater than or equal to startDate");

            while (startDate <= endDate)
            {
                yield return startDate;
                startDate = startDate.AddDays(1);
            }
        }
    }

    struct MultiValueKey<T, TU>
    {
        public readonly T Dimension1;
        public readonly TU Dimension2;
        public MultiValueKey(T p1, TU p2)
        {
            Dimension1 = p1;
            Dimension2 = p2;
        }
        // Equals and GetHashCode ommitted
    }
}