using gehGassiApp.Core.Data;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;
using gehGassiApp.Core.Interfaces;

namespace gehGassiApp.Core.Services
{
    /// <summary>
    /// Abstrakte Implementation des Service Interface als Basis für spezialisierte Klassen
    /// </summary>
    /// <typeparam name="T">Typ der Klasse</typeparam>
    public abstract class ServiceBase<T> : IDisposable, IService<T> where T : class
    {
        private readonly IUnitOfWork _unitOfWork;
        private bool _disposed = false;
        internal readonly IRepository<T> Repository;

        /// <summary>
        /// Erstellt eine Instanz
        /// </summary>
        /// <param name="unitOfWork">Instanz eines IUnitOfWork</param>
        protected ServiceBase(IUnitOfWork unitOfWork)
        {
            _unitOfWork = unitOfWork;
            Repository = _unitOfWork.GetRepository<T>();
        }

        #region Get

        /// <summary>
        /// Gibt eine Entität anhand der eindeutigen Id zurück
        /// </summary>
        /// <param name="id">Id der Entität</param>
        /// <param name="noTracking">Gibt an ob NoTRacking verwendet werden soll. Es werden keine Entitäten im EF-Speicher gehalten</param>
        /// <returns>Entität oder null, wenn nicht gefunden</returns>
        public abstract T Get(object id, bool noTracking = true);

        /// <summary>
        /// Gibt eine Entität anhand der eindeutigen Id zurück
        /// </summary>
        /// <param name="id">Id der Entität</param>
        /// <param name="noTracking">Gibt an ob NoTRacking verwendet werden soll. Es werden keine Entitäten im EF-Speicher gehalten</param>
        /// <returns>Entität oder null, wenn nicht gefunden</returns>
        public abstract Task<T> GetAsync(object id, bool noTracking = true);

        /// <summary>
        /// Gibt alle Entitäten zurück
        /// </summary>
        /// <param name="noTracking">Gibt an ob NoTRacking verwendet werden soll. Es werden keine Entitäten im EF-Speicher gehalten</param>
        /// <returns>Liste aller Entitäten</returns>
        public virtual IEnumerable<T> GetAll(bool noTracking = true)
        {
            return Repository.GetAll(noTracking);
        }

        /// <summary>
        /// Gibt alle Entitäten zurück
        /// </summary>
        /// <param name="noTracking">Gibt an ob NoTRacking verwendet werden soll. Es werden keine Entitäten im EF-Speicher gehalten</param>
        /// <returns>Liste aller Entitäten</returns>
        public virtual async Task<IEnumerable<T>> GetAllAsync(bool noTracking = true)
        {
            return await Repository.GetAllAsync(noTracking).ConfigureAwait(false);
        }

        /// <summary>
        /// Gibt eine Liste aller Entitäten zurück welche definierten Kriterien entsprechen
        /// </summary>
        /// <param name="predicate">Kriterien</param>
        /// <param name="noTracking">Gibt an ob NoTRacking verwendet werden soll. Es werden keine Entitäten im EF-Speicher gehalten</param>
        /// <returns>Liste gefundener Entitäten</returns>
        public virtual IEnumerable<T> Find(Expression<Func<T, bool>> predicate, bool noTracking = true)
        {
            if (predicate == null)
                throw new ArgumentNullException(nameof(predicate));
            return Repository.Find(predicate, noTracking);
        }

        /// <summary>
        /// Gibt eine Liste aller Entitäten zurück welche definierten Kriterien entsprechen
        /// </summary>
        /// <param name="predicate">Kriterien</param>
        /// <param name="noTracking">Gibt an ob NoTRacking verwendet werden soll. Es werden keine Entitäten im EF-Speicher gehalten</param>
        /// <returns>Liste gefundener Entitäten</returns>
        public virtual async Task<IEnumerable<T>> FindAsync(Expression<Func<T, bool>> predicate, bool noTracking = true)
        {
            if (predicate == null)
                throw new ArgumentNullException(nameof(predicate));
            return await Repository.FindAsync(predicate, noTracking).ConfigureAwait(false);
        }

        /// <summary>
        /// Gibt eine Liste aller Entitäten zurück welche definierten Kriterien entsprechen
        /// </summary>
        /// <param name="predicate">Kriterien</param>
        /// <param name="noTracking">Gibt an ob NoTRacking verwendet werden soll. Es werden keine Entitäten im EF-Speicher gehalten</param>
        /// <returns>Liste gefundener Entitäten</returns>
        public IQueryable<T> Query(Expression<Func<T, bool>> predicate, bool noTracking = true)
        {
            if (predicate == null)
                throw new ArgumentNullException(nameof(predicate));
            return Repository.Query(predicate, noTracking);
        }

        /// <summary>
        /// Gibt eine Entität oder den Default wert zurück
        /// </summary>
        /// <param name="predicate">Kriterien</param>
        /// <param name="noTracking">Gibt an ob NoTRacking verwendet werden soll. Es werden keine Entitäten im EF-Speicher gehalten</param>
        /// <returns>Gefundene entität oder Default-Wert</returns>
        public virtual T SingleOrDefault(Expression<Func<T, bool>> predicate, bool noTracking = true)
        {
            if (predicate == null)
                throw new ArgumentNullException(nameof(predicate));
            return Repository.SingleOrDefault(predicate, noTracking);
        }

        /// <summary>
        /// Gibt eine Entität oder den Default wert zurück
        /// </summary>
        /// <param name="predicate">Kriterien</param>
        /// <param name="noTracking">Gibt an ob NoTRacking verwendet werden soll. Es werden keine Entitäten im EF-Speicher gehalten</param>
        /// <returns>Gefundene entität oder Default-Wert</returns>
        public virtual async Task<T> SingleOrDefaultAsync(Expression<Func<T, bool>> predicate, bool noTracking = true)
        {
            if (predicate == null)
                throw new ArgumentNullException(nameof(predicate));
            return await Repository.SingleOrDefaultAsync(predicate, noTracking).ConfigureAwait(false);
        }

        #endregion

        #region CRUD

        /// <summary>
        /// Fügt eine Entität zum Repository hinzu
        /// </summary>
        /// <param name="entity">Entität</param>
        public virtual void Add(T entity)
        {
            if (entity == null)
                throw new ArgumentNullException(nameof(entity));
            Repository.Add(entity);
        }

        /// <summary>
        /// Fügt eine Liste von Entitäten zum Repository hinzu
        /// </summary>
        /// <param name="entities">List von Entitäten</param>
        public virtual void AddRange(IEnumerable<T> entities)
        {
            if (entities == null)
                throw new ArgumentNullException(nameof(entities));
            Repository.AddRange(entities);
        }

        /// <summary>
        /// Entfernt eine Entität aus dem Repository
        /// </summary>
        /// <param name="entity">Zu entfernende Entität</param>
        public virtual void Remove(T entity)
        {
            if (entity == null)
                throw new ArgumentNullException(nameof(entity));
            Repository.Remove(entity);
        }

        /// <summary>
        /// Entfernt eine Liste von Entitäten aus dem Repository
        /// </summary>
        /// <param name="entities">Liste von Entitäten</param>
        public virtual void RemoveRange(IEnumerable<T> entities)
        {
            if (entities == null)
                throw new ArgumentNullException(nameof(entities));
            Repository.RemoveRange(entities);
        }

        #endregion

        #region Count

        /// <summary>
        /// Gibt die Anzahl aller Entitäten zurück
        /// </summary>
        /// <returns>Anzahl</returns>
        public virtual int Count()
        {
            return Repository.Count();
        }

        /// <summary>
        /// Gibt die Anzahl aller Entitäten zurück
        /// </summary>
        /// <returns>Anzahl</returns>
        public virtual async Task<int> CountAsync()
        {
            return await Repository.CountAsync().ConfigureAwait(false);
        }

        #endregion

        #region Commit / UnitOfWork

        /// <summary>
        /// Schließt Daten-Änderungen ab und speichert die selben
        /// </summary>
        public int Commit()
        {
            return _unitOfWork.Commit();
        }

        /// <summary>
        /// Schließt Daten-Änderungen ab und speichert die selben
        /// </summary>
        public async Task<int> CommitAsync()
        {
            return await _unitOfWork.CommitAsync().ConfigureAwait(false);
        }

        #endregion  

        #region IDisposable

        /// <summary>
        /// Dispose
        /// </summary>
        /// <param name="disposing"></param>
        protected virtual void Dispose(bool disposing)
        {
            if (!this._disposed)
            {
                if (disposing)
                {
                    _unitOfWork.Dispose();
                }
            }
            this._disposed = true;
        }

        /// <summary>
        /// Dispose
        /// </summary>
        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        #endregion
    }
}