using Mapster;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Caching.Memory;
using Persistence.Database.Entity;
using Persistence.Models;
using Persistence.Repositories;
using Persistence.Repository.Extensions;

namespace Persistence.Repository.Repositories
{
	public class TechMessagesRepository : ITechMessagesRepository
	{
		private static readonly string SystemCacheKey = $"{typeof(ADSystem).FullName}CacheKey";
		private readonly IMemoryCache memoryCache;
		private DbContext db;

		public TechMessagesRepository(DbContext db, IMemoryCache memoryCache)
		{
			this.memoryCache = memoryCache;
			this.db = db;
		}

		protected virtual IQueryable<TechMessage> GetQueryReadOnly() => db.Set<TechMessage>()
			.Include(e => e.System);

		public async Task<PaginationContainer<TechMessageDto>> GetPage(RequestDto request, CancellationToken token)
		{
			var query = GetQueryReadOnly();
			var entities = await query
				.SortBy(request.SortSettings)
				.Skip(request.Skip)
				.Take(request.Take)
				.ToListAsync();
			var dto = new PaginationContainer<TechMessageDto>()
			{
				Skip = request.Skip,
				Take = request.Take,
				Count = entities.Count,
				Items = entities.Select(e => e.Adapt<TechMessageDto>())
			};

			return dto;
		}

		public async Task<Dictionary<string, int>> GetStatistics(int? importantId, string? autoDrillingSystem, CancellationToken token)
		{
			var query = GetQueryReadOnly();
			var count = await query
				.Where(e => importantId == null || e.CategoryId == importantId)
				.Where(e => autoDrillingSystem == null || e.System.Name == autoDrillingSystem)
				.GroupBy(e => e.System.Name)
				.ToDictionaryAsync(e => e.Key, v => v.Count());

			return count;
		}

		public async Task<IEnumerable<string>> GetSystems(CancellationToken token)
		{
			var entities = await GetSystems();
			var systems = entities.Select(e => e.Name);

			return systems ?? [];
		}

		public async Task<int> InsertRange(IEnumerable<TechMessageDto> dtos, CancellationToken token)
		{

			var entities = new List<TechMessage>();
			foreach (var dto in dtos)
			{
				var entity = dto.Adapt<TechMessage>();
				var systems = await GetSystems();
				var systemId = systems.FirstOrDefault(e => e.Name == dto.System)?.SystemId
					?? await CreateSystem(dto.System);

				entity.SystemId = systemId;

				entities.Add(entity);
			}

			await db.Set<TechMessage>().AddRangeAsync(entities, token);
			var result = await db.SaveChangesAsync(token);

			return result;
		}

		private async Task<IEnumerable<ADSystemDto>> GetSystems()
		{
			var systems = await memoryCache.GetOrCreateAsync(SystemCacheKey, async f =>
			{
				f.AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(60);

				var query = db.Set<ADSystem>();
				var entities = await query.ToListAsync();
				var dtos = entities.Select(e => e.Adapt<ADSystemDto>());

				return dtos;
			});

			return systems ?? [];
		}
		private async Task<Guid> CreateSystem(string name)
		{
			memoryCache.Remove(SystemCacheKey);

			var systemId = Guid.NewGuid();
			var entity = new ADSystem()
			{
				SystemId = systemId,
				Name = name
			};

			await db.Set<ADSystem>().AddAsync(entity);
			await db.SaveChangesAsync();

			return systemId;
		}
	}
}