using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Threading.Tasks;
using gehGassi.Core.Interfaces;
using Microsoft.Data.SqlClient;
using Microsoft.EntityFrameworkCore;

namespace gehGassi.Persistence
{
    /// <summary>
    /// Abstrakte Basis-Klasse für Repositories
    /// </summary>
    /// <typeparam name="T">Typ (Klasse) des Repositories</typeparam>
    public class Repository<T> : IRepository<T> where T : class
    {
        private readonly DbContext _context;
        private readonly DbSet<T> _entities;

        /// <summary>
        /// Erstellt eine Instanz
        /// </summary>
        /// <param name="context">Instanz eines DBContext</param>
        public Repository(DbContext context)
        {
            _context = context;
            _entities = _context.Set<T>();
        }

        /// <summary>
        /// Gibt eine Entität anhand der eindeutigen Id zurück
        /// </summary>
        /// <param name="id">Id der Entität</param>
        /// <returns>Entität oder null, wenn nicht gefunden</returns>
        public virtual T Get(object id)
        {
            return _entities.Find(id);
        }

        /// <summary>
        /// Gibt eine Entität anhand der eindeutigen Id zurück
        /// </summary>
        /// <param name="id">Id der Entität</param>
        /// <returns>Entität oder null, wenn nicht gefunden</returns>
        public virtual async Task<T> GetAsync(object id)
        {
            return await _entities.FindAsync(id);
        }

        /// <summary>
        /// Gibt alle Entitäten zurück
        /// </summary>
        /// <returns>Liste aller Entitäten</returns>
        public virtual IEnumerable<T> GetAll()
        {
            return _entities.ToList();
        }

        /// <summary>
        /// Gibt alle Entitäten zurück
        /// </summary>
        /// <returns>Liste aller Entitäten</returns>
        public virtual async Task<IEnumerable<T>> GetAllAsync()
        {
            return await _entities.ToListAsync();
        }

        /// <summary>
        /// Gibt eine Liste aller Entitäten zurück welche definierten Kriterien entsprechen
        /// </summary>
        /// <param name="predicate">Kriterien</param>
        /// <returns>Liste gefundener Entitäten</returns>
        public virtual IEnumerable<T> Find(Expression<Func<T, bool>> predicate)
        {
            return _entities.Where(predicate).ToList();
        }

        /// <summary>
        /// Gibt eine Liste aller Entitäten zurück welche definierten Kriterien entsprechen
        /// </summary>
        /// <param name="predicate">Kriterien</param>
        /// <returns>Liste gefundener Entitäten</returns>
        public virtual async Task<IEnumerable<T>> FindAsync(Expression<Func<T, bool>> predicate)
        {
            return await _entities.Where(predicate).ToListAsync();
        }

        /// <summary>
        /// Gibt eine Liste aller Entitäten zurück welche definierten Kriterien entsprechen
        /// </summary>
        /// <param name="predicate">Kriterien</param>
        /// <returns>Liste gefundener Entitäten</returns>
        public virtual async Task<IEnumerable<T>> FindNoTrackingAsync(Expression<Func<T, bool>> predicate)
        {
            return await _entities.Where(predicate).AsNoTracking().ToListAsync();
        }

        /// <summary>
        /// Gibt eine Liste aller Entitäten zurück welche definierten Kriterien entsprechen.
        /// Hier wird zuerst die SQL-Abfrage ausgeführt!
        /// </summary>
        /// <param name="rawSql">SQL-String</param>
        /// <param name="predicate">Kriterien</param>
        /// <returns>Liste gefundener Entitäten</returns>
        public IEnumerable<T> Find(string rawSql, Expression<Func<T, bool>> predicate = null)
        {
            var result = _entities.FromSqlRaw(rawSql);
            if (predicate != null)
                result = result.Where(predicate);

            return result.ToList();
        }

        /// <summary>
        /// Gibt eine Liste aller Entitäten zurück welche definierten Kriterien entsprechen
        /// Hier wird zuerst die SQL-Abfrage ausgeführt!
        /// </summary>
        /// <param name="rawSql">SQL-String</param>
        /// <param name="predicate">Kriterien</param>
        /// <returns>Liste gefundener Entitäten</returns>
        public async Task<IEnumerable<T>> FindAsync(string rawSql, Expression<Func<T, bool>> predicate = null)
        {
            var result = _entities.FromSqlRaw(rawSql);
            if (predicate != null)
                result = result.Where(predicate);

            return await result.ToListAsync();
        }

        /// <summary>
        /// Gibt eine Liste aller Entitäten zurück welche definierten Kriterien entsprechen
        /// Hier wird zuerst die SQL-Abfrage ausgeführt!
        /// </summary>
        /// <param name="rawSql">SQL-String</param>
        /// <param name="parameters">SQL-Parameter</param>
        /// <returns>Liste gefundener Entitäten</returns>
        public async Task<IEnumerable<T>> FindSqlAsync(string rawSql, params object[] parameters)
        {
            var result = _entities.FromSqlRaw(rawSql, parameters);
            return await result.ToListAsync().ConfigureAwait(false);
        }

        /// <summary>
        /// Gibt eine Liste aller Entitäten zurück welche definierten Kriterien entsprechen
        /// </summary>
        /// <param name="predicate">Kriterien</param>
        /// <returns>Liste gefundener Entitäten</returns>
        public IQueryable<T> Query(Expression<Func<T, bool>> predicate)
        {
            return _entities.Where(predicate);
        }

        /// <summary>
        /// Gibt eine Liste aller Entitäten zurück welche definierten Kriterien entsprechen von einem View
        /// </summary>
        /// <param name="predicate">Kriterien</param>
        /// <returns>Liste gefundener Entitäten</returns>
        public IQueryable<T> QueryView(Expression<Func<T, bool>> predicate)
        {
            return _context.Set<T>().Where(predicate);
        }

        /// <summary>
        /// Gibt eine Liste aller Entitäten zurück welche definierten Kriterien entsprechen von einem View
        /// </summary>
        /// <param name="predicate">Kriterien</param>
        /// <returns>Liste gefundener Entitäten</returns>
        public async Task<IEnumerable<T>> QueryViewListAsync(Expression<Func<T, bool>> predicate)
        {
            return await _context.Set<T>().Where(predicate).ToListAsync();
        }

        /// <summary>
        /// Gibt eine Liste aller Entitäten zurück welche definierten Kriterien entsprechen.
        /// Hier wird zuerst die SQL-Abfrage ausgeführt!
        /// </summary>
        /// <param name="rawSql">SQL-String</param>
        /// <param name="predicate">Kriterien</param>
        /// <returns>Liste gefundener Entitäten</returns>
        public IQueryable<T> Query(string rawSql, Expression<Func<T, bool>> predicate = null)
        {
            var result = _entities.FromSqlRaw(rawSql);
            if (predicate != null)
                result = result.Where(predicate);

            return result;
        }

        /// <summary>
        /// Gibt eine Liste aller Entitäten zurück welche definierten Kriterien entsprechen.
        /// Hier wird zuerst die SQL-Abfrage ausgeführt!
        /// </summary>
        /// <param name="rawSql">SQL-String</param>
        /// <param name="predicate">Kriterien</param>
        /// <param name="parameters">Parameter für die Stored Procedure</param>
        /// <returns>Liste gefundener Entitäten</returns>
        public IQueryable<T> QueryStoredProcedure(string rawSql, Expression<Func<T, bool>> predicate = null, params object[] parameters)
        {
            var result = _entities.FromSqlRaw(rawSql, parameters);
            if (predicate != null)
                result = result.Where(predicate);

            return result;
        }

        /// <summary>
        /// Gibt eine Entität oder den Default wert zurück
        /// </summary>
        /// <param name="predicate">Kriterien</param>
        /// <returns>Gefundene entität oder Default-Wert</returns>
        public virtual T SingleOrDefault(Expression<Func<T, bool>> predicate)
        {
            return _entities.SingleOrDefault(predicate);
        }

        /// <summary>
        /// Gibt eine Entität oder den Default wert zurück
        /// </summary>
        /// <param name="predicate">Kriterien</param>
        /// <returns>Gefundene entität oder Default-Wert</returns>
        public virtual async Task<T> SingleOrDefaultAsync(Expression<Func<T, bool>> predicate)
        {
            return await _entities.SingleOrDefaultAsync(predicate);
        }

        /// <summary>
        /// Gibt eine Entität oder den Default wert zurück
        /// </summary>
        /// <param name="predicate">Kriterien</param>
        /// <returns>Gefundene entität oder Default-Wert</returns>
        public T FirstOrDefault(Expression<Func<T, bool>> predicate)
        {
            return _entities.FirstOrDefault(predicate);
        }

        /// <summary>
        /// Gibt eine Entität oder den Default wert zurück
        /// </summary>
        /// <param name="predicate">Kriterien</param>
        /// <returns>Gefundene entität oder Default-Wert</returns>
        public async Task<T> FirstOrDefaultAsync(Expression<Func<T, bool>> predicate)
        {
            return await _entities.FirstOrDefaultAsync(predicate);
        }

        /// <summary>
        /// Fügt eine Entität zum Repository hinzu
        /// </summary>
        /// <param name="entity">Entität</param>
        public virtual void Add(T entity)
        {
            _entities.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)
        {
            _entities.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)
        {
            _entities.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)
        {
            _entities.RemoveRange(entities);
        }

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

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

        /// <summary>
        /// Gibt die Anzahl aller Entitäten zurück die definierten Kriterien entsprechen
        /// </summary>
        /// <param name="predicate">Kriterien</param>
        /// <returns>Anzahl Entitäten</returns>
        public int Count(Expression<Func<T, bool>> predicate)
        {
            return _entities.Count(predicate);
        }

        /// <summary>
        /// Gibt die Anzahl aller Entitäten zurück die definierten Kriterien entsprechen
        /// </summary>
        /// <param name="predicate">Kriterien</param>
        /// <returns>Anzahl Entitäten</returns>
        public async Task<int> CountAsync(Expression<Func<T, bool>> predicate)
        {
            return await _entities.CountAsync(predicate);
        }

        /// <summary>
        /// Ausführen eines RAW SQL commands
        /// </summary>
        /// <param name="sql">SQL-String</param>
        /// <param name="parameters">Parameter</param>
        /// <returns>Anzahl betroffener Datensätze</returns>
        public async Task<int> ExecuteRawSqlAsync(string sql, Dictionary<string, object> parameters)
        {
            var sqlParameters = new List<SqlParameter>();
            foreach (var (key, value) in parameters)
            {
                sqlParameters.Add(new SqlParameter(key, value));
            }
            return await _context.Database.ExecuteSqlRawAsync(sql, sqlParameters);
        }
    }
}