using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using Luticate2.Auth.Utils.Business.Converters;
using Luticate2.Auth.Utils.Business.ExpressionConverter;
using Luticate2.Auth.Utils.Dbo;
using Luticate2.Auth.Utils.Dbo.Fields;
using Luticate2.Auth.Utils.Dbo.Pagination;
using Luticate2.Auth.Utils.Dbo.Result;
using Luticate2.Auth.Utils.Interfaces;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;

namespace Luticate2.Auth.Utils.Business.Crud
{
    public class LuEfCrudBusiness<TDbo, TModel, TDbContext> : ILuCrud<TDbo>
        where TModel : class
        where TDbContext : DbContext
        where TDbo : class, new()
    {
        protected IServiceProvider ServiceProvider { get; }

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

        protected virtual ILuObjectConverterOptions GetOptions()
        {
            return new LuConvertersOptions();// TODO
        }

        protected virtual LuResult<TModel> ConvertDboToModel(LuPartialFieldsDbo partialInput, TDbo dbo)
        {
            var copier = ServiceProvider.GetService<ILuObjectConverter<TDbo, TModel>>();
            if (copier == null)
            {
                return LuResult<TModel>.Error(LuStatus.InternalError.ToInt(),
                    $"Could not get service: {nameof(ILuObjectConverter)}<{typeof(TDbo).Name}, {typeof(TModel).Name}>");
            }
            var result = copier.Convert(dbo, new LuFieldDbo(), partialInput, GetOptions());
            return result.Select(o => o as TModel);
        }

        protected virtual LuResult<TDbo> ConvertModelToDbo(LuPartialFieldsDbo partialResponse, TModel model)
        {
            var copier = ServiceProvider.GetService<ILuObjectConverter<TModel, TDbo>>();
            if (copier == null)
            {
                return LuResult<TDbo>.Error(LuStatus.InternalError.ToInt(),
                    $"Could not get service: {nameof(ILuObjectConverter)}<{typeof(TModel).Name}, {typeof(TDbo).Name}>");
            }
            var result = copier.Convert(model, new LuFieldDbo(), partialResponse, GetOptions());
            return result.Select(o => o as TDbo);
        }

        protected virtual LuResult<T> HandleError<T>(Exception e)
        {
            return LuResult<T>.Error(LuStatus.DbError.ToInt(), e);
        }

        protected LuResult<T> Execute<T>(Func<TDbContext, DbSet<TModel>, LuResult<T>> action)
        {
            try
            {
                using (var db = ServiceProvider.GetService<TDbContext>())
                {
                    return action(db, db.Set<TModel>());
                }
            }
            catch (Exception e)
            {
                var result = HandleError<T>(e);
                return result;
            }
        }

        protected virtual LuResult<IQueryable<TModel>> Include(LuPartialFieldsDbo partialResponse, IQueryable<TModel> queryable)
        {
            return LuResult<IQueryable<TModel>>.Ok(queryable);
        }

        protected virtual LuResult<IQueryable<TModel>> Filter(LuFilterDbo filter, IQueryable<TModel> queryable)
        {
            var lamdbaDbo = (Expression<Func<TDbo, bool>>) filter.Expression;

            var options = new LuConvertersOptions
            {
                Parameters = new Dictionary<ParameterExpression, Expression>(), // TODO
                TypeConverter = null, // TODO
                Allocator = null // TODO
            };
            var converter = new LuExpressionConverterVisitor(options, ServiceProvider);
            var lamdbaModel = converter.Visit(lamdbaDbo) as Expression<Func<TModel, bool>>;// TODO Handle errors
            return LuResult<IQueryable<TModel>>.Ok(queryable.Where(lamdbaModel));
        }

        protected virtual LuResult<IQueryable<TModel>> OrderByField(LuOrderByFieldDbo orderByfield, IQueryable<TModel> queryable)
        {
//            var expressionBuilder = ServiceProvider.GetService<ILuDboModelExpressionConverter<TDbo, TModel>>();
//            var expressionResult = expressionBuilder.ConvertLamdba<TModel>(orderByfield.);
//            if (!expressionResult)
//            {
//                return expressionResult.To<IQueryable<TModel>>();
//            }
//
//            var expression = expressionResult.Data;
//            var expressionNoConvert = LuExpressionUtils.GetFromConvert(expression);
//
//            var ordered = queryable.OrderBy(expressionNoConvert);
//
//            return LuResult<IQueryable<TModel>>.Ok(ordered);
            return LuResult<IQueryable<TModel>>.Ok(queryable);
        }

        protected virtual LuResult<IQueryable<TModel>> OrderBy(LuOrderByDbo orderBy, IQueryable<TModel> queryable)
        {
            var ordered = queryable;
            foreach (var field in orderBy.OrderByFields)
            {
                var orderedResult = OrderByField(field, ordered);
                if (!orderedResult)
                {
                    return orderedResult.To<IQueryable<TModel>>();
                }

                ordered = orderedResult.Data;
            }

            return LuResult<IQueryable<TModel>>.Ok(ordered ?? queryable);
        }

        protected virtual LuResult<IQueryable<TModel>> Paginate(int page, int perPage, IQueryable<TModel> queryable)
        {
            var paginated = queryable.Skip(page * perPage).Take(perPage);
            return LuResult<IQueryable<TModel>>.Ok(paginated);
        }

        public virtual LuResult<IList<TDbo>> Create(LuPartialFieldsDbo partialResponse, LuPartialFieldsDbo partialInput, IEnumerable<TDbo> dbos)
        {
            throw new NotImplementedException();
        }

        public virtual LuResult<LuPaginatedDbo<TDbo>> Read(LuPartialFieldsDbo partialResponse, LuPaginatedParamsDbo paginationParams)
        {
            var result = Execute((context, set) =>
            {
                var includeResult = Include(partialResponse, set);
                if (!includeResult)
                {
                    return includeResult.To<LuPaginatedDbo<TDbo>>();
                }

                var included = includeResult.Data;

                var orderByResult = OrderBy(paginationParams.OrderBy, included);
                if (!orderByResult)
                {
                    return orderByResult.To<LuPaginatedDbo<TDbo>>();
                }

                var ordered = orderByResult.Data;
                
                var filteredResult = Filter(paginationParams.Filter, ordered);
                if (!filteredResult)
                {
                    return filteredResult.To<LuPaginatedDbo<TDbo>>();
                }

                var filtered = filteredResult.Data;
                var count = filtered.Count();

                var paginatedResult = Paginate(paginationParams.Page, paginationParams.PerPage, filtered);
                if (!paginatedResult)
                {
                    return paginatedResult.To<LuPaginatedDbo<TDbo>>();
                }

                var paginated = paginatedResult.Data;

                var data = paginated.AsEnumerable().Select(model =>
                    {
                        var convertResult = ConvertModelToDbo(partialResponse, model); // TODO Handle error
                        return convertResult.Data;
                    }).ToList();

                return LuResult<LuPaginatedDbo<TDbo>>.Ok(new LuPaginatedDbo<TDbo>
                {
                    Count = count,
                    Data = data
                });
            });
            return result;
        }

        public virtual LuResult<IList<TDbo>> Update(LuPartialFieldsDbo partialResponse, LuPartialFieldsDbo partialInput, IEnumerable<TDbo> dbos)
        {
            throw new NotImplementedException();
        }

        public virtual LuResult<IList<TDbo>> Delete(LuPartialFieldsDbo partialResponse, LuPartialFieldsDbo partialInput, IEnumerable<TDbo> dbos)
        {
            throw new NotImplementedException();
        }
    }
}