using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using gehGassi.Core.Interfaces;
using gehGassi.Domain.Dogs;
using gehGassi.Domain.News;
using Microsoft.EntityFrameworkCore;

namespace gehGassi.Core.Services
{
    /// <summary>
    /// Service der die Verwaltung von Hunderassen realisiert
    /// </summary>
    public class DogRaceService : ServiceBase<DogRace>, IDogRaceService
    {
        private readonly IRepository<DogRaceWithNames> _namesRepository;

        /// <summary>
        /// Erstellt eine Instanz
        /// </summary>
        /// <param name="unitOfWork">Instanz einer IUnitOfWork</param>
        public DogRaceService(IUnitOfWork unitOfWork) : base(unitOfWork)
        {
            _namesRepository = unitOfWork.GetRepository<DogRaceWithNames>();
        }

        /// <summary>
        /// Gibt eine gefilterte Liste von Hunderassen zurück
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <returns>List betroffener Hunderassen</returns>
        public IQueryable<DogRace> Filter(string filter)
        {
            return Repository.Query(c => c.NameLocalized.Contains(filter));
        }

        /// <summary>
        /// Erstellen einer Hunderasse
        /// </summary>
        /// <returns>Hunderasse</returns>
        public DogRace Create()
        {
            var item = new DogRace()
            {
                Id = Guid.NewGuid().ToString("N"),
                Created = DateTimeOffset.UtcNow
            };
            return item;
        }

        /// <summary>
        /// Gibt eine gefilterte Liste von Hunderassen zurück.
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <returns>List betroffener Hunderassen</returns>
        public async Task<List<DogRace>> SearchAsync(string filter)
        {
            return (await Repository.FindAsync(c => c.NameLocalized.Contains(filter) && c.Deleted == false)).ToList();
        }

        /// <summary>
        /// Gibt eine gefilterte Liste von Hunderassen zurück.
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="fallback">Fallback Sprache</param>
        /// <returns>List betroffener Hunderassen</returns>
        public async Task<List<DogRaceWithNames>> SearchWithNamesAsync(string filter, string language, string fallback)
        {
            language = language.ToUpperInvariant();
            fallback = fallback.ToUpperInvariant();

            var baseQuery = _namesRepository.QueryStoredProcedure("SELECT * FROM tv_DogRacesWithNames({0},{1})", c => c.Name.Contains(filter) && c.Deleted == false, language, fallback);
            return await baseQuery.ToListAsync().ConfigureAwait(false);
        }

        /// <summary>
        /// Gibt eine gefilterte Liste von Hunderassen mit Namen zurück in einer gewählten Sprache
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="fallback">Fallback Sprache</param>
        /// <param name="includeDeleted">Sollen gelöschte inkludiert werden?</param>
        /// <returns>Liste betroffener Hunderassen</returns>
        public IQueryable<DogRaceWithNames> FilterWithNames(string filter, string language, string fallback, bool includeDeleted)
        {
            language = language.ToUpperInvariant();
            fallback = fallback.ToUpperInvariant();

            var baseQuery = _namesRepository.QueryStoredProcedure("SELECT * FROM tv_DogRacesWithNames({0},{1})", c => c.Name.Contains(filter), language, fallback);

            if (!includeDeleted)
                baseQuery = baseQuery.Where(c => c.Deleted == false);

            return baseQuery;
        }

        /// <summary>
        /// Gibt eine Liste von Hunderassen zurück, welche nach dem glieferten Datum geändert wurden.
        /// Wird kein Datum angegeben, werden alle zurückgegeben.
        /// </summary>
        /// <param name="lastUpdate">Letztes Update oder null wenn noch keines</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="fallback">Fallback Sprache</param>
        /// <returns>Liste von Hunderassen</returns>
        public async Task<List<DogRaceWithNames>> GetForSyncAsync(DateTimeOffset? lastUpdate, string language, string fallback)
        {
            language = language.ToUpperInvariant();
            fallback = fallback.ToUpperInvariant();

            IQueryable<DogRaceWithNames> baseQuery;
            if (lastUpdate == null)
                baseQuery = _namesRepository.QueryStoredProcedure("SELECT * FROM tv_DogRacesWithNames({0},{1})", null, language, fallback);
            else
                baseQuery = _namesRepository.QueryStoredProcedure("SELECT * FROM tv_DogRacesWithNames({0},{1})", c => c.UpdatedAt > lastUpdate, language, fallback);
            return await baseQuery.ToListAsync().ConfigureAwait(false);
        }

        /// <summary>
        /// Gibt eine Hunderasse mit Namen aufgelöst zurück
        /// </summary>
        /// <param name="id">Id der Hunderasse</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="fallback">Fallback Sprache</param>
        /// <returns>Hunderasse oder null, wenn nicht gefunden</returns>
        public async Task<DogRaceWithNames> GetWithNamesAsync(string id, string language, string fallback)
        {
            language = language.ToUpperInvariant();
            fallback = fallback.ToUpperInvariant();

            var baseQuery = _namesRepository.QueryStoredProcedure("SELECT * FROM tv_DogRacesWithNames({0},{1})", c => c.Id == id && c.Deleted == false, language, fallback);
            return await baseQuery.FirstOrDefaultAsync().ConfigureAwait(false);
        }
    }
}