using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using Luticate2.Auth.Dbo;
using Luticate2.Auth.Dbo.Result;
using Luticate2.Auth.Interfaces;

namespace Luticate2.Auth.Business.Fields.DMEC
{
    public class LuExpressionConverterEnumerable : ILuExpressionConverter
    {
        public IServiceProvider ServiceProvider { get; }

        public LuExpressionConverterEnumerable(IServiceProvider serviceProvider)
        {
            ServiceProvider = serviceProvider;
        }

        protected LuResult<Expression> ConvertOther(Type typeFrom, Stack<Expression> expressions, Expression baseExpression, LuExpressionConverterOptions options)
        {
            var type = typeof(ILuExpressionConverter<>);
            var gtype = type.MakeGenericType(typeFrom);
            var converter = (ILuExpressionConverter) ServiceProvider.GetService(gtype);
            if (converter == null)
            {
                return LuResult<Expression>.Error(LuStatus.InternalError.ToInt(), $"Could not get service: {gtype}>");
            }

            return converter.ConvertExpression(expressions, baseExpression, options);
        }

        public LuResult<Expression> ConvertExpression(Stack<Expression> expressions, Expression baseExpression, LuExpressionConverterOptions options)
        {
            if (!expressions.Any())
            {
                return LuResult<Expression>.Ok(baseExpression);
            }

            var expression = expressions.Pop();
            if (expression is MethodCallExpression methodCallExpression)
            {
                var argumentsModel = new List<Expression>();
                foreach (var argumentDbo in methodCallExpression.Arguments)
                {
                    var converter = new LuExpressionConverterVisitor(options, ServiceProvider);
                    var result = converter.Visit(argumentDbo);
                    argumentsModel.Add(result);
                }

                var newExpression = Expression.Call(baseExpression, methodCallExpression.Method, argumentsModel);
                return ConvertOther(newExpression.Type, expressions, newExpression, options);
            }

            return LuResult<Expression>.Error(LuStatus.InternalError.ToInt(), "Not supported expression");
        }
    }
}