public static bool TryFactorizeCondition()

in src/Epam.GraphQL/Helpers/ExpressionHelpers.cs [180:251]
60 lines of code
12 McCabe index (conditional complexity)

        public static bool TryFactorizeCondition<T1, T2>(Expression<Func<T1, T2, bool>> expression, [NotNullWhen(true)] out ConditionFactorizationResult<T2>? result)
        {
            var factorizationResult = Factorize(expression);

            if (factorizationResult.LeftExpressions.Count == 1 && factorizationResult.RightExpressions.Count != 0)
            {
                var leftExpression = factorizationResult.LeftExpressions[0];
                LambdaExpression? rightExpression = null;
                Expression<Func<T2, bool>>? rightCondition = null;

                var operands = GetAndAlsoExpressions(factorizationResult.Expression.Body);
                var parameters = factorizationResult.Expression.Parameters;
                var leftParam = parameters[0];

                var equalOperand = operands.Single(op => op.ContainsParameter(leftParam));

                if (equalOperand.NodeType == ExpressionType.Equal)
                {
                    var index = -1;
                    for (int i = 0; i < parameters.Count - 1; i++)
                    {
                        if (equalOperand.ContainsParameter(parameters[i + 1]))
                        {
                            index = i;
                            break;
                        }
                    }

                    if (index != -1)
                    {
                        var rightExpressions = factorizationResult.RightExpressions;
                        Expression? left = null;
                        var param = Expression.Parameter(typeof(T2));

                        for (int i = 0; i < rightExpressions.Count; i++)
                        {
                            if (i != index)
                            {
                                var right = ParameterRebinder<Expression, ParameterExpression>.ReplaceParameter(rightExpressions[i].Body, rightExpressions[i].Parameters[0], param);

                                if (left == null)
                                {
                                    left = right;
                                    continue;
                                }

                                left = Expression.AndAlso(left, right);
                            }
                            else
                            {
                                rightExpression = rightExpressions[i];
                            }
                        }

                        if (left != null)
                        {
                            rightCondition = Expression.Lambda<Func<T2, bool>>(left, param);
                        }

                        if (rightExpression != null)
                        {
                            result = new ConditionFactorizationResult<T2>(leftExpression, rightExpression, rightCondition);
                            return true;
                        }
                    }
                }
            }

            result = null;

            return false;
        }