using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using NLog;
using Sony.Filtr.Contracts.Abstractions;
using Sony.Filtr.Contracts.Entities;
using Sony.Filtr.PlaylistSynchronization.Data;
using Sony.Filtr.SoundCloud;
using Sony.Filtr.SoundCloud.Model;
using Sony.Filtr.Utility;
using Track = Sony.Filtr.SoundCloud.Model.Track;

namespace Sony.Filtr.PlaylistSynchronization.Synchronizer
{
    public class SoundCloudSynchronizer : SynchronizerBase
    {
        private readonly IServiceAccountManager _serviceAccountManager;
        private Logger _logger;

        public SoundCloudSynchronizer(IServiceAccountManager serviceAccountManager)
        {
            _serviceAccountManager = serviceAccountManager;
            _logger = LogManager.GetLogger("PlaylistSynchronization");
        }

        protected override async Task<PlaylistSynchronizationResult> CopyToPlaylistInternalAsync(GenericPlaylist genericPlaylist, Data.PlaylistSynchronization playlistSynchronization, ServiceAccount serviceAccount)
        {
            var soundCloudApi = new SoundCloudApi(serviceAccount, _serviceAccountManager);
         
            PlaylistResponse soundcloudPlaylist;
            var playlistId = Maybe.ToIntOrDefault(playlistSynchronization.ToPlaylistId);
            if (playlistSynchronization.ToPlaylistId.StartsWith("https://soundcloud.com"))
            {
                soundcloudPlaylist = await soundCloudApi.GetPlaylistAsync(playlistSynchronization.ToPlaylistId);
                playlistId = Convert.ToInt32(soundcloudPlaylist.id);
                _logger.Debug("SoundcloudSynchronizer for {0} to Soundcloud playlist: {1}", genericPlaylist.Name, playlistSynchronization.ToPlaylistId);
            }
            else if (playlistId.HasValue)
            {
                soundcloudPlaylist = await soundCloudApi.GetPlaylistAsync(playlistId.Value);
                _logger.Debug("SoundcloudSynchronizer for {0} to Soundcloud playlist: {1}", genericPlaylist.Name, playlistSynchronization.ToPlaylistId);                    
            }
            else
            {
                throw new PlaylistSynchronizationException($"Could not parse toPlaylistId in Soundcloud-Sync. '{playlistSynchronization.ToPlaylistId}'", SyncError.VendorSpecific);
            }

            if (soundcloudPlaylist == null)
            {
                throw new PlaylistSynchronizationException($"Could not find playlist with id {playlistSynchronization.ToPlaylistId}", SyncError.NoTargetPlaylist);
            }

            SyncCounts counts = await AddSongsToPlaylist(genericPlaylist, soundCloudApi, soundcloudPlaylist.id);
            await SetPlaylistInfo(soundCloudApi, genericPlaylist, playlistSynchronization, playlistId.ToString());

            return PlaylistSynchronizationResult.FromSuccess(counts, genericPlaylist.Tracks.Count);
        }

        public async Task<SyncCounts> AddSongsToPlaylist(GenericPlaylist genericPlaylist, SoundCloudApi soundCloudApi, int playlistId)
        {
            List<Track> tracksToAdd = new List<Track>();

            if (genericPlaylist.Tracks.Any())
            {
                foreach (var track in genericPlaylist.Tracks)
                {
                    var matchedTracks = (await soundCloudApi.GetTrackAsync(track.Name, track.ISRC));
                    var trackWithCorrectIsrc = matchedTracks.Where(t=> !string.IsNullOrWhiteSpace(t.isrc) )
                        .FirstOrDefault(m => m.isrc.Equals(track.ISRC, StringComparison.InvariantCultureIgnoreCase));
                    if (trackWithCorrectIsrc != null)
                    {
                        tracksToAdd.Add(new SoundCloud.Model.Track() { id = trackWithCorrectIsrc.id, isrc = trackWithCorrectIsrc.isrc, title = string.Empty });
                    }
                    else
                    {
                        var matchedTrack = matchedTracks.FirstOrDefault();
                        if (matchedTrack != null)
                        {
                            tracksToAdd.Add(new SoundCloud.Model.Track() { id = matchedTrack.id, isrc = matchedTrack.isrc, title = string.Empty });
                        }
                    }
                    
                }
            }

            await soundCloudApi.AddTracksToPlayListAsync(playlistId, tracksToAdd);

            return new SyncCounts(tracksToAdd.Count, 0, 0);
        }


        public async Task SetPlaylistInfo(SoundCloudApi soundCloudApi, GenericPlaylist genericPlaylist, Data.PlaylistSynchronization playlistSynchronization, string playlistId)
        {
            const int maxCharsInDescription = 4000;
            const int maxCharsInTitle = 100;

            var playlistInfoRequest = new UpdatePlaylistInfoRequest() {playlist = new PlaylistInfo()};
        
            if (playlistSynchronization.TitleCopyMode != FieldCopyMode.NoUpdate)
            {
                if (playlistSynchronization.TitleCopyMode == FieldCopyMode.UseSetting)
                {
                    if (String.IsNullOrEmpty(playlistSynchronization.Title))
                    {
                        playlistInfoRequest.playlist.description = String.Empty;
                    }
                    else if (playlistSynchronization.Title.Length > maxCharsInTitle)
                    {
                        playlistInfoRequest.playlist.title = playlistSynchronization.Title.Substring(0, maxCharsInTitle);
                    }
                    else
                    {
                        playlistInfoRequest.playlist.title = playlistSynchronization.Title;
                    }
                }
                else if (playlistSynchronization.TitleCopyMode == FieldCopyMode.CopySource)
                {
                    if (String.IsNullOrEmpty(playlistSynchronization.Title))
                    {
                        playlistInfoRequest.playlist.description = String.Empty;
                    }
                    else if (genericPlaylist.Name.Length > maxCharsInTitle)
                    {
                        playlistInfoRequest.playlist.title = genericPlaylist.Name.Substring(0, maxCharsInTitle);
                    }
                    else
                    {
                        playlistInfoRequest.playlist.title = genericPlaylist.Name;
                    }
                }
            }

            if (playlistSynchronization.DescriptionCopyMode != FieldCopyMode.NoUpdate)
            {
                if (playlistSynchronization.DescriptionCopyMode == FieldCopyMode.UseSetting)
                {
                    if (String.IsNullOrEmpty(playlistSynchronization.Description))
                    {
                        playlistInfoRequest.playlist.description = String.Empty;
                    }
                    else if (playlistSynchronization.Description.Length > maxCharsInDescription)
                    {
                        playlistInfoRequest.playlist.description = playlistSynchronization.Description.Substring(0, maxCharsInDescription);
                    }
                    else
                    {
                        playlistInfoRequest.playlist.description = playlistSynchronization.Description;
                    }

                    playlistInfoRequest.playlist.description = playlistSynchronization.Description;
                }
                else if (playlistSynchronization.DescriptionCopyMode == FieldCopyMode.CopySource)
                {
                    if (String.IsNullOrEmpty(genericPlaylist.Description))
                    {
                        playlistInfoRequest.playlist.description = String.Empty;
                    }
                    else if(genericPlaylist.Description.Length > maxCharsInDescription)
                    {
                        playlistInfoRequest.playlist.description = genericPlaylist.Description.Substring(0, maxCharsInDescription);
                    }
                    else
                    {
                        playlistInfoRequest.playlist.description = genericPlaylist.Description;
                    }
                }
            }
            await soundCloudApi.UpdateTitleAndDescription(playlistId, playlistInfoRequest);
        }

    }
}