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

namespace PoweredSoft.DynamicLinq.Helpers
{
    public class ExpressionParameterGroup
    {
        public ExpressionParameterGroup Parent { get; set; }
        public ParameterExpression Parameter { get; set; }
        public List<ExpressionPiece> Pieces { get; set; } = new List<ExpressionPiece>();

        public ExpressionParameterGroup(ParameterExpression parameter)
        {
            Parameter = parameter;
        }

        public void AddSubPart(ExpressionPiece expressionPart)
        {
            Pieces.Add(expressionPart);
        }

        public Expression LastExpression() => LastPiece().Expression;

        public ExpressionPiece LastPiece() => Pieces.Last();

        public LambdaExpression CreateLambda()
        {
            var lastExpression = LastPiece().Expression;
            var lambda = Expression.Lambda(lastExpression, Parameter);
            return lambda;
        }
    }

    public class ExpressionPiece
    {
        public ExpressionParameterGroup Parameter { get; set; }
        public ExpressionPiece Parent { get; set; }
        public Expression Expression { get; set; }

        public ExpressionPiece(ExpressionParameterGroup parameter, ExpressionPiece parent = null)
        {
            Parameter = parameter;
            Parent = parent;
        }

        public void Resolve(string piece)
        {
            Expression = Expression.PropertyOrField(Parent?.Expression ?? Parameter.Parameter, piece);
        }

        public bool IsGenericEnumerable() => QueryableHelpers.IsGenericEnumerable(Expression);
        public Type GetGenericEnumerableType() => Expression.Type.GenericTypeArguments.First();
    }

    public class ExpressionParser
    {
        public ParameterExpression Parameter { get; protected set; }
        public string Path { get; protected set; }
        public List<ExpressionParameterGroup> Groups { get; set; } = new List<ExpressionParameterGroup>();

        public ExpressionParser(Type type, string path) : this(Expression.Parameter(type), path)
        {
            
        }

        public ExpressionParser(ParameterExpression parameter, string path)
        {
            if (parameter == null)
                throw new ArgumentNullException("parameter");

            if (string.IsNullOrEmpty(path))
                throw new ArgumentNullException("path");

            Parameter = parameter;
            Path = path;
        }
        
        public void Parse()
        {
            Groups = new List<ExpressionParameterGroup>();
            var pieces = Path.Split('.').ToList();

            // create the current parameter.
            var currentGroup = CreateAndAddParameterGroup(Parameter);
            ExpressionPiece parentPiece = null;

            int indexOfPiece = -1;
            pieces.ForEach(piece =>
            {
                ++indexOfPiece;
                bool isLast = indexOfPiece == pieces.Count - 1;

                var expressionPiece = new ExpressionPiece(currentGroup, parentPiece);
                expressionPiece.Resolve(piece);
                currentGroup.AddSubPart(expressionPiece);

                // rest is only if its not the last piece.
                if (isLast) return;

                if (expressionPiece.IsGenericEnumerable())
                {
                    var param = Expression.Parameter(expressionPiece.GetGenericEnumerableType());
                    currentGroup = CreateAndAddParameterGroup(param, currentGroup);
                    parentPiece = null;
                }
                else
                {
                    parentPiece = expressionPiece;
                }
            });           
        }

        public ExpressionParameterGroup CreateAndAddParameterGroup(ParameterExpression parameter, ExpressionParameterGroup parent = null)
        {
            var group = new ExpressionParameterGroup(parameter);

            if (parent != null)
                group.Parent = parent;

            Groups.Add(group);
            return group;
        }
    }

    public class ExpressionPathPart
    {
        public Expression ParentExpression { get; set; }
        public ParameterExpression ParameterExpression { get; set; }
        public Expression PartExpression { get; set; }

        public bool IsNullable() => TypeHelpers.IsNullable(PartExpression.Type);
   
        public bool IsGenericEnumerable() => QueryableHelpers.IsGenericEnumerable(PartExpression);
        public Type GenericEnumerableType() => PartExpression.Type.GenericTypeArguments.First();
        public bool IsCallingMethod() => PartExpression is MethodCallExpression;
        public Type GetToListType() => IsGenericEnumerable() ? GenericEnumerableType() : PartExpression.Type;
        public bool IsParentGenericEnumerable() => QueryableHelpers.IsGenericEnumerable(ParentExpression);

        public static List<ExpressionPathPart> Split(ParameterExpression param, string path)
        {
            var ret = new List<ExpressionPathPart>();

            var parts = path.Split('.').ToList();
            Expression parent = param;
            parts.ForEach(part =>
            {
                var p = new ExpressionPathPart();
                p.PartExpression = Expression.PropertyOrField(parent, part);
                p.ParentExpression = parent;
                p.ParameterExpression = param;
                ret.Add(p);

                if (p.IsGenericEnumerable())
                {
                    param = Expression.Parameter(p.GenericEnumerableType());
                    parent = param;
                }
                else
                {
                    parent = p.PartExpression;
                }
            });

            return ret;
        }

        public LambdaExpression GetLambdaExpression()
        {
            var lambda = Expression.Lambda(PartExpression, ParameterExpression);
            return lambda;
        }

        public Type ParentGenericEnumerableType() => ParentExpression.Type.GenericTypeArguments.First();

    }
}