#pragma warning disable RS0030 // Do not use banned APIs

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using Jellyfin.Database.Implementations.Entities;
using Microsoft.EntityFrameworkCore;

namespace Jellyfin.Database.Implementations;

/// <summary>
/// Contains a number of query related extensions.
/// </summary>
public static class JellyfinQueryHelperExtensions
{
    private static readonly MethodInfo _containsMethodGenericCache = typeof(Enumerable).GetMethods(BindingFlags.Public | BindingFlags.Static).First(m => m.Name == nameof(Enumerable.Contains) && m.GetParameters().Length == 2);
    private static readonly MethodInfo _efParameterInstruction = typeof(EF).GetMethod(nameof(EF.Parameter), BindingFlags.Public | BindingFlags.Static)!;
    private static readonly ConcurrentDictionary<Type, MethodInfo> _containsQueryCache = new();

    /// <summary>
    /// Builds an optimised query checking one property against a list of values while maintaining an optimal query.
    /// </summary>
    /// <typeparam name="TEntity">The entity.</typeparam>
    /// <typeparam name="TProperty">The property type to compare.</typeparam>
    /// <param name="query">The source query.</param>
    /// <param name="oneOf">The list of items to check.</param>
    /// <param name="property">Property expression.</param>
    /// <returns>A Query.</returns>
    public static IQueryable<TEntity> WhereOneOrMany<TEntity, TProperty>(this IQueryable<TEntity> query, IList<TProperty> oneOf, Expression<Func<TEntity, TProperty>> property)
    {
        return query.Where(OneOrManyExpressionBuilder(oneOf, property));
    }

    /// <summary>
    /// Builds a query that checks referenced ItemValues for a cross BaseItem lookup.
    /// </summary>
    /// <param name="baseQuery">The source query.</param>
    /// <param name="context">The database context.</param>
    /// <param name="itemValueType">The type of item value to reference.</param>
    /// <param name="referenceIds">The list of BaseItem ids to check matches.</param>
    /// <param name="invert">If set an exclusion check is performed instead.</param>
    /// <returns>A Query.</returns>
    public static IQueryable<BaseItemEntity> WhereReferencedItem(
        this IQueryable<BaseItemEntity> baseQuery,
        JellyfinDbContext context,
        ItemValueType itemValueType,
        IList<Guid> referenceIds,
        bool invert = false)
    {
        return baseQuery.Where(ReferencedItemFilterExpressionBuilder(context, itemValueType, referenceIds, invert));
    }

    /// <summary>
    /// Builds a query that checks referenced ItemValues for a cross BaseItem lookup.
    /// </summary>
    /// <param name="baseQuery">The source query.</param>
    /// <param name="context">The database context.</param>
    /// <param name="itemValueTypes">The type of item value to reference.</param>
    /// <param name="referenceIds">The list of BaseItem ids to check matches.</param>
    /// <param name="invert">If set an exclusion check is performed instead.</param>
    /// <returns>A Query.</returns>
    public static IQueryable<BaseItemEntity> WhereReferencedItemMultipleTypes(
        this IQueryable<BaseItemEntity> baseQuery,
        JellyfinDbContext context,
        IList<ItemValueType> itemValueTypes,
        IList<Guid> referenceIds,
        bool invert = false)
    {
        var itemFilter = OneOrManyExpressionBuilder<BaseItemEntity, Guid>(referenceIds, f => f.Id);
        var typeFilter = OneOrManyExpressionBuilder<ItemValueMap, ItemValueType>(itemValueTypes, m => m.ItemValue.Type);

        // Flat sub-selects + Contains instead of a nested correlated .Any(...Any(...)).
        var referencedCleanValues = context.BaseItems
            .Where(itemFilter)
            .Select(e => e.CleanName);

        var matchingItemIds = context.ItemValuesMap
            .Where(typeFilter)
            .Where(m => referencedCleanValues.Contains(m.ItemValue.CleanValue))
            .Select(m => m.ItemId);

        if (invert)
        {
            return baseQuery.Where(e => !matchingItemIds.Contains(e.Id));
        }

        return baseQuery.Where(e => matchingItemIds.Contains(e.Id));
    }

    /// <summary>
    /// Builds a query expression that checks referenced ItemValues for a cross BaseItem lookup.
    /// </summary>
    /// <param name="context">The database context.</param>
    /// <param name="itemValueType">The type of item value to reference.</param>
    /// <param name="referenceIds">The list of BaseItem ids to check matches.</param>
    /// <param name="invert">If set an exclusion check is performed instead.</param>
    /// <returns>A Query.</returns>
    public static Expression<Func<BaseItemEntity, bool>> ReferencedItemFilterExpressionBuilder(
        this JellyfinDbContext context,
        ItemValueType itemValueType,
        IList<Guid> referenceIds,
        bool invert = false)
    {
        // Well genre/artist/album etc items do not actually set the ItemValue of thier specitic types so we cannot match it that way.
        /*
        "(guid in (select itemid from ItemValues where CleanValue = (select CleanName from TypedBaseItems where guid=@GenreIds and Type=2)))"
        */

        var itemFilter = OneOrManyExpressionBuilder<BaseItemEntity, Guid>(referenceIds, f => f.Id);

        // Flat sub-selects + Contains instead of a nested correlated .Any(...Any(...)).
        var referencedCleanValues = context.BaseItems
            .Where(itemFilter)
            .Select(e => e.CleanName);

        var matchingItemIds = context.ItemValuesMap
            .Where(m => m.ItemValue.Type == itemValueType && referencedCleanValues.Contains(m.ItemValue.CleanValue))
            .Select(m => m.ItemId);

        if (invert)
        {
            return item => !matchingItemIds.Contains(item.Id);
        }

        return item => matchingItemIds.Contains(item.Id);
    }

    /// <summary>
    /// Filters items that match any of the specified (provider name, value) pairs.
    /// </summary>
    /// <param name="baseQuery">The source query.</param>
    /// <param name="providerIds">Dictionary mapping provider names to arrays of values to match.</param>
    /// <returns>A filtered query.</returns>
    public static IQueryable<BaseItemEntity> WhereHasAnyProviderIds(
        this IQueryable<BaseItemEntity> baseQuery,
        IReadOnlyDictionary<string, string[]> providerIds)
    {
        var providerKeys = providerIds
            .SelectMany(kvp => kvp.Value.Select(v => $"{kvp.Key}:{v}"))
            .ToList();

        if (providerKeys.Count == 0)
        {
            return baseQuery;
        }

        return baseQuery.Where(e => e.Provider!.Any(p => providerKeys.Contains(p.ProviderId + ":" + p.ProviderValue)));
    }

    /// <summary>
    /// Filters items that have any of the specified providers. Empty/null values match any value for that provider.
    /// </summary>
    /// <param name="baseQuery">The source query.</param>
    /// <param name="providerIds">Dictionary mapping provider names to optional values.</param>
    /// <returns>A filtered query.</returns>
    public static IQueryable<BaseItemEntity> WhereHasAnyProviderId(
        this IQueryable<BaseItemEntity> baseQuery,
        IReadOnlyDictionary<string, string> providerIds)
    {
        var existenceOnly = providerIds
            .Where(e => string.IsNullOrEmpty(e.Value))
            .Select(e => e.Key)
            .ToList();

        var specificValues = providerIds
            .Where(e => !string.IsNullOrEmpty(e.Value))
            .Select(e => $"{e.Key}:{e.Value}")
            .ToList();

        if (existenceOnly.Count == 0 && specificValues.Count == 0)
        {
            return baseQuery;
        }

        if (existenceOnly.Count == 0)
        {
            return baseQuery.Where(e => e.Provider!.Any(p =>
                specificValues.Contains(p.ProviderId + ":" + p.ProviderValue)));
        }

        if (specificValues.Count == 0)
        {
            return baseQuery.Where(e => e.Provider!.Any(p => existenceOnly.Contains(p.ProviderId)));
        }

        // Single EXISTS over Provider with both predicates OR'd, instead of two separate subqueries.
        return baseQuery.Where(e => e.Provider!.Any(p =>
            existenceOnly.Contains(p.ProviderId) ||
            specificValues.Contains(p.ProviderId + ":" + p.ProviderValue)));
    }

    /// <summary>
    /// Excludes items that match any of the specified (provider name, value) pairs.
    /// </summary>
    /// <param name="baseQuery">The source query.</param>
    /// <param name="providerIds">Dictionary mapping provider names to values to exclude.</param>
    /// <returns>A filtered query.</returns>
    public static IQueryable<BaseItemEntity> WhereExcludeProviderIds(
        this IQueryable<BaseItemEntity> baseQuery,
        IReadOnlyDictionary<string, string> providerIds)
    {
        var excludeKeys = providerIds
            .Select(e => $"{e.Key}:{e.Value}")
            .ToList();

        if (excludeKeys.Count == 0)
        {
            return baseQuery;
        }

        return baseQuery.Where(e => e.Provider!.All(p => !excludeKeys.Contains(p.ProviderId + ":" + p.ProviderValue)));
    }

    /// <summary>
    /// Builds an optimised query expression checking one property against a list of values while maintaining an optimal query.
    /// </summary>
    /// <typeparam name="TEntity">The entity.</typeparam>
    /// <typeparam name="TProperty">The property type to compare.</typeparam>
    /// <param name="oneOf">The list of items to check.</param>
    /// <param name="property">Property expression.</param>
    /// <returns>A Query.</returns>
    public static Expression<Func<TEntity, bool>> OneOrManyExpressionBuilder<TEntity, TProperty>(this IList<TProperty> oneOf, Expression<Func<TEntity, TProperty>> property)
    {
        var parameter = Expression.Parameter(typeof(TEntity), "item");
        property = ParameterReplacer.Replace<Func<TEntity, TProperty>, Func<TEntity, TProperty>>(property, property.Parameters[0], parameter);
        if (oneOf.Count == 1)
        {
            var value = oneOf[0];
            if (typeof(TProperty).IsValueType)
            {
                return Expression.Lambda<Func<TEntity, bool>>(Expression.Equal(property.Body, Expression.Constant(value)), parameter);
            }
            else
            {
                return Expression.Lambda<Func<TEntity, bool>>(Expression.ReferenceEqual(property.Body, Expression.Constant(value)), parameter);
            }
        }

        var containsMethodInfo = _containsQueryCache.GetOrAdd(typeof(TProperty), static (key) => _containsMethodGenericCache.MakeGenericMethod(key));

        // Always wrap the collection in EF.Parameter so EF Core caches a single compiled plan and reuses it across calls.
        return Expression.Lambda<Func<TEntity, bool>>(
            Expression.Call(
                null,
                containsMethodInfo,
                Expression.Call(null, _efParameterInstruction.MakeGenericMethod(oneOf.GetType()), Expression.Constant(oneOf)),
                property.Body),
            parameter);
    }

    internal static class ParameterReplacer
    {
        // Produces an expression identical to 'expression'
        // except with 'source' parameter replaced with 'target' expression.
        internal static Expression<TOutput> Replace<TInput, TOutput>(
                        Expression<TInput> expression,
                        ParameterExpression source,
                        ParameterExpression target)
        {
            return new ParameterReplacerVisitor<TOutput>(source, target)
                        .VisitAndConvert(expression);
        }

        private sealed class ParameterReplacerVisitor<TOutput> : ExpressionVisitor
        {
            private readonly ParameterExpression _source;
            private readonly ParameterExpression _target;

            public ParameterReplacerVisitor(ParameterExpression source, ParameterExpression target)
            {
                _source = source;
                _target = target;
            }

            internal Expression<TOutput> VisitAndConvert<T>(Expression<T> root)
            {
                return (Expression<TOutput>)VisitLambda(root);
            }

            protected override Expression VisitLambda<T>(Expression<T> node)
            {
                // Leave all parameters alone except the one we want to replace.
                var parameters = node.Parameters.Select(p => p == _source ? _target : p);

                return Expression.Lambda<TOutput>(Visit(node.Body), parameters);
            }

            protected override Expression VisitParameter(ParameterExpression node)
            {
                // Replace the source with the target, visit other params as usual.
                return node == _source ? _target : base.VisitParameter(node);
            }
        }
    }
}