using System;

using System.Collections.Generic;

using System.Collections.Specialized;

using System.ComponentModel.DataAnnotations.Schema;

using System.Data.Objects.DataClasses;

using System.Globalization;

using System.Linq;

using System.Reflection;

using System.Linq.Expressions;

​

namespace GAP.Models {

​

    /// <summary>

    /// The data required to display a set of search results

    /// </summary>

    /// <typeparam name="T"></typeparam>

    public struct SearchFilterResultsData<T> {

        public int? Count;

        public IEnumerable<T> Results;

        public bool HasCount { get { return Count.HasValue; } }

    }

​

    /// <summary>

    /// A sortable paged list

    /// </summary>

    public class SortPager : Pager {

        /// <summary>

        /// The property to search on

        /// </summary>

        public string SortField { get; set; }

​

        /// <summary>

        /// The direction of the sort

        /// </summary>

        public bool SortDescending { get; set; }

    }

​

    /// <summary>

    /// A sortable paged filtered list

    /// </summary>

    public class SearchFilter : SortPager {

​

        /// <summary>

        /// The search filter parameters propertyName : searchQuery

        /// </summary>

        public Dictionary<string, string> Search { get; set; }

​

        /// <summary>

        /// Operations that can be used in each search filter

        /// </summary>

        protected enum Operations {

            Equals = 0,

            GreaterThanOrEqual = 1,

            LessThanOrEqual = 2,

            GreaterThan = 3,

            LessThan = 4,

            Between = 5

        }

​

        /// <summary>

        /// The string version of Operations at correlated indexes

        /// </summary>

        protected static readonly string[] Operators = new[] { "=", ">=", "<=", ">", "<", " - " };

​

    }

​

    /// <summary>

    /// A sortable paged list

    /// </summary>

    public class SortPager<T> : SearchFilter {

​

        /// <summary>

        /// Returns a sorted version of the specified list using the current search parameters

        /// </summary>

        /// <param name="list"></param>

        /// <returns></returns>

        public IOrderedQueryable<T> Sort(IQueryable<T> list) {

            string sortField = SortField ?? GetPrimaryKeyName();

            if (sortField == null) return list.OrderBy(x => true);

            return Sort(list, sortField, SortDescending);

        }

​

        /// <summary>

        /// Returns a sorted version of the specified list using the specified search parameters

        /// </summary>

        /// <param name="query"></param>

        /// <param name="memberName"></param>

        /// <param name="sortDescending"></param>

        /// <returns></returns>

        public IOrderedQueryable<T> Sort(IQueryable<T> query, string memberName, bool sortDescending) {

​

            PropertyInfo pi = typeof(T).GetProperty(memberName);

            if (pi == null) throw new ArgumentException(String.Format("Order By property {0} not found on object", memberName));

​

            var typeParams = new[] { Expression.Parameter(typeof(T), "") };

​

            return (IOrderedQueryable<T>)query.Provider.CreateQuery(

                Expression.Call(

                    typeof(Queryable),

                    sortDescending ? "OrderByDescending" : "OrderBy",

                    new[] { typeof(T), pi.PropertyType },

                    query.Expression,

                    Expression.Lambda(Expression.Property(typeParams[0], pi), typeParams))

            );

        }

​

        /// <summary>

        /// Checks against EF properties to try and automatically get the primary key

        /// </summary>

        /// <returns></returns>

        public string GetPrimaryKeyName() {

​

            // find the primary key of T from entityframework

            foreach (var property in typeof(T).GetProperties()) {

                var attributes = property.GetCustomAttributes(false);

                if (attributes.OfType<EdmScalarPropertyAttribute>().FirstOrDefault(a => a.EntityKeyProperty) != null) {

                    return property.Name;

                }

                if (attributes.OfType<DatabaseGeneratedAttribute>().FirstOrDefault(a => a.DatabaseGeneratedOption == DatabaseGeneratedOption.Identity) != null) {

                    return property.Name;

                }

            }

            return default(string);

        }

    }

​

    /// <summary>

    /// An exception thrown when trying to create a search filter

    /// </summary>

    [Serializable]

    public class SearchFilterException : ArgumentOutOfRangeException {

        public string[] ErrorFields { get; set; }

        public string ShowPopupMessage { get; set; }

    }

​

​

    public interface ISearchFilter {

​

        /// <summary>

        /// The search filter parameters propertyName : searchQuery

        /// </summary>

        Dictionary<string, string> Search { get; set; }

​

​

        /// <summary>

        /// 

        /// </summary>

        string JsonDictionary { get; set; }

​

​

        /// <summary>

        /// The property to search on

        /// </summary>

        string SortField { get; set; }

​

        /// <summary>

        /// The direction of the sort

        /// </summary>

        bool SortDescending { get; set; }

​

        /// <summary>

        /// The number of records to skip at the start

        /// </summary>

        int Skip { get; set; }

​

        /// <summary>

        /// The number of records to return

        /// </summary>

        int Take { get; set; }

    }

​

    /// <summary>

    /// Filters an IQueryable of T based on user specified search parameters

    /// </summary>

    /// <typeparam name="T"></typeparam>

    public class SearchFilter<T> : SortPager<T>, ISearchFilter {

​

        public SearchFilter() {}

​

        public SearchFilter(ISearchFilter parameters) {

            Search = parameters.Search;

            SortField = parameters.SortField;

            SortDescending = parameters.SortDescending;

            Skip = parameters.Skip;

            Take = parameters.Take;

            JsonDictionary = parameters.JsonDictionary;

        }

​

        //public Dictionary<string, string> FilterErrors = new Dictionary<string, string>();

        public NameValueCollection FilterErrors = new NameValueCollection();

        public string ErrorMessagePopup { get; protected set; }

​

        /// <summary>

        /// Given a valid queryable will return a proper results set

        /// </summary>

        /// <param name="list">the queryable to filter from</param>

        /// <param name="getCount">when true, will also return the total number of matching results</param>

        /// <returns></returns>

        public SearchFilterResultsData<T> GetResults(IQueryable<T> list, bool getCount) {

            var results = Filter(list);

​

            return new SearchFilterResultsData<T> {

                Count = getCount ? (int?) results.Count() : null,

                Results = Sort(results).Skip(Skip).Take(Take).ToArray()

            };

        }

​

        /// <summary>

        /// Applies the stored filters to the specified list

        /// </summary>

        /// <param name="list"></param>

        /// <returns></returns>

        public IQueryable<T> Filter(IQueryable<T> list) {

​

            if (Search != null && Search.Count > 0) {

​

                Type t = typeof(T);

                foreach (string key in Search.Keys) {

​

                    string value;

                    if (Search.TryGetValue(key, out value)) {

​

                        // generate a filter expression and apply it

                        try {

                            if (value != "") {

                                list = list.Where(CreateFilterExpression(t, key, value));

                            }

                        }

                        catch (SearchFilterException ex) {

                            Array.ForEach(ex.ErrorFields, x => FilterErrors.Add(x, ex.Message));

                            if (!string.IsNullOrWhiteSpace(ex.ShowPopupMessage)) ErrorMessagePopup = ex.Message;

                        }

                        catch(FormatException ex) {

                            FilterErrors.Add(key, ex.Message);

                        }

                        catch(Exception ex) {

                            ErrorMessagePopup = ex.Message;

                        }

                    }

                }

            }

            return list;

        }

​

        /// <summary>

        /// Creates a expression which is used to filter T

        /// </summary>

        /// <param name="t"></param>

        /// <param name="propertyName"></param>

        /// <param name="value"></param>

        /// <returns></returns>

        protected Expression<Func<T, bool>> CreateFilterExpression(Type t, string propertyName, string value) {

​

            // get the property we're filtering against

            PropertyInfo propertyInfo = t.GetProperty(propertyName);

            if (propertyInfo == null) throw new InvalidOperationException(String.Format("Search parameters define a filter on {0}, but a property with that name doesn't exist in type {1}", propertyName, t));

​

            // parse the operation we're doing

            var opStr = "";

            var filterValueSource = value;

            var op = Operations.Equals;

            if (value.Contains(" - ")) {

                op = Operations.Between;

            } else {

                for (var bl = 0; bl < Operators.Length - 1; bl++) {

                    if (value.StartsWith(Operators[bl])) {

                        op = (Operations)bl;

                        opStr = Operators[bl];

                        filterValueSource = value.Substring(opStr.Length).Trim();

                        break;

                    }

                }

            }

​

            // turn the parsed operation into an expression tree

            ExpressionProvider filter;

            ExpressionValueParser parser = (type, s) => CreateConstantExpression(type, s.Trim());

​

            // ReSharper disable AccessToModifiedClosure

            switch (op) {

                default:

                    filter = (expression, type, s) => Expression.Equal(expression, parser(type, s));

                    break;

                case Operations.GreaterThan:

                    filter = (expression, type, s) => Expression.GreaterThan(expression, parser(type, s));

                    break;

                case Operations.GreaterThanOrEqual:

                    filter = (expression, type, s) => Expression.GreaterThanOrEqual(expression, parser(type, s));

                    break;

                case Operations.LessThan:

                    filter = (expression, type, s) => Expression.LessThan(expression, parser(type, s));

                    break;

                case Operations.LessThanOrEqual:

                    filter = (expression, type, s) => Expression.LessThanOrEqual(expression, parser(type, s));

                    break;

                case Operations.Between:

                    filter = (expression, type, filterValue) => {

                                var values = SplitBetweenStatement(filterValue);

                                return BetweenExpression(expression, parser(type, values.Item1), parser(type, values.Item2));

                             };

                    break;

            }

            // ReSharper restore AccessToModifiedClosure

​

            // override custom behaviour for certain types

            var fieldType = propertyInfo.GetGetMethod().ReturnType;

            if (fieldType == typeof(String)) {

​

                // make string search the default provided they weren't explicit about equality

                if (op == Operations.Equals && (opStr == string.Empty)) {

                    filter = CreateStringSearchLambda;

                }

​

            } else if ((fieldType == typeof(DateTime)) || (fieldType == typeof(DateTime?))) {

​

                // change the parser to one that converts to local time

                parser = (type, s) => CreateConstantExpression(fieldType, ParseDate(s));

​

                // if no time component is specified we search the whole date (the whole 24hrs) using a between

                if (op == Operations.Equals) {

​

                    // parse the date using no modifiers so we don't convert it to including a time

                    var minDate = ParseDateLocal(filterValueSource);

                    if (minDate.Hour == 0 && minDate.Minute == 0 && minDate.Second == 0) {

                        // they weren't explicit about the time - get a range and use that

                        var values = GetDateTimeMinMaxValues(filterValueSource);

                        filter = (expression, type, filterValue) => BetweenExpression(expression, Expression.Constant(values.Item1, type), Expression.Constant(values.Item2, type));

                    }

​

                } else if (op == Operations.Between) {

​

                    // get the range items

                    var values = SplitBetweenStatement(filterValueSource);

                    // get min and max for each

                    var minValues = GetDateTimeMinMaxValues(values.Item1);

                    var maxValues = GetDateTimeMinMaxValues(values.Item2);

​

                    // then use minmin and maxmax to get the outermost bounds

                    filter = (expression, type, filterValue) => BetweenExpression(expression, Expression.Constant(minValues.Item1, type), Expression.Constant(maxValues.Item2, type));

                }

​

            } else if ((fieldType == typeof(Decimal)) || (fieldType == typeof(Decimal?))) {

                // replace all equality comparisons with one that ensures it includes numbers rounded for display

                if (op == Operations.Equals) {

                    var values = GetDecimalMinMaxValues(filterValueSource, 2);

                    filter = (expression, type, filterValue) => BetweenExpression(expression, Expression.Constant(values.Item1, type), Expression.Constant(values.Item2, type));

​

                } else if (op == Operations.Between) {

​

                    // get the range items

                    var values = SplitBetweenStatement(filterValueSource);

                    // get min and max for each

                    var minValues = GetDecimalMinMaxValues(values.Item1, 2);

                    var maxValues = GetDecimalMinMaxValues(values.Item2, 2);

​

                    // then use minmin and maxmax to get the outermost bounds

                    filter = (expression, type, filterValue) => BetweenExpression(expression, Expression.Constant(minValues.Item1, type), Expression.Constant(maxValues.Item2, type));

                }

​

            } else if ((fieldType == typeof (Boolean)) || (fieldType == typeof (Boolean?))) {

​

                // parse various different strings into a bool

                parser = (type, s) => CreateConstantExpression(fieldType, ParseBoolean(s));

                // always use an equality

                filter = (expression, type, s) => Expression.Equal(expression, parser(type, s));

​

            }

​

            // create a lambda to apply the filter to a member access call to the property

            ParameterExpression parameterExpression = Expression.Parameter(t, propertyName + "SearchFilterExpression");

            MemberExpression memberExpression = Expression.Property(parameterExpression, propertyInfo);

            return Expression.Lambda<Func<T, bool>>(filter(memberExpression, fieldType, filterValueSource), parameterExpression);

        }

​

        protected Boolean ParseBoolean(string value) {

            switch (value.ToLower()) {

                case "1":

                case "yes":

                case "y":

                case "true":

                    return true;

                default:

                    return false;

            }

        }

​

​

        /// <summary>

        /// A filter expression against a property for the SearchFilter

        /// </summary>

        /// <param name="propertyExpression"></param>

        /// <param name="propertyType"></param>

        /// <param name="filterValue"></param>

        /// <returns></returns>

        protected delegate Expression ExpressionProvider(MemberExpression propertyExpression, Type propertyType, string filterValue);

​

        /// <summary>

        /// Parses a string into a ConstantExpression of the specified type

        /// </summary>

        /// <param name="fieldType"></param>

        /// <param name="value"></param>

        /// <returns></returns>

        protected delegate ConstantExpression ExpressionValueParser(Type fieldType, string value);

​

        /// <summary>

        /// Splits the given string into two sides of the between statement

        /// </summary>

        /// <param name="filterValue"></param>

        /// <returns></returns>

        private static Tuple<string, string> SplitBetweenStatement(string filterValue) {

            var values = filterValue.Split(new[] { Operators.Last() }, StringSplitOptions.RemoveEmptyEntries).Select(x => x.Trim()).Take(2).ToArray();

            return new Tuple<string, string>(values[0], values[1]);

        }

​

        /// <summary>

        /// Creates an expression that checks if the member falls between the specified range

        /// </summary>

        /// <param name="expression">the value to compare</param>

        /// <param name="minExpression">the min bound of the range</param>

        /// <param name="maxExpression">the max bound of the range</param>

        /// <returns></returns>

        private static BinaryExpression BetweenExpression(Expression expression, ConstantExpression minExpression, ConstantExpression maxExpression) {

            return Expression.And(Expression.GreaterThanOrEqual(expression, minExpression), Expression.LessThanOrEqual(expression, maxExpression));

        }

​

        /// <summary>

        /// Returns the highest and lowest numbers that the user probably meant when typing. Also accounts for rounding errors in display

        /// </summary>

        /// <param name="userInputString">the filter string typed by the user</param>

        /// <returns></returns>

        protected Tuple<DateTime, DateTime> GetDateTimeMinMaxValues(string userInputString) {

            var realDate = ParseDate(userInputString);

            return new Tuple<DateTime, DateTime>(realDate, realDate.AddDays(1));

        }

​

        /// <summary>

        /// Parses a date to UTC time

        /// </summary>

        /// <param name="value"></param>

        /// <returns></returns>

        protected DateTime ParseDate(string value) {

            DateTime result;

            if (!DateTime.TryParseExact(value, "d", CultureInfo.CurrentCulture, DateTimeStyles.AssumeLocal | DateTimeStyles.AdjustToUniversal, out result)) {

                result = DateTime.Parse(value, CultureInfo.CurrentCulture, DateTimeStyles.AssumeLocal | DateTimeStyles.AdjustToUniversal);

            }

            return result;

        }

​

        /// <summary>

        /// Parses a date in the same format as it's presented, used to check whether the user specified HH:MM:SS

        /// </summary>

        /// <param name="value"></param>

        /// <returns></returns>

        protected DateTime ParseDateLocal(string value) {

            DateTime result;

            if (!DateTime.TryParseExact(value, "d", CultureInfo.CurrentCulture, DateTimeStyles.None, out result)) {

                result = DateTime.Parse(value, CultureInfo.CurrentCulture, DateTimeStyles.None);

            }

            return result;

        }

​

        /// <summary>

        /// Returns the appropriate string searching method based on the presence of %s

        /// </summary>

        /// <param name="m"></param>

        /// <param name="fieldType"></param>

        /// <param name="value"></param>

        /// <returns></returns>

        protected MethodCallExpression CreateStringSearchLambda(MemberExpression m, Type fieldType, string value) {

​

            // find out which method we should apply (depending on presence of %s at the start and end)

            string methodName = "Contains";

​

            if (value.Length > 1) {

                if (value.StartsWith("%") && value.EndsWith("%")) {

                    // %search%

                    methodName = "Contains";

                    value = value.Substring(1, value.Length - 2);

                } else if (value.StartsWith("%")) {

                    // %search

                    methodName = "EndsWith";

                    value = value.Substring(1);

                } else if (value.EndsWith("%")) {

                    // search%

                    methodName = "StartsWith";

                    value = value.Substring(0, value.Length - 1);

                }

            }

            // apply the filter method

            MethodInfo method = typeof (string).GetMethod(methodName, new[] {typeof (string)});

            ConstantExpression someValue = Expression.Constant(value, typeof (string));

            return Expression.Call(m, method, new Expression[]{ someValue });

        }

​

​

        /// <summary>

        /// Returns the highest and lowest numbers that the user probably meant when typing. Also accounts for rounding errors in display

        /// </summary>

        /// <param name="userInputString">the filter string typed by the user</param>

        /// <param name="numDisplayDecimalPlaces">the number of display decimal places which presented to the user</param>

        /// <returns></returns>

        protected Tuple<Decimal, Decimal> GetDecimalMinMaxValues(string userInputString, int numDisplayDecimalPlaces) {

            var decimalValue = Decimal.Parse(userInputString);

            var numMantissaQueryDigits = userInputString.Trim().Length - Math.Floor(Math.Log10((double)Math.Abs(decimalValue)) + 1);

            if (userInputString.Contains(".")) numMantissaQueryDigits--;

            Decimal min;

            Decimal max;

            if (numMantissaQueryDigits < numDisplayDecimalPlaces) {

                min = decimalValue;

                max = min + (decimal)Math.Pow(10, -numMantissaQueryDigits);

            } else {

                var epsilon = (decimal)Math.Pow(10, -Math.Max(numMantissaQueryDigits, numDisplayDecimalPlaces)) / 2;

                min = decimalValue - epsilon;

                max = decimalValue + epsilon;

            }

            return new Tuple<Decimal, Decimal>(min, max);

        }

​

        /// <summary>

        /// Creates a constant of the specified type and value, parsing into nullables

        /// </summary>

        /// <param name="fieldType"></param>

        /// <param name="fieldValue"></param>

        /// <returns></returns>

        protected ConstantExpression CreateConstantExpression(Type fieldType, object fieldValue) {

​

            Type nfieldType;

            // see if it's nullable and if so use the base type

            if (fieldType.IsGenericType && fieldType.GetGenericTypeDefinition() == typeof(Nullable<>)) {

                nfieldType = Nullable.GetUnderlyingType(fieldType);

            } else {

                nfieldType = fieldType;

            }

​

            // convert to the required type

            object value = Convert.ChangeType(fieldValue, nfieldType);

​

            // and create a constantexpression

            return Expression.Constant(value, fieldType);

        }

​

​

​

        public string JsonDictionary { get; set; }

    }

​

}

​