using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using MongoDB.Bson;
using MongoDB.Driver;
using MongoDB.Driver.Linq;
using Sony.ChartBot.Entities.Storage;

namespace Sony.ChartBot.Repository
{
    public class SubscriptionRepository : BaseRepository<SubscriptionRecord>
    {
        public SubscriptionRepository()
            : base(DbConstants.Database, DbConstants.SubscriptionCollection)
        {
            
        }

        public SubscriptionRepository(string database)
            : base(database, DbConstants.SubscriptionCollection)
        {
        }

        public virtual async Task AddSubscriptionAsync(string userId, string trackReference, int sendoutHourUtc = 7)
        {
            // Ignore if already exists
            var existing = await GetSubscriptionAsync(userId, trackReference);
            if (existing != null)
            {
                return;
            }

            await Collection.InsertOneAsync(new SubscriptionRecord
            {
                Id = ObjectId.GenerateNewId(),
                TrackReference = trackReference,
                UserId = userId,
                SendoutHourUtc = sendoutHourUtc
            });
        }

        public virtual async Task UpdateSubscriptionAsync(SubscriptionRecord subscription)
        {
            var filter = Builders<SubscriptionRecord>.Filter.Eq(nameof(SubscriptionRecord.Id), subscription.Id);
            await Collection.ReplaceOneAsync(filter, subscription);
        }

        public virtual async Task RemoveSubscriptionAsync(string userId, string trackReference)
        {
            var builder = Builders<SubscriptionRecord>.Filter;
            var filter =
                builder.Eq(nameof(SubscriptionRecord.TrackReference), trackReference) &
                builder.Eq(nameof(SubscriptionRecord.UserId), userId);

            await Collection.DeleteOneAsync(filter);
        }

        public virtual async Task<IEnumerable<SubscriptionRecord>> GetSubscriptionsAsync(string userId)
        {
            return await Collection.AsQueryable().Where(s => s.UserId == userId).ToListAsync();
        }

        public virtual async Task<SubscriptionRecord> GetSubscriptionAsync(string userId, string trackReference)
        {
            return await Collection.AsQueryable().SingleOrDefaultAsync(s =>
                s.UserId == userId &&
                s.TrackReference == trackReference);
        }

        public virtual async Task<IEnumerable<SubscriptionRecord>> GetSubscriptionsAsync()
        {
            return await Collection.AsQueryable().ToListAsync();
        }

        public virtual async Task<IEnumerable<SubscriptionRecord>> GetDueSubscriptionsAsync(int? matchHourUtc = null)
        {
            matchHourUtc = matchHourUtc ?? DateTime.UtcNow.Hour;

            if (DateTime.Now.IsDaylightSavingTime())
            {
                matchHourUtc = matchHourUtc + 1;
            }

            var currentDate = DateTime.Today;

            return await Collection.AsQueryable().Where(s =>
                s.SendoutHourUtc == matchHourUtc.Value &&
                (s.LatestSendoutDay == null ||
                 s.LatestSendoutDay.Value < currentDate)).ToListAsync();
        }
    }
}