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

namespace gehGassi.Core.Services
{
    /// <summary>
    /// Service der die Verwaltung von Hunden realisiert
    /// </summary>
    public class DogService : ServiceBase<Dog>, IDogService
    {
        private readonly IRepository<DogWithNames> _namesRepository;

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

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

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

        /// <summary>
        /// Gibt eine gefilterte Liste von Hunden zurück. Sucht nur im Namen
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <returns>List betroffener Hunde</returns>
        public async Task<List<Dog>> SearchAsync(string filter)
        {
            return (await Repository.FindAsync(c => c.Name.Contains(filter))).ToList();
        }

        /// <summary>
        /// Gibt eine gefilterte Liste von Hunden mit Namen 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 Hunde</returns>
        public IQueryable<DogWithNames> FilterWithNames(string filter, string language, string fallback)
        {
            language = language.ToUpperInvariant();
            fallback = fallback.ToUpperInvariant();

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

        /// <summary>
        /// Gibt die nächste freie Nummer für einen Hund zurück
        /// </summary>
        /// <returns>Hunde-Nummer</returns>
        public async Task<string> GetNextNumberAsync()
        {
            long number = 1;
            var total = await Repository.CountAsync().ConfigureAwait(false);
            number = total + 1;
            return $"D-{DateTime.UtcNow.Year:00}{DateTime.UtcNow.Month:00}-{number:000000000}";
        }

        /// <summary>
        /// Zurücksetzen der Rasse auf null
        /// </summary>
        /// <param name="dogRaceId">Id der Hunderasse</param>
        /// <returns>Anzahl zurückgesetzte Hunde</returns>
        public async Task<int> ResetDogRaceAsync(string dogRaceId)
        {
            var items = (await Repository.FindAsync(c => c.DogRaceId == dogRaceId).ConfigureAwait(false)).ToList();
            foreach (var item in items)
            {
                item.DogRaceId = null;
            }

            return items.Count;
        }

        /// <summary>
        /// Gibt eine Liste der Hunde eines Benutzers zurück
        /// </summary>
        /// <param name="appUserId">Id des AppUsers</param>
        /// <param name="lastUpdate">Letztes Update</param>
        /// <returns>Liste der Hunde</returns>
        public async Task<List<Dog>> GetDogsAsync(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>
        /// Gibt einen hunde mit Namen aufgelöst zurück
        /// </summary>
        /// <param name="dogId">Id des Hundes</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="fallback">Fallback Sprache</param>
        /// <param name="includeDeleted">Sollen gelöschte auch abgefragt werden - für historische Korrektheit</param>
        /// <returns>Hund oder null, wenn nicht gefunden</returns>
        public async Task<DogWithNames> GetWithNamesAsync(string dogId, string language, string fallback,bool includeDeleted)
        {
            language = language.ToUpperInvariant();
            fallback = fallback.ToUpperInvariant();

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

        /// <summary>
        /// Gibt alle Hunde mit Namen aufgelöst für einen hundebesitzer zurück
        /// </summary>
        /// <param name="ownerId">Id des Hundebesitzers</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="fallback">Fallback Sprache</param>
        /// <returns>Hund oder null, wenn nicht gefunden</returns>
        public async Task<List<DogWithNames>> GetWithNamesOwnerAsync(string ownerId, string language, string fallback)
        {
            language = language.ToUpperInvariant();
            fallback = fallback.ToUpperInvariant();

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