using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Sony.ChartBot.Entities;
using Sony.ChartBot.Entities.ChartApi;
using Sony.ChartBot.Entities.Storage;
using Sony.ChartBot.Repository;

namespace Sony.ChartBot.Helpers
{
    public class ChartTrackModelBuilder
    {
        private readonly CountryRepository _countryRepository;
        private readonly SubscriptionRepository _subscriptionRepository;

        public ChartTrackModelBuilder(
            CountryRepository countryRepository,
            SubscriptionRepository subscriptionRepository)
        {
            _countryRepository = countryRepository;
            _subscriptionRepository = subscriptionRepository;
        }

        public async Task<ChartTrackModel> BuildModel(string trackReference, string userId,
            bool includeSubscriptionStatus = false, bool? subscriptionStatusDefault = null)
        {
            var userSubscriptions = includeSubscriptionStatus ? await _subscriptionRepository.GetSubscriptionsAsync(userId) : null;

            string artistName, trackName, countryCode;
            if (!new TrackReferenceGenerator().TryParseTrackReference(trackReference,
                out artistName,
                out trackName,
                out countryCode))
            {
                throw new Exception($"Invalid track reference: {trackReference}");
            }

            var country = _countryRepository.GetSupportedCountry(countryCode);
            if (country == null)
            {
                throw new Exception($"Invalid track reference: Invalid country {countryCode}");
            }

            return new ChartTrackModel
            {
                ArtistName = artistName,
                Country = country,
                TrackName = trackName,
                TrackReference = trackReference,
                CurrentUserIsSubscribing = includeSubscriptionStatus
                    ? IsSubscribing(trackReference, userSubscriptions)
                    : subscriptionStatusDefault
            };
        }


        public async Task<IEnumerable<ChartTrackModel>> BuildModels(ChartResponse chartResponse, SupportedCountry country, string userId, 
            bool includeSubscriptionStatus = false, bool? subscriptionStatusDefault = null)
        {
            var userSubscriptions = includeSubscriptionStatus ? await _subscriptionRepository.GetSubscriptionsAsync(userId) : null;

            if (!chartResponse.Tracks.Any())
            {
                return new[]
                {
                    new ChartTrackModel
                    {
                        ArtistName = chartResponse.Artist.Name,
                        ArtistArtworkUrl = chartResponse.Artist.ArtworkUrl,
                        Country = country,
                        Charts = chartResponse.Charts,
                    }
                };
            }

            return chartResponse.Tracks.Select(t =>
            {
                var trackReference = new TrackReferenceGenerator().BuildTrackReference(
                    chartResponse.Artist.Name,
                    t.Name,
                    country.CountryCode);

                return new ChartTrackModel
                {
                    ArtistName = chartResponse.Artist.Name,
                    ArtistArtworkUrl = chartResponse.Artist.ArtworkUrl,
                    Country = country,
                    TrackName = t.Name,
                    TrackArtworkUrl = t.ArtworkUrl,
                    TrackReference = trackReference,
                    Positions = t.Positions,
                    Charts = chartResponse.Charts,
                    CurrentUserIsSubscribing = includeSubscriptionStatus
                        ? IsSubscribing(trackReference, userSubscriptions)
                        : subscriptionStatusDefault
                };
            });
        }

        private bool IsSubscribing(string trackReference, IEnumerable<SubscriptionRecord> subscriptions)
        {
            return subscriptions.Any(s => s.TrackReference == trackReference);
        }
    }
}