using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;
using PARR.DAL.Context;
using PARR.DAL.Models.Unit;
using PARR.DAL.Services.Interfaces.Unit;

namespace PARR.DAL.Services.Implementations.Unit
{
    internal class UnitInValueService : IUnitInValueService
    {
        private readonly ILogger<UnitInValueService> logger;
        private readonly DataContext dataContext;

        public UnitInValueService(
            ILogger<UnitInValueService> logger,
            DataContext dataContext
            )
        {
            this.logger = logger;
            this.dataContext = dataContext;
        }

        public async Task<List<UnitInValue>> GetByUnitIdAsync(Guid unitId)
        {
            return await dataContext.UnitInValues.AsNoTracking()
                    .Include(t => t.Value)
                    .Where(uv => uv.UnitId == unitId)
                    .ToListAsync();
        }

        public async Task<List<UnitInValue>> GetByUnitIdsAsync(IEnumerable<Guid> unitIds)
        {
            return await dataContext.UnitInValues.AsNoTracking()
                    .Include(t => t.Value)
                    .Where(uv => unitIds.Contains(uv.UnitId))
                    .ToListAsync();
        }


        public async Task<List<(string FieldName, string? Value)>> GetFieldValuesAsync(
            Guid unitId,
            IReadOnlyCollection<string> aihitNames)
        {
            if (aihitNames == null || aihitNames.Count == 0)
                return new List<(string, string?)>();

            var keyValuePairs = await dataContext.UnitInValues
                .AsNoTracking()
                .AsSplitQuery()
                .Where(uiv => uiv.UnitId == unitId
                           && uiv.Field != null
                           && uiv.Value != null
                           && aihitNames.Contains(uiv.Field.AihitName.ToUpper()))
                .Select(uiv => new { Key = uiv.Field!.AihitName.ToUpper(), Value = uiv.Value!.Value })
                .ToListAsync();

            // Журналируем если не нашли поля
            var foundFieldNames = keyValuePairs.Select(kvp => kvp.Key).ToHashSet(StringComparer.OrdinalIgnoreCase);
            var missing = aihitNames
                .Where(name => !foundFieldNames.Contains(name.ToUpper()))
                .ToList();
            if (missing.Any())
            {
                logger.LogDebug("UnitInValueService: поля не найдены для unitId={UnitId}: {Fields}",
                    unitId, string.Join(", ", missing));
            }

            return keyValuePairs.Select(kvp => (kvp.Key, kvp.Value)).ToList();
        }


        public async Task<List<UnitInValue>> GetByUnitIdsAndFieldIdsAsync(IEnumerable<Guid> unitIds, IEnumerable<Guid> fieldIds)
        {
            var unitIdSet = unitIds.ToHashSet();
            var fieldIdSet = fieldIds.ToHashSet();

            return await dataContext.UnitInValues
                .AsNoTracking()
                .Include(uv => uv.Value) // UnitFieldValue
                .Where(uv => unitIdSet.Contains(uv.UnitId) && fieldIdSet.Contains(uv.FieldId))
                .ToListAsync();
        }
    }
}