using System;
using System.Collections.Generic;
using System.Linq.Expressions;

namespace JSMachine.WMS.Infrastructure.LambdaHelp
{
    public static class LambdaBuider<T>
    {
        public static Expression<Func<T, bool>> BuildExpreesion(FilterCollection filters)
        {
            Expression<Func<T, bool>> baseExpression = t => false;



            if (filters == null || filters.Count == 0)
                return t => true;

            List<Expression<Func<T, bool>>> orExpressions = new List<Expression<Func<T, bool>>>();

            for (int i = 0; i < filters.Count; i++)
            {
                for (int j = 0; j < filters[i].Count; j++)
                {
                    string propName = filters[i][j].PropertyName;
                    object value = filters[i][j].Value;

                    switch (filters[i][j].Operation)
                    {
                        case Op.NULL:
                            {
                                if (typeof(T).GetProperty(propName).PropertyType == typeof(int) || typeof(T).GetProperty(propName) == typeof(long))
                                {
                                    baseExpression = baseExpression.Or(LambdaHelper<T>.CreateEqual(propName, 0));
                                }
                                else
                                {
                                    baseExpression = baseExpression.Or(LambdaHelper<T>.Null(propName));
                                }
                            }; break;
                        case Op.NOTNUL:
                            {
                                if (typeof(T).GetProperty(propName).PropertyType == typeof(int) || typeof(T).GetProperty(propName) == typeof(long))
                                {
                                    baseExpression = baseExpression.Or(LambdaHelper<T>.CreateNotEqual(propName, 0));
                                }
                                else
                                {
                                    baseExpression = baseExpression.Or(LambdaHelper<T>.NotNull(propName));
                                }
                            }; break;
                        case Op.Equals: baseExpression = baseExpression.Or(LambdaHelper<T>.CreateEqual(propName, value)); break;
                        case Op.NotEquals: baseExpression = baseExpression.Or(LambdaHelper<T>.CreateNotEqual(propName, value)); break;
                        case Op.GreaterThan: baseExpression = baseExpression.Or(LambdaHelper<T>.CreateGreaterThan(propName, value)); break;
                        case Op.LessThan: baseExpression = baseExpression.Or(LambdaHelper<T>.CreateLessThan(propName, value)); break;
                        case Op.GreaterThanOrEqual: baseExpression = baseExpression.Or(LambdaHelper<T>.CreateGreaterThanOrEqual(propName, value)); break;
                        case Op.LessThanOrEqual: baseExpression = baseExpression.Or(LambdaHelper<T>.CreateLessThanOrEqual(propName, value)); break;
                        case Op.Contains: baseExpression = baseExpression.Or(LambdaHelper<T>.GetContains(propName, value)); break;
                        case Op.NotContains: baseExpression = baseExpression.Or(LambdaHelper<T>.GetNotContains(propName, value)); break;
                        case Op.StartsWith: baseExpression = baseExpression.Or(LambdaHelper<T>.GetStartsWith(propName, value)); break;
                        case Op.EndsWith: baseExpression = baseExpression.Or(LambdaHelper<T>.GetEndsWith(propName, value)); break;
                        case Op.In: baseExpression = baseExpression.Or(LambdaHelper<T>.GetIn(propName, value)); break;
                    }
                }

                orExpressions.Add(baseExpression);
                baseExpression = p => false;
            }

            Expression<Func<T, bool>> resultExpression = p => true;
            orExpressions.ForEach(x =>
            {
                resultExpression = resultExpression.And(x);
            });

            return resultExpression;
        }
    }
}