using EchoNest;
using EchoNest.Artist;
using EchoNest.Song;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Sony.Filtr.Contracts.Entities;
using Sony.Filtr.Contracts.Entities.Genre;
using SearchArgument = EchoNest.Artist.SearchArgument;

namespace Sony.Filtr.PlaylistGeneration.MusicInfoStore
{
    public class EchoNestManager : IMusicInfoStore
    {
        private readonly EchoNestSession _echoNestSession;
        public readonly int CodeVersion = 1;

        public EchoNestManager(EchoNestSession echoNestSession)
        {
            _echoNestSession = echoNestSession;
        }

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

            var resp = await test.ExecuteAsync(searchParams);

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

        public async Task<List<SimilarArtistMatch>> GetSimilarArtistsAsync(string artistName)
        {
            var req = _echoNestSession.Query<EchoNest.Artist.SimilarArtists>();
            var parameters = new SimilarArtistsArgument()
                                 {
                                     Name = artistName,
                                     Bucket = ArtistBucket.IdFacebook,
                                     Results = 25,
                                 };
            var resp = await req.ExecuteAsync(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;
        }
        
        private ExtendedTrack BuildExtendedTrack(SongBucketItem song, DateTime fetchDateTime)
        {
            var track = new ExtendedTrack();
            track.FetchDate = fetchDateTime;
            track.FetchCodeVersion = CodeVersion;
            track.ArtistName = song.ArtistName;
            track.Title = song.Title;
            if (song.AudioSummary != null)
            { 
                track.Danceability = song.AudioSummary.Danceability;
                track.Energy = song.AudioSummary.Energy;
                track.Loudness = song.AudioSummary.Loudness;
                track.Mode = song.AudioSummary.Mode;
                track.Tempo = song.AudioSummary.Tempo;
            }
            track.Hotness = song.SongHotttnesss;
            track.ArtistFamiliarity = song.ArtistFamiliarity;
            track.ArtistHotnesss = song.ArtistHotttnesss;
            track.SongType = song.SongType;

            if (song.Tracks != null)
            { 
                foreach (var trackItem in song.Tracks.Where(t=> t.Catalog == "spotify"))
                {
                    var spotifyTrackUri = trackItem.ForeignID.Replace("spotify-WW:track:", "spotify:track:");
                    track.SpotifyLinks.Add(new SpotifyLink(spotifyTrackUri));
                }
                track.SpotifyLink = track.SpotifyLinks.FirstOrDefault();

                track.DeezerIds = song.Tracks.Where(t => t.Catalog == "deezer").Select(t => t.ForeignID.Replace("deezer:track:", string.Empty)).Select(t => long.Parse(t)).ToList();
                track.DeezerId = track.DeezerIds.FirstOrDefault();
                
                
                track.MBIDs = song.Tracks.Where(t => t.Catalog == "musicbrainz").Select(t => t.ForeignID.Replace("musicbrainz:track:", string.Empty)).ToList();
            }
            return track;
        }

        public async Task<List<ExtendedTrack>> GetEchoNestTracksBySpotifyTrackAsync(List<Track> tracks)
        {
            var query = _echoNestSession.Query<EchoNest.Song.Profile>();
            var trackIds = tracks.Select(t => GetEchoNestSpotifyTrackId(t.SpotifyLink));
            const SongBucket buckets = SongBucket.AudioSummary | SongBucket.Tracks | SongBucket.IdSpotify | SongBucket.SongHotttness | SongBucket.ArtistFamiliarity | SongBucket.ArtistHotttness | SongBucket.SongType;
            var echoNestTracks = await query.ExecuteAsync(trackIds, buckets);
            var fetchDate = DateTime.UtcNow;
            if (echoNestTracks != null && echoNestTracks.Songs != null)
            {
                return echoNestTracks.Songs.Select(t => BuildExtendedTrack(t, fetchDate)).ToList();
            }
            return new List<ExtendedTrack>();
        }

        public async Task<IEnumerable<ExtendedTrack>> GetEchoNestTracksByDeezerIdAsync(IEnumerable<long> deezerTrackIds)
        {
            var query = _echoNestSession.Query<EchoNest.Song.Profile>();
            var trackIds = deezerTrackIds.Select(t => GetEchoNestDeezerTrackId(t));
            const SongBucket buckets = SongBucket.AudioSummary | SongBucket.Tracks | SongBucket.IdSpotify | SongBucket.SongHotttness | SongBucket.ArtistFamiliarity | SongBucket.ArtistHotttness | SongBucket.SongType;
            var echoNestTracks = await query.ExecuteAsync(trackIds, buckets);
            var fetchDate = DateTime.UtcNow;
            if (echoNestTracks != null && echoNestTracks.Songs != null)
            {
                return echoNestTracks.Songs.Select(t => BuildExtendedTrack(t, fetchDate));
            }
            return new List<ExtendedTrack>();
        }

        public async Task<IEnumerable<ExtendedTrack>> GetEchoNestTracksByMbidAsync(IEnumerable<string> tracksMbids)
        {
            var query = _echoNestSession.Query<EchoNest.Song.Profile>();
            var trackIds = tracksMbids.Select(t => GetMusicBrainzTrackId(t)).Take(100);
            const SongBucket constantBuckets = SongBucket.AudioSummary | SongBucket.Tracks | SongBucket.IdMusicBrainz | SongBucket.SongHotttness | SongBucket.ArtistFamiliarity | SongBucket.ArtistHotttness | SongBucket.SongType;

            List<string> buckets = new List<string>();
            buckets.AddRange(constantBuckets.GetBucketDescriptions());
            buckets.Add("id:spotify");

            var echoNestTracks = await query.ExecuteAsync(trackIds, buckets);
            var fetchDate = DateTime.UtcNow;
            if (echoNestTracks != null && echoNestTracks.Songs != null)
            {
                return echoNestTracks.Songs.Select(t => BuildExtendedTrack(t, fetchDate));
            }
            return new List<ExtendedTrack>();
        }

        private IdSpace GetMusicBrainzTrackId(string trackId)
        {
            return new IdSpace(string.Format("musicbrainz:track:{0}", trackId));
        }
        
        
        private IdSpace GetEchoNestDeezerTrackId(long deezerTrackId)
        {
            return new IdSpace("deezer:track:" + deezerTrackId);
        }
        private IdSpace GetEchoNestSpotifyTrackId(SpotifyLink spotifyLink)
        {
            var uri = spotifyLink.Uri.Replace("spotify:track", "spotify-WW:track");
            return new IdSpace(uri);
        }
        
        public Task<List<Tag>> GetTagsAsync(Track track)
        {
            throw new NotImplementedException();
        }

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

        public List<RankedItem<Track>> GetTopTracksForTag(string tag)
        {
            throw new NotImplementedException();
        }

        public async Task<List<string>> GetTopHotttArtistsAsync(int? results)
        {
            var query = _echoNestSession.Query<TopHottt>();
            if (!results.HasValue)
                results = 15;

            var hotttArtists = await query.ExecuteAsync(results.Value);
            if (hotttArtists?.Artists != null)
                return hotttArtists.Artists.Select(a => a.Name).ToList();

            return new List<string>();
        }


        public List<Tag> GetRelatedTags(string tag)
        {
            throw new NotImplementedException();
        }

    }
}