using System;
using System.Collections.Generic;
using System.Linq;
using EchoNest;
using EchoNest.Artist;
using EchoNest.Song;
using MusicMatch.Core.Data;
using Sony.Core.Data;
using Spotifony.Core.Data;
using SearchArgument = EchoNest.Artist.SearchArgument;
using System.Threading.Tasks;

namespace Sony.Filtr.PlaylistGeneration.MusicInfoStore
{
    public class EchoNestManagerAsync : IMusicInfoStoreAsync
    {
        private readonly EchoNestSession _echoNestSession;
        public EchoNestManagerAsync(string apiKey)
        {
            _echoNestSession = new EchoNestSession(apiKey);
        }

        public async Task<Artist> GetArtistAsync(string artistName)
        {
            var artistSearch = _echoNestSession.Query<EchoNest.Artist.Search>();
            var searchParams = new SearchArgument()
                                   {
                                       Name = artistName,
                                       Results = 1
                                   };

            var resp = await artistSearch.ExecuteAsync(searchParams).ConfigureAwait(continueOnCapturedContext: false);

            Artist artist = null;
            if (resp.Status.Code == ResponseCode.Success)
            {
                if (resp.Artists.Count > 0)
                    artist = new Artist(resp.Artists[0].Name)
                    {
                        ImageUrl = null,
                        IsSonyArtist = false,
                        LastFMImageID = null,
                        Listeners = 0,
                    };
            }
            return artist;
        }

        public async Task<IEnumerable<GenreMatch>> GetGenreMatchesAsync(Artist artist)
        {
            var req = _echoNestSession.Query<Terms>();
            var resp = await req.ExecuteAsync(artist.Name, TermsSort.Frequency).ConfigureAwait(continueOnCapturedContext:false);

            IEnumerable<GenreMatch> genres = new List<GenreMatch>();
            if (resp.Status.Code == ResponseCode.Success)
            {
                genres = resp.Terms.Select(t => new GenreMatch(t.Name, (int)t.Weight * 100));
            }
            return genres;
        }

        public List<SimilarArtistMatch> GetSimilarArtists(string artistName)
        {
            var req = _echoNestSession.Query<EchoNest.Artist.SimilarArtists>();
            var parameters = new SimilarArtistsArgument()
                                 {
                                     Name = artistName,
                                     Bucket = ArtistBucket.IdFacebook,
                                     Results = 25,
                                 };
            var resp = req.Execute(parameters);
            List<SimilarArtistMatch> similarArtistMatches = new List<SimilarArtistMatch>();
            if (resp.Status.Code == ResponseCode.Success)
            {
                similarArtistMatches = resp.Artists.Select(a => new SimilarArtistMatch(new Artist(a.Name), 100)).ToList();
            }
            return similarArtistMatches;
        }

        public List<SimilarArtistMatch> GetSimilarArtistsByGenre(string name)
        {
            var test = _echoNestSession.Query<EchoNest.Artist.Search>();
            var genres = new TermList();
            genres.Add(name);
            var searchParams = new SearchArgument()
            {
                Styles = genres,
                Results = 25,
                Sort = Sorting.FamiliarityDesc,
            };

            var resp = test.Execute(searchParams);

            List<SimilarArtistMatch> similarArtistMatches = new List<SimilarArtistMatch>();
            if (resp.Status.Code == ResponseCode.Success)
            {
                if (resp.Artists.Count > 0)
                    similarArtistMatches = resp.Artists.Select(a => new SimilarArtistMatch(new Artist(a.Name), 100)).ToList();
            }
            return similarArtistMatches;
        }


        public List<RankedItem<Track>> SearchTracks(string mood, string style)
        {
            List<RankedItem<Track>> allTracks = new List<RankedItem<Track>>();

            int startFrom = 0;
            for (int i = 0; i < 10; i++)
            {
                var tracks = SearchTracks(mood, style, startFrom);
                startFrom = startFrom + 100;
                if (tracks != null)
                    allTracks.AddRange(tracks);
            }            
            return allTracks;
        }

        private List<RankedItem<Track>> SearchTracks(string mood, string style, int startFrom)
        {
            var query = _echoNestSession.Query<EchoNest.Song.Search>();

            var searchParams = new EchoNest.Song.SearchArgument();
            if (!string.IsNullOrEmpty(mood))
                searchParams.Moods.Add(mood);
            if (!string.IsNullOrEmpty(style))
                searchParams.Styles.Add(style);
            searchParams.Results = 100;
            searchParams.Bucket = SongBucket.Tracks | SongBucket.IdSpotify | SongBucket.SongHotttness;
            searchParams.Start = startFrom;
            searchParams.Limit = true;

            var resp = query.Execute(searchParams);
            if (resp.Status.Code == ResponseCode.Success)
            {
                if (resp.Songs.Count > 0)
                {
                    {
                        var list = resp.Songs.Select(s => BuildTrack(s)).Where(t => t != null).ToList();
                        return list;
                    }
                }
            }
            return null;
        }

        //public List<Track> SearchTracks(string mood, string style)
        //{
        //    var query = _echoNestSession.Query<EchoNest.Playlist.Static>();
        //    var args = new StaticArgument();
        //    args.Type = "artist-description";
        //    args.Styles.Add(style);
        //    args.Moods.Add(mood);
        //    args.Bucket = PlaylistBucket.Tracks | PlaylistBucket.IdSpotify;
        //    args.ArtistMinFamiliarity = 0.8;
        //    args.Results = 100;

        //    var playlistResponse = query.Execute(args);
        //    if (playlistResponse.Status.Code == ResponseCode.Success)
        //    {
        //        if (playlistResponse.Songs.Count > 0)
        //        {
        //            var tracks = playlistResponse.Songs.Select(s => BuildTrack(s)).Where(t => t != null).ToList();
        //            return tracks;
        //        }
        //    }
        //    return null;
        //}

        private RankedItem<Track> BuildTrack(SongBucketItem song)
        {
            var track = new Track(song.ArtistName, song.Title);
            var spotifyTrack = song.Tracks.FirstOrDefault(t=> t.Catalog == "spotify-WW");
            if (spotifyTrack != null)
            {
                var spotifyTrackUri = "spotify:track:" +
                                      spotifyTrack.ForeignID.Replace("spotify-WW:track:", string.Empty);
                
                track.SpotifyLink = new SpotifyLink(spotifyTrackUri);
                return new RankedItem<Track>(track, (int)(song.SongHotttnesss*100));
            }
            return null;
        }


        public List<Tag> GetTags(Track track)
        {
            throw new NotImplementedException();
        }

        public List<Tag> GetTags(Artist artist)
        {
            throw new NotImplementedException();
        }
    }
}