using gehGassi.Core.Interfaces;
using gehGassi.Domain.Common;
using gehGassi.Domain.Favourites;
using gehGassi.Domain.Messages;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Metadata.Internal;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using gehGassi.Dto.Messages;
using gehGassi.Domain.Dogs;
using static System.Runtime.InteropServices.JavaScript.JSType;

namespace gehGassi.Core.Services
{
    /// <summary>
    /// Service der die Verwaltung von Systemnachrichten ermöglicht
    /// </summary>
    public class SystemMessageService : ServiceBase<SystemMessage>, ISystemMessageService
    {
        private readonly IRepository<SystemMessageToSend> _toSendRepository;

        /// <summary>
        /// Erstellt eine Instanz
        /// </summary>
        /// <param name="unitOfWork">Instanz eines IUnitOfWork</param>
        public SystemMessageService(IUnitOfWork unitOfWork) : base(unitOfWork)
        {
            _toSendRepository = unitOfWork.GetRepository<SystemMessageToSend>();
        }

        /// <summary>
        /// Erstellen einer Systemnachrichten
        /// </summary>
        /// <returns>Systemnachricht</returns>
        public SystemMessage Create()
        {
            var item = new SystemMessage()
            {
                Id = Guid.NewGuid().ToString("N"),
                Created = DateTimeOffset.UtcNow,
                Read = false,
                ReadDate = null
            };
            return item;
        }

        /// <summary>
        /// Erstellen einer Systemnachrichten
        /// </summary>
        /// <param name="appUserId">Id des AppUsers</param>
        /// <param name="appUserType">Typ des App-Users</param>
        /// <param name="key">Id des verknüpften Objekts</param>
        /// <param name="table">Typ des verknüpften Objekts</param>
        /// <param name="type">Typ der Systemnachricht</param>
        /// <returns>Systemnachricht</returns>
        public SystemMessage Create(string appUserId, AppUserType appUserType, string key, string table, SystemMessageType type)
        {
            var item = new SystemMessage()
            {
                Id = Guid.NewGuid().ToString("N"),
                Created = DateTimeOffset.UtcNow,
                AppUserId = appUserId,
                AppUserType = appUserType,
                Key = key,
                Table = table,
                Type = type,
                Read = false,
                ReadDate = null
            };
            return item;
        }

        /// <summary>
        /// Gibt eine Liste der Systemnachrichten eines Benutzers zurück
        /// </summary>
        /// <param name="appUserId">Id des AppUsers</param>
        /// <param name="lastUpdate">Letztes Update</param>
        /// <returns>Liste der Systemnachricht</returns>
        public async Task<List<SystemMessage>> GetForSyncAppAsync(string appUserId, DateTimeOffset? lastUpdate)
        {
            var query = Repository.Query(c => c.AppUserId == appUserId);

            if (lastUpdate.HasValue)
                query = query.Where(c => c.UpdatedAt > lastUpdate);

            return await query.ToListAsync().ConfigureAwait(false);
        }

        /// <summary>
        /// Berstätigen des Erhaltes von SystemNachrichten für einen Benutzer. Alle die älter als das UpdateDatum sind werden gelöscht
        /// </summary>
        /// <param name="senderId">Id des Users - wird als Receiver gesucht</param>
        /// <param name="lastUpdate">Letztes Update</param>
        /// <param name="userName">Benutzer der die Änderung vornimmt</param>
        /// <returns>true wenn erfolgreich, false sonst</returns>
        public async Task<bool> ConfirmAsync(string senderId, DateTimeOffset lastUpdate, string userName)
        {
            var query = Repository.Query(c => c.AppUserId == senderId && c.UpdatedAt <= lastUpdate);
            var list = await query.ToListAsync().ConfigureAwait(false);

            if (list.Any())
            {
                Repository.RemoveRange(list);
                await CommitAsync(userName).ConfigureAwait(false);
            }

            return true;
        }

        /// <summary>
        /// Entfernen von Systemnachrichten für einen Benutzer wenn diese in der App schon gesehen wurden
        /// </summary>
        /// <param name="appUserId">Id des AppUsers</param>
        /// <param name="appUserType">Typ des App-Users</param>
        /// <param name="key">Id des verknüpften Objekts</param>
        /// <param name="table">Typ des verknüpften Objekts</param>
        /// <param name="created">Datum  - das created Datum der Systemnachricht muss kleiner gleich sein</param>
        /// <param name="userName">Benutzer der die Änderung vornimmt</param>
        /// <returns>Systemnachricht</returns>
        public async Task<bool> RemoveAsync(string appUserId, AppUserType appUserType, string key, string table, DateTimeOffset? created, string userName)
        {
            var query = Repository.Query(c => c.AppUserId == appUserId && c.AppUserType == appUserType && c.Key == key && c.Table == table && c.Created <= created.Value);
            var list = await query.ToListAsync().ConfigureAwait(false);

            if (list.Any())
            {
                Repository.RemoveRange(list);
                await CommitAsync(userName).ConfigureAwait(false);
            }

            return true;
        }

        /// <summary>
        /// Hinzufügen eines Systemnachricht
        /// </summary>
        /// <param name="appUserId">Id des Ziels</param>
        /// <param name="appUserType">Typ des App-Users</param>
        /// <param name="key">Id des Objekts</param>
        /// <param name="table">Objekttyp</param>
        /// <param name="type">Nachrichten-Typ</param>
        /// <param name="expires">Ablaufdatum</param>
        /// <returns>Task</returns>
        public void Add(string appUserId, AppUserType appUserType, string key, string table, SystemMessageType type, DateTimeOffset expires)
        {
            var systemMessage = Create(appUserId, appUserType, key, table, type);
            systemMessage.Expires = expires;
            Repository.Add(systemMessage);
        }

        /// <summary>
        /// Hinzufügen einer Systemnachricht als Text. Setzt den Typen automatisch
        /// </summary>
        /// <param name="appUserId">Id des Ziels</param>
        /// <param name="appUserType">Typ des App-Users</param>
        /// <param name="key">Id des Objekts</param>
        /// <param name="expires">Ablaufdatum</param>
        /// <param name="message">Nachricht</param>
        /// <returns>Task</returns>
        public void Add(string appUserId, AppUserType appUserType, string key, DateTimeOffset expires, string message)
        {
            var systemMessage = Create();
            systemMessage.AppUserId = appUserId;
            systemMessage.AppUserType = appUserType;
            systemMessage.Key = key;
            systemMessage.Table = SystemMessageTables.Message;
            systemMessage.Expires = expires;
            systemMessage.Type = SystemMessageType.Text;
            systemMessage.Message = message;
            Repository.Add(systemMessage);
        }

        /// <summary>
        /// Löschen abgelaufener Nachrichten
        /// </summary>
        /// <param name="date">Grenzdatum für Expired</param>
        /// <returns>Anzahl gelöschte Nachrichten</returns>
        public async Task<int> RemoveExpiredAsync(DateTimeOffset date)
        {
            var expiredMessages = await Repository.FindAsync(c => c.Expires < date).ConfigureAwait(false);
            foreach (var expiredMessage in expiredMessages)
            {
                Repository.Remove(expiredMessage);
            }
            return expiredMessages.Count();
        }

        /// <summary>
        /// Alle Systemnachrichten eines AppUsers löschen
        /// </summary>
        /// <param name="appUserId">Id des AppUsers</param>
        /// <returns>Anzahl gelöscht</returns>
        public async Task<int> DeleteAllForAppUserAsync(string appUserId)
        {
			var messages = await Repository.FindAsync(c => c.AppUserId == appUserId).ConfigureAwait(false);
			foreach (var message in messages)
			{
				Repository.Remove(message);
			}
			return messages.Count();
		}

        /// <summary>
        /// Erstellen einer Systemnachrichten die gesendet werden sollen
        /// </summary>
        /// <returns>Systemnachricht die gesendet werden soll</returns>
        public SystemMessageToSend CreateToSend()
        {
            var item = new SystemMessageToSend()
            {
                Created = DateTimeOffset.UtcNow,
                AppUserCount = 0,
                SentCount = 0,
                HasBeenSent = false,
                SentDate = null,
                SentBy = string.Empty
            };
            return item;
        }


        #region SystemMessagesToSend

        /// <summary>
        /// Gibt eine gefilterte Liste von Systemnachrichten die gesendet werden sollen
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <returns>List betroffener Systemnachrichten die gesendet werden sollen</returns>
        public IQueryable<SystemMessageToSend> FilterSystemMessagesToSend(string filter)
        {
            return _toSendRepository.Query(c => c.Title.Contains(filter));
        }

        /// <summary>
        /// Hinzufügen einer Systemnachricht die gesendet werden soll
        /// </summary>
        /// <param name="item">SystemMessageToSend</param>
        public void AddToSend(SystemMessageToSend item)
        {
            _toSendRepository.Add(item);
        }

        /// <summary>
        /// Löschen einer Systemnachricht die gesendet werden soll
        /// </summary>
        /// <param name="item">SystemMessageToSend</param>
        public void RemoveToSend(SystemMessageToSend item)
        {
            _toSendRepository.Remove(item);
        }

        /// <summary>
        /// Gibt eine Systemnachricht die gesendet werden soll zurück
        /// </summary>
        /// <param name="id">Id der Systemnachricht</param>
        /// <returns>SystemMessageToSend oder null, wenn nicht gefunden</returns>
        public async Task<SystemMessageToSend> GetToSendAsync(long id)
        {
            return await _toSendRepository.GetAsync(id).ConfigureAwait(false);
        }

        /// <summary>
        /// Gibt eine Liste von Systemnachrichten die gesendet werden sollen zurück.
        /// Bereits gesendete oder Nachrichten die kein Versanddatum haben werden nicht zurückgegeben
        /// </summary>
        /// <param name="date">Datum das größer als das Versanddatum sein muss</param>
        /// <returns>Liste Nachrichten zu senden</returns>
        public async Task<List<SystemMessageToSend>> GetToSendAsync(DateTimeOffset date)
        {
            var list = await _toSendRepository.FindAsync(c => c.SentDate != null && c.HasBeenSent == false && c.ToSendDate <= date).ConfigureAwait(false);
            return list.ToList();
        }

        #endregion
    }
}