using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Threading.Tasks;
using System.Web.Http;
using Sony.ChartBot.Entities.Storage;
using Sony.ChartBot.Helpers;
using Sony.ChartBot.Messages.Helpers;
using Sony.ChartBot.Repository;
using Sony.ChartBot.Tasks;
using StructureMap.Diagnostics;

namespace Sony.ChartBot.Client.Controllers
{
    [RoutePrefix("debug")]
    public class DebugController : ApiController
    {
        private readonly SubscriptionRepository _subscriptionRepository;
        private readonly CountryRepository _countryRepository;

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

        [Route("duesubscriptions")]
        [HttpGet]
        public async Task<IHttpActionResult> GetDueSubscriptionsAsync(int? matchHourUtc)
        {
            var subscriptions = await _subscriptionRepository.GetDueSubscriptionsAsync(matchHourUtc);

            return Ok(subscriptions);
        }

        [Route("sendduesubscriptions")]
        [HttpGet]
        public async Task<IHttpActionResult> SendDueSubscriptionsAsync(int? matchHourUtc)
        {
            var subscriptions = await _subscriptionRepository.GetDueSubscriptionsAsync(matchHourUtc);

            var task = new SendChartMessagesToSubscribersTask();
            task.SubscriptionRepository = new SubscriptionRepositoryMock(subscriptions);
            await task.ExecuteAsync();

            return Ok(subscriptions);
        }

        [Route("subscriptions")]
        [HttpGet]
        public async Task<IHttpActionResult> GetAllSubscriptionsAsync()
        {
            var subscriptions = await _subscriptionRepository.GetSubscriptionsAsync();

            return Ok(subscriptions);
        }

        [Route("trackreference")]
        [HttpGet]
        public IHttpActionResult ParseTrackReference(string trackReference)
        {
            string artistName, countryCode, trackName;
            new TrackReferenceGenerator().TryParseTrackReference(trackReference, out artistName, out countryCode,
                out trackName);

            return Ok(new
            {
                artistName,
                countryCode,
                trackName
            });
        }

        [Route("defaultcountry")]
        [HttpGet]
        public async Task<IHttpActionResult> GetDefaultCountriesAsync()
        {
            var settings = await _countryRepository.GetCountrySettingsAsync();

            return Ok(settings);
        }

        [Route("setdefaultcountry")]
        [HttpGet]
        public async Task<IHttpActionResult> SetDefaultCountriesAsync(string userId, string country, int timeZoneDiff)
        {
            var supportedCountry = _countryRepository.GetSupportedCountry(country);
            await _countryRepository.SetDefaultCountryAsync(userId, supportedCountry, timeZoneDiff);

            return Ok();
        }

        public class SubscriptionRepositoryMock : SubscriptionRepository
        {
            private readonly IEnumerable<SubscriptionRecord> _dueSubscriptions;

            public SubscriptionRepositoryMock(IEnumerable<SubscriptionRecord> dueSubscriptions)
            {
                _dueSubscriptions = dueSubscriptions;
            }

            public override Task<IEnumerable<SubscriptionRecord>> GetDueSubscriptionsAsync(int? matchHourUtc = null)
            {
                return Task.FromResult(_dueSubscriptions);
            }
        }
    }
}