using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using Amazon;
using Amazon.S3;
using Amazon.S3.Transfer;
using MoreLinq;
using MySql.Data.MySqlClient;
using Newtonsoft.Json;
using Newtonsoft.Json.Serialization;
using NLog;
using Sony.Filtr.Buzz;
using Sony.Filtr.Contracts.Definitions;
using Sony.Filtr.Contracts.Entities;
using Sony.Filtr.Core.EditorialPlaylists;
using Sony.Filtr.Database;
using Sony.Filtr.Utility.Extensions;

namespace Sony.Filtr.Tasks.Tasks
{

    public class UploadPlaylistsAndUsers : IScheduledTask
    {
        private readonly EditorialPlaylistManager _editorialPlaylistManager;
        private readonly BuzzAccountManager _buzzAccountManager;
        private readonly Logger _logger;
        private readonly S3BucketReference _bucketReference;

        //private readonly string accessKey = "***REMOVED***";
        //private readonly string secretKey = "***REMOVED***";
        //private readonly string bucketName = "sme.ca.prod.smanalytics.partners/sme-imis/in";

        public UploadPlaylistsAndUsers(EditorialPlaylistManager editorialPlaylistManager, BuzzAccountManager buzzAccountManager, S3BucketReference bucketReference)
        {
            _editorialPlaylistManager = editorialPlaylistManager;
            _buzzAccountManager = buzzAccountManager;
            _bucketReference = bucketReference;

            _logger = NLog.LogManager.GetLogger("UploadPlaylistsAndUsers");
        }

        public async Task<ScheduledTaskLog> ExecuteAsync(Guid scheduledTaskLogId)
        {
            var playlistJson = await GetAllPlaylistsJsonAsync();
            var usersJson = await GetBuzzUsersJsonAsync();

            var dir = Path.Combine(Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location), "filtrexport");
            var playlistsFileName = $"PlaylistsExport-{DateTime.Today.ToString("d", CultureInfo.GetCultureInfo("sv-SE"))}.json";
            var buzzUsersFileName = $"AllSpotifyBuzzUsers-{DateTime.Today.ToString("d", CultureInfo.GetCultureInfo("sv-SE"))}.json";

            var playlistFilePath = Path.Combine(dir, playlistsFileName);
            var buzzUsersFilePath = Path.Combine(dir, buzzUsersFileName);

            if (!new DirectoryInfo(dir).Exists)
            {
                Directory.CreateDirectory(dir);
            }

            var playlistFile = await WriteToFileAsync(playlistFilePath, playlistJson);
            var usersFile = await WriteToFileAsync(buzzUsersFilePath, usersJson);

            var s3Client = new AmazonS3Client(_bucketReference.AccessKey, _bucketReference.SecretKey, RegionEndpoint.USEast1);

            var transferUtility = new TransferUtility(s3Client);

            await transferUtility.UploadAsync(new TransferUtilityUploadRequest()
            {
                BucketName = _bucketReference.Bucket + "/" + _bucketReference.BucketPath,
                FilePath = playlistFile.FullName,
                Key = $"AllSpotifyPlaylistExport.json",
                CannedACL = S3CannedACL.BucketOwnerFullControl,
            });

            await transferUtility.UploadAsync(new TransferUtilityUploadRequest()
            {
                BucketName = _bucketReference.Bucket + "/" + _bucketReference.BucketPath,
                FilePath = usersFile.FullName,
                Key = $"AllSpotifyBuzzUsers.json",
                CannedACL = S3CannedACL.BucketOwnerFullControl,
            });

            playlistFile.Delete();
            usersFile.Delete();

            _logger.Info("Done!");
            return null;
        }



        private static async Task<FileInfo> WriteToFileAsync(string filePath, string json)
        {
            var file = new FileInfo(filePath);
            if (file.Exists)
            {
                file.Delete();
            }

            using(var saveFile = File.Open(filePath, FileMode.OpenOrCreate))
            {
                using(var fileWriter = new StreamWriter(saveFile))
                {
                    await fileWriter.WriteAsync(json);
                }
            }

            return file;
        }

        private async Task<string> GetBuzzUsersJsonAsync()
        {
            var buzzCategories = _buzzAccountManager.GetBuzzCategories().ToDictionary(c => c.ID, c => c.Name);

            var buzzUsers = await _buzzAccountManager.GetBuzzUsersAsync();
            var buzzViewModels = buzzUsers.DistinctBy(u => new { u.Username, u.ServiceType }).Select(p => new CustomUserViewModel()
            {
                Username = p.Username,
                DisplayName = p.DisplayName,
                BuzzCategory = p.BuzzCategoryId.HasValue && buzzCategories.ContainsKey(p.BuzzCategoryId.Value) ? buzzCategories[p.BuzzCategoryId.Value] : null,
                Country = p.CountryCode
            });

            var json = JsonConvert.SerializeObject(buzzViewModels, new JsonSerializerSettings()
            {
                ContractResolver = new CamelCasePropertyNamesContractResolver(),
                Formatting = Formatting.Indented
            });

            _logger.Info("Got {0} users.", buzzViewModels.Count());

            return json;
        }

        private async Task<string> GetAllPlaylistsJsonAsync()
        {
            List<CustomPlaylistViewModel> playlists = new List<CustomPlaylistViewModel>();
            using (var conn = await DatabaseHandler.GetOpenReadOnlyConnectionAsync())
            {
                var sql = "SELECT p.playlistUri, p.name, pf.followers " +
                          "FROM tblSpotifyPlaylist AS p " +
                          "LEFT JOIN tblPlaylistIgnoredPlaylist AS ip ON p.playlistUri=ip.playlistId AND ip.MusicServiceId=@spotifyServiceId " +
                          "LEFT JOIN tblSpotifyPlaylistFollowers AS pf ON pf.playlistId = p.playlistId " +
                          "WHERE p.removed = 0 AND ip.playlistId IS NULL " +
                          "ORDER BY p.playlistUri";

                var cmd = new MySqlCommand(sql, conn);
                cmd.Parameters.AddWithValue("@spotifyServiceId", MusicService.Spotify);

                using (var reader = await cmd.ExecuteReaderAsync())
                {
                    while (await reader.ReadAsync())
                    {
                        var playlistUri = reader.GetString("playlistUri");
                        var name = reader.GetString("name");
                        var followers = reader.GetLongOrFallback("followers", 0);

                        playlists.Add(new CustomPlaylistViewModel() { Uri = playlistUri, PlaylistDisplayName = name, Followers = followers });
                    }
                }
            }
            
            var json = JsonConvert.SerializeObject(playlists, new JsonSerializerSettings()
            {
                ContractResolver = new CamelCasePropertyNamesContractResolver(),
                Formatting = Formatting.Indented
            });

            _logger.Info("Got {0} playlists.", playlists.Count);

            return json;
        }

        private class CustomPlaylistViewModel
        {
            public string Uri { get; set; }

            public string PlaylistDisplayName { get; set; }

            public long Followers { get; set; }
        }

        private class CustomUserViewModel
        {
            public string Username { get; set; }

            public string DisplayName { get; set; }

            public string BuzzCategory { get; set; }

            public string Country { get; set; }
        }
    }
}