//---------------------------------------------------------------------
// <copyright file="FunctionOverloadResolver.cs" company="Microsoft">
//      Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>
//
// @owner  Microsoft
// @backupOwner Microsoft
//---------------------------------------------------------------------

namespace System.Data.Common.EntitySql
{
    using System;
    using System.Collections.Generic;
    using System.Data.Entity;
    using System.Data.Metadata.Edm;
    using System.Diagnostics;
    using System.Linq;

    /// <summary>
    /// Represents function overload resolution mechanism, used by L2E and eSQL frontends.
    /// </summary>
    internal static class FunctionOverloadResolver
    {
        /// <summary>
        /// Resolves <paramref name="argTypes"/> against the list of function signatures.
        /// </summary>
        /// <returns>Funciton metadata</returns>
        internal static EdmFunction ResolveFunctionOverloads(IList<EdmFunction> functionsMetadata,
                                                             IList<TypeUsage> argTypes,
                                                             bool isGroupAggregateFunction,
                                                             out bool isAmbiguous)
        {
            return ResolveFunctionOverloads(
                functionsMetadata,
                argTypes,
                (edmFunction) => edmFunction.Parameters,
                (functionParameter) => functionParameter.TypeUsage,
                (functionParameter) => functionParameter.Mode,
                (argType) => TypeSemantics.FlattenType(argType),
                (paramType, argType) => TypeSemantics.FlattenType(paramType),
                (fromType, toType) => TypeSemantics.IsPromotableTo(fromType, toType),
                (fromType, toType) => TypeSemantics.IsStructurallyEqual(fromType, toType),
                isGroupAggregateFunction,
                out isAmbiguous);
        }

        /// <summary>
        /// Resolves <paramref name="argTypes"/> against the list of function signatures.
        /// </summary>
        /// <returns>Funciton metadata</returns>
        internal static EdmFunction ResolveFunctionOverloads(IList<EdmFunction> functionsMetadata,
                                                             IList<TypeUsage> argTypes,
                                                             Func<TypeUsage, IEnumerable<TypeUsage>> flattenArgumentType,
                                                             Func<TypeUsage, TypeUsage, IEnumerable<TypeUsage>> flattenParameterType,
                                                             Func<TypeUsage, TypeUsage, bool> isPromotableTo,
                                                             Func<TypeUsage, TypeUsage, bool> isStructurallyEqual,
                                                             bool isGroupAggregateFunction,
                                                             out bool isAmbiguous)
        {
            return ResolveFunctionOverloads(
                functionsMetadata,
                argTypes,
                (edmFunction) => edmFunction.Parameters,
                (functionParameter) => functionParameter.TypeUsage,
                (functionParameter) => functionParameter.Mode,
                flattenArgumentType,
                flattenParameterType,
                isPromotableTo,
                isStructurallyEqual,
                isGroupAggregateFunction,
                out isAmbiguous);
        }

        /// <summary>
        /// Resolves <paramref name="argTypes"/> against the list of function signatures.
        /// </summary>
        /// <param name="getSignatureParams">function formal signature getter</param>
        /// <param name="getParameterTypeUsage">TypeUsage getter for a signature param</param>
        /// <param name="getParameterMode">ParameterMode getter for a signature param</param>
        /// <returns>Funciton metadata</returns>
        internal static TFunctionMetadata ResolveFunctionOverloads<TFunctionMetadata, TFunctionParameterMetadata>(
            IList<TFunctionMetadata> functionsMetadata,
            IList<TypeUsage> argTypes,
            Func<TFunctionMetadata, IList<TFunctionParameterMetadata>> getSignatureParams,
            Func<TFunctionParameterMetadata, TypeUsage> getParameterTypeUsage,
            Func<TFunctionParameterMetadata, ParameterMode> getParameterMode,
            Func<TypeUsage, IEnumerable<TypeUsage>> flattenArgumentType,
            Func<TypeUsage, TypeUsage, IEnumerable<TypeUsage>> flattenParameterType,
            Func<TypeUsage, TypeUsage, bool> isPromotableTo,
            Func<TypeUsage, TypeUsage, bool> isStructurallyEqual,
            bool isGroupAggregateFunction,
            out bool isAmbiguous) where TFunctionMetadata : class
        {
            //
            // Flatten argument list
            //
            List<TypeUsage> argTypesFlat = new List<TypeUsage>(argTypes.Count);
            foreach (TypeUsage argType in argTypes)
            {
                argTypesFlat.AddRange(flattenArgumentType(argType));
            }

            //
            // Find a candidate overload with the best total rank, remember the candidate and its composite rank.
            //
            TFunctionMetadata bestCandidate = null;
            isAmbiguous = false;
            List<int[]> ranks = new List<int[]>(functionsMetadata.Count);
            int[] bestCandidateRank = null;
            for (int i = 0, maxTotalRank = int.MinValue; i < functionsMetadata.Count; i++)
            {
                int totalRank;
                int[] rank;
                if (TryRankFunctionParameters(argTypes,
                                              argTypesFlat,
                                              getSignatureParams(functionsMetadata[i]),
                                              getParameterTypeUsage,
                                              getParameterMode,
                                              flattenParameterType,
                                              isPromotableTo,
                                              isStructurallyEqual,
                                              isGroupAggregateFunction,
                                              out totalRank, out rank))
                {
                    if (totalRank == maxTotalRank)
                    {
                        isAmbiguous = true;
                    }
                    else if (totalRank > maxTotalRank)
                    {
                        isAmbiguous = false;
                        maxTotalRank = totalRank;
                        bestCandidate = functionsMetadata[i];
                        bestCandidateRank = rank;
                    }

                    Debug.Assert(argTypesFlat.Count == rank.Length, "argTypesFlat.Count == rank.Length");

                    ranks.Add(rank);
                }
            }

            //
            // If there is a best candidate, check it for ambiguity against composite ranks of other candidates
            // 
            if (bestCandidate != null && 
                !isAmbiguous && 
                argTypesFlat.Count > 1 && // best candidate may be ambiguous only in the case of 2 or more arguments
                ranks.Count > 1)
            {
                Debug.Assert(bestCandidateRank != null);

                //
                // Search collection of composite ranks to see if there is an overload that would render the best candidate ambiguous
                // 
                isAmbiguous = ranks.Any(rank =>
                {
                    Debug.Assert(rank.Length == bestCandidateRank.Length, "composite ranks have different number of elements");

                    if (!Object.ReferenceEquals(bestCandidateRank, rank)) // do not compare best cadnidate against itself
                    {
                        // All individual ranks of the best candidate must equal or better than the ranks of all other candidates,
                        // otherwise we consider it ambigous, even though it has an unambigously best total rank.
                        for (int i = 0; i < rank.Length; ++i)
                        {
                            if (bestCandidateRank[i] < rank[i])
                            {
                                return true;
                            }
                        }
                    }

                    return false;
                });
            }

            return isAmbiguous ? null : bestCandidate;
        }

        /// <summary>
        /// Check promotability, returns true if argument list is promotable to the overload and overload was successfully ranked, otherwise false.
        /// Ranks the overload parameter types against the argument list.
        /// </summary>
        /// <param name="argumentList">list of argument types</param>
        /// <param name="flatArgumentList">flattened list of argument types</param>
        /// <param name="overloadParamList1">list of overload parameter types</param>
        /// <param name="getParameterTypeUsage">TypeUsage getter for the overload parameters</param>
        /// <param name="getParameterMode">ParameterMode getter for the overload parameters</param>
        /// <param name="totalRank">returns total promotion rank of the overload, 0 if no arguments</param>
        /// <param name="parameterRanks">returns individual promotion ranks of the overload parameters, empty array if no arguments</param>
        private static bool TryRankFunctionParameters<TFunctionParameterMetadata>(IList<TypeUsage> argumentList,
                                                                                  IList<TypeUsage> flatArgumentList,
                                                                                  IList<TFunctionParameterMetadata> overloadParamList,
                                                                                  Func<TFunctionParameterMetadata, TypeUsage> getParameterTypeUsage,
                                                                                  Func<TFunctionParameterMetadata, ParameterMode> getParameterMode,
                                                                                  Func<TypeUsage, TypeUsage, IEnumerable<TypeUsage>> flattenParameterType,
                                                                                  Func<TypeUsage, TypeUsage, bool> isPromotableTo,
                                                                                  Func<TypeUsage, TypeUsage, bool> isStructurallyEqual,
                                                                                  bool isGroupAggregateFunction,
                                                                                  out int totalRank,
                                                                                  out int[] parameterRanks)
        {
            totalRank = 0;
            parameterRanks = null;

            if (argumentList.Count != overloadParamList.Count)
            {
                return false;
            }

            //
            // Check promotability and flatten the parameter types
            //
            List<TypeUsage> flatOverloadParamList = new List<TypeUsage>(flatArgumentList.Count);
            for (int i = 0; i < overloadParamList.Count; ++i)
            {
                TypeUsage argumentType = argumentList[i];
                TypeUsage parameterType = getParameterTypeUsage(overloadParamList[i]);

                //
                // Parameter mode must match.
                //
                ParameterMode parameterMode = getParameterMode(overloadParamList[i]);
                if (parameterMode != ParameterMode.In && parameterMode != ParameterMode.InOut)
                {
                    return false;
                }

                //
                // If function being ranked is a group aggregate, consider the element type.
                //
                if (isGroupAggregateFunction)
                {
                    if (!TypeSemantics.IsCollectionType(parameterType))
                    {
                        //
                        // Even though it is the job of metadata to ensure that the provider manifest is consistent.
                        // Ensure that if a function is marked as aggregate, then the argument type must be of collection{GivenType}.
                        //
                        throw EntityUtil.EntitySqlError(Strings.InvalidArgumentTypeForAggregateFunction);
                    }
                    parameterType = TypeHelpers.GetElementTypeUsage(parameterType);
                }

                //
                // If argument is not promotable - reject the overload.
                //
                if (!isPromotableTo(argumentType, parameterType))
                {
                    return false;
                }

                //
                // Flatten the parameter type.
                //
                flatOverloadParamList.AddRange(flattenParameterType(parameterType, argumentType));
            }

            Debug.Assert(flatArgumentList.Count == flatOverloadParamList.Count, "flatArgumentList.Count == flatOverloadParamList.Count");

            //
            // Rank argument promotions
            //
            parameterRanks = new int[flatOverloadParamList.Count];
            for (int i = 0; i < parameterRanks.Length; ++i)
            {
                int rank = GetPromotionRank(flatArgumentList[i], flatOverloadParamList[i], isPromotableTo, isStructurallyEqual);
                totalRank += rank;
                parameterRanks[i] = rank;
            }

            return true;
        }

        /// <summary>
        /// Ranks the <paramref name="fromType"/> -> <paramref name="toType"/> promotion.
        /// Range of values: 0 to negative infinity, with 0 as the best rank (promotion to self).
        /// <paramref name="fromType"/> must be promotable to <paramref name="toType"/>, otherwise internal error is thrown.
        /// </summary>
        private static int GetPromotionRank(TypeUsage fromType,
                                            TypeUsage toType,
                                            Func<TypeUsage, TypeUsage, bool> isPromotableTo,
                                            Func<TypeUsage, TypeUsage, bool> isStructurallyEqual)
        {
            //
            // Only promotable types are allowed at this point.
            //
            Debug.Assert(isPromotableTo(fromType, toType), "isPromotableTo(fromType, toType)");

            //
            // If both types are the same return rank 0 - the best match.
            //
            if (isStructurallyEqual(fromType, toType))
            {
                return 0;
            }

            //
            // In the case of eSQL untyped null will float up to the point of isStructurallyEqual(...) above.
            // Below it eveything should be normal.
            //
            Debug.Assert(fromType != null, "fromType != null");
            Debug.Assert(toType != null, "toType != null");

            //
            // Handle primitive types
            //
            PrimitiveType primitiveFromType = fromType.EdmType as PrimitiveType;
            PrimitiveType primitiveToType = toType.EdmType as PrimitiveType;
            if (primitiveFromType != null && primitiveToType != null)
            {
                if (Helper.AreSameSpatialUnionType(primitiveFromType, primitiveToType))
                {
                    return 0;
                }

                IList<PrimitiveType> promotions = EdmProviderManifest.Instance.GetPromotionTypes(primitiveFromType);

                int promotionIndex = promotions.IndexOf(primitiveToType);

                if (promotionIndex < 0)
                {
                    throw EntityUtil.InternalError(EntityUtil.InternalErrorCode.FailedToGeneratePromotionRank, 1);
                }
                
                return -promotionIndex;
            }

            //
            // Handle entity/relship types
            //
            EntityTypeBase entityBaseFromType = fromType.EdmType as EntityTypeBase;
            EntityTypeBase entityBaseToType = toType.EdmType as EntityTypeBase;
            if (entityBaseFromType != null && entityBaseToType != null)
            {
                int promotionIndex = 0;
                EdmType t;
                for (t = entityBaseFromType; t != entityBaseToType && t != null; t = t.BaseType, ++promotionIndex);

                if (t == null)
                {
                    throw EntityUtil.InternalError(EntityUtil.InternalErrorCode.FailedToGeneratePromotionRank, 2);
                }

                return -promotionIndex;
            }

            throw EntityUtil.InternalError(EntityUtil.InternalErrorCode.FailedToGeneratePromotionRank, 3);
        }
    }
}