using System;
using System.Collections.Generic;
using System.Data.Common;
using System.Linq;
using System.Threading.Tasks;
using MoreLinq;
using Sony.Filtr.Applications;
using Sony.Filtr.Contracts.Entities.Buzz;
using Sony.Filtr.Core.Buzz;
using Sony.Filtr.Database;
using Sony.Filtr.SpotifyWebAPI;
using Sony.Filtr.SpotifyWebAPI.Model;

namespace Sony.Filtr.Tasks.Tasks
{
    public class TempSpotifyUserCategorization : IScheduledTask
    {
        private readonly BuzzManager _buzzManager;
        private readonly SpotifyWebApi _spotifyWebApi;
        private readonly ApplicationInstanceManager _applicationInstanceManager;

        public TempSpotifyUserCategorization(BuzzManager buzzManager, SpotifyWebApi spotifyWebApi, ApplicationInstanceManager applicationInstanceManager)
        {
            _buzzManager = buzzManager;
            _spotifyWebApi = spotifyWebApi;
            _applicationInstanceManager = applicationInstanceManager;
        }

        public void ImportUsersFromCategorization()
        {
            List<string> usernames = new List<string>();
            using (DbConnection conn = DatabaseHandler.GetOpenConnection())
            {
                var cmd = conn.CreateCommand();
                cmd.CommandText = "SELECT Username FROM TempBuzzUsersCategorized WHERE Category = 'Tastemaker' AND Username < 'a'";

                var reader = cmd.ExecuteReader();
                while (reader.Read())
                {
                    usernames.Add(reader.GetString(0));
                }

                conn.Close();
            }

            foreach (var username in usernames)
            {
                var buzzImportUser = new BuzzImportUser()
                {
                    ApplicationID = _applicationInstanceManager.GetFallbackApplication().ID,
                    CompanyName = "Tastemaker",
                    SpotifyUserName = username,
                };
                _buzzManager.SaveBuzzImportUser(buzzImportUser);
            }
        }

        public async Task<ScheduledTasksInfo> ExecuteAsync()
        {
            var usernames = GetTempSpotifyUsers().OrderByDescending(p=> p);
            var allBuzzUsers = _buzzManager.GetBuzzImportUsers();
            var allBuzzUsersHash = allBuzzUsers.Select(b => b.SpotifyUserName).ToHashSet();
            foreach (var username in usernames)
            {
                var localUsername = username;

                if (!allBuzzUsersHash.Contains(localUsername, StringComparer.InvariantCultureIgnoreCase))
                {
                    try
                    {
                        //Console.WriteLine("User not found in existing: {0}", localUsername);
                        var spotifyUser = await _spotifyWebApi.GetUserAsync(localUsername);
                        if (spotifyUser == null)
                        {
                            //Console.WriteLine("User not found on spotify");
                            continue;
                        }
                        Console.WriteLine("{0} has name {1} and {2} followers", localUsername, spotifyUser.display_name, spotifyUser.followers.total);
                        //Console.WriteLine("{0} has user type {1}", localUsername, spotifyUser.type);

                        var spotifyPlaylistsForUser = await _spotifyWebApi.GetAllPublicPlaylistsAsync(localUsername);

                        var ownPlaylists = spotifyPlaylistsForUser.Where(p => p.owner.id == localUsername).ToList();
                        List<PlaylistResponse> playlistResponses = new List<PlaylistResponse>();
                        foreach (var playlistItem in ownPlaylists.Where(p => p.id != null))
                        {
                            PlaylistResponse fullPlaylist = null;
                            try
                            {
                                fullPlaylist = await _spotifyWebApi.GetPlaylistAsync(playlistItem.owner.id, playlistItem.id);
                            }
                            catch (Exception)
                            {
                                Console.WriteLine("Could not get playlist for {0}", localUsername);
                            }


                            if (fullPlaylist != null)
                                playlistResponses.Add(fullPlaylist);
                        }

                        Console.WriteLine("{0} has {1} own playlists.", localUsername, ownPlaylists.Count);

                        var topPlaylist = playlistResponses.Where(p => p.followers != null).OrderByDescending(p => p.followers.total).FirstOrDefault();
                        if (topPlaylist != null)
                            Console.WriteLine("{0} The top playlist has {1} followers", localUsername, topPlaylist.followers.total);

                        var anyPlaylistHasOwnImage = ownPlaylists.Any(p => p.images.Where(i => i.url != null).Any(i => !i.url.Contains("mosaic")));
                        Console.WriteLine("{0} has playlists with image: {1}", localUsername, anyPlaylistHasOwnImage);
                        var averageFollowers = (playlistResponses.Any()) ? playlistResponses.Where(p=> p.followers.total.HasValue).Average(p => p.followers.total.Value) : 0;
                        var sumFollowers = (playlistResponses.Any()) ? playlistResponses.Where(p => p.followers.total.HasValue).Sum(p => p.followers.total.Value) : 0;
                        if (playlistResponses.Any())
                        {
                            Console.WriteLine("{0} Average playlist followers: {1}. Sum playlist followers: {2}", localUsername, averageFollowers, sumFollowers);
                        }

                        var topPlaylistFollowers = (topPlaylist != null && topPlaylist.followers.total.HasValue) ? topPlaylist.followers.total.Value : 0;

                        UpdateRow(localUsername, spotifyUser.display_name, spotifyUser.followers.total ?? 0, ownPlaylists.Count, topPlaylistFollowers, averageFollowers, sumFollowers, anyPlaylistHasOwnImage);
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine("error: {0}", ex);
                    }
                    
                }
                
            }
            Console.WriteLine("Done");
            return new ScheduledTasksInfo();
        }

        private void UpdateRow(string localUsername, string displayName, int total, int count, int topPlaylistFollowers, double averageFollowers, int sumFollowers, bool anyPlaylistHasOwnImage)
        {
            using (DbConnection conn = DatabaseHandler.GetOpenConnection())
            {
                var cmd = conn.CreateCommand();

                cmd.CommandText = "UPDATE TempBuzzUsers SET FullName=@FullName, Followers=@followers, Playlists=@playlists, " +
                                  "TopPlaylistFollowers=@TopPlaylistFollowers, AverageFollowers=@AverageFollowers, SumFollowers=@SumFollowers, HasPlaylistImage=@HasPlaylistImage, " +
                                  "Processed=1 " +
                                  "WHERE Username = @username";
                cmd.Parameters.AddWithValue("@FullName", displayName);
                cmd.Parameters.AddWithValue("@Followers", total);
                cmd.Parameters.AddWithValue("@Playlists", count);
                cmd.Parameters.AddWithValue("@TopPlaylistFollowers", topPlaylistFollowers);
                cmd.Parameters.AddWithValue("@AverageFollowers", (int)averageFollowers);
                cmd.Parameters.AddWithValue("@SumFollowers", sumFollowers);
                cmd.Parameters.AddWithValue("@HasPlaylistImage", anyPlaylistHasOwnImage);
                
                cmd.Parameters.AddWithValue("@username", localUsername);
                
                cmd.ExecuteNonQuery();

                conn.Close();
            }
        }

        private List<string> GetTempSpotifyUsers()
        {
            List<string> usernames = new List<string>();
            using (DbConnection conn = DatabaseHandler.GetOpenConnection())
            {
                var cmd = conn.CreateCommand();
                cmd.CommandText = "SELECT Username FROM TempBuzzUsers WHERE Processed = 0";

                var reader = cmd.ExecuteReader();
                while (reader.Read())
                {
                    usernames.Add(reader.GetString(0));
                }

                conn.Close();
            }
            return usernames;

        }
    }
}