using System;
using System.Collections.Generic;
using System.Linq;
using Luticate2.Utils.Dbo.Basic;
using Luticate2.Utils.Dbo.Filter;
using Luticate2.Utils.Dbo.OrderBy;
using Luticate2.Utils.Dbo.Result;
using Luticate2.Utils.Interfaces;

namespace Luticate2.Utils.Business
{
    public abstract class LuCrudBusiness<TDataAccess, TDboCreate, TDboRead, TDboUpdate, TId> :
            LuBusiness,
            ILuCrudInterface<TDboCreate, TDboRead, TDboUpdate, TId>
        where TDataAccess : ILuCrudInterface<TDboCreate, TDboRead, TDboUpdate, TId>
        where TDboCreate : class
        where TDboRead : class
        where TDboUpdate : class
    {
        protected readonly TDataAccess DataAccess;

        private readonly LuNotificationsBusiness _notificationsBusiness;

        protected virtual string EntityType { get; set; }

        protected LuCrudBusiness(TDataAccess dataAccess, LuNotificationsBusiness notificationsBusiness)
        {
            DataAccess = dataAccess;
            _notificationsBusiness = notificationsBusiness;
        }

        protected virtual LuResult<TDboCreate> CheckAdd(TDboCreate obj)
        {
            return LuResult<TDboCreate>.Ok(obj);
        }

        protected virtual LuResult<IEnumerable<TDboCreate>> CheckAdd(IEnumerable<TDboCreate> objs)
        {
            var list = new List<TDboCreate>();
            foreach (var obj in objs)
            {
                var res = CheckAdd(obj);
                if (!res)
                {
                    return res.To<IEnumerable<TDboCreate>>();
                }
                list.Add(res.Data);
            }
            return LuResult<IEnumerable<TDboCreate>>.Ok(list);
        }

        protected virtual LuResult<TDboUpdate> CheckEdit(TDboRead dbo, TDboUpdate update)
        {
            return LuResult<TDboUpdate>.Ok(update);
        }

        protected LuResult<TDboUpdate> GetAndCheckEdit(TId id, TDboUpdate update)
        {
            var res = GetSingleById(id);
            if (!res)
            {
                return res.To<TDboUpdate>();
            }
            return CheckEdit(res.Data, update);
        }




        public virtual LuResult<T> Add<T>(IEnumerable<TDboCreate> objs, Func<IEnumerable<TDboRead>, T> returnFunc)
        {
            var res = CheckAdd(objs);
            if (!res)
            {
                return res.To<T>();
            }
            return DataAccess.Add(res.Data, returnFunc);
        }

        public virtual LuResult<T> Add<T>(TDboCreate obj, Func<TDboRead, T> returnFunc)
        {
            var res = CheckAdd(obj);
            if (!res)
            {
                return res.To<T>();
            }
            var newEntity = DataAccess.AddDbo(res.Data);
            if (newEntity)
            {
                _notificationsBusiness.NotifyCreate(EntityType, newEntity.Data);
                return LuResult<T>.Ok(returnFunc(newEntity.Data));
            }
            return newEntity.To<T>();
        }

        public virtual LuResult<IEnumerable<TId>> AddId(IEnumerable<TDboCreate> objs)
        {
            return Add(objs, reads => reads.Select(read => (TId)((dynamic)read).Id));
        }

        public virtual LuResult<TId> AddId(TDboCreate obj)
        {
            return Add(obj, read => (TId)((dynamic)read).Id);
        }

        public virtual LuResult<IEnumerable<TDboRead>> AddDbo(IEnumerable<TDboCreate> objs)
        {
            return Add(objs, reads => reads);
        }

        public virtual LuResult<TDboRead> AddDbo(TDboCreate obj)
        {
            return Add(obj, read => read);
        }




        public virtual LuResult<TDboRead> GetSingleById(TId id)
        {
            return DataAccess.GetSingleById(id);
        }


        public virtual LuResult<LuPaginatedDbo<TDboRead>> GetMultiple(LuOrderByDbo orderBy, LuFilterDbo filter,
            int page = 0, int perPage = int.MaxValue)
        {
            return DataAccess.GetMultiple(orderBy, filter, page, perPage);
        }

        public virtual LuResult<LuPaginatedDbo<TDboRead>> GetMultiple(LuOrderByDbo orderBy, int page = 0,
            int perPage = int.MaxValue)
        {
            return DataAccess.GetMultiple(orderBy, page, perPage);
        }




        public virtual LuResult<T> EditSingleById<T>(TId id, TDboUpdate update, Func<TDboRead, T> returnFunc)
        {
            var originalEntity = GetSingleById(id);
            if (!originalEntity)
            {
                return originalEntity.To<T>();
            }

            var obj = CheckEdit(originalEntity.Data, update);
            if (!obj)
            {
                return obj.To<T>();
            }
            var editedEntity = DataAccess.EditSingleByIdDbo(id, obj.Data);
            if (editedEntity)
            {
                _notificationsBusiness.NotifyUpdate(EntityType, originalEntity.Data, editedEntity.Data);
                return LuResult<T>.Ok(returnFunc(editedEntity.Data));
            }
            return editedEntity.To<T>();
        }

        public virtual LuResult<TId> EditSingleByIdId(TId id, TDboUpdate update)
        {
            return EditSingleById(id, update, read => (TId)((dynamic)read).Id);
        }

        public virtual LuResult<TDboRead> EditSingleByIdDbo(TId id, TDboUpdate update)
        {
            return EditSingleById(id, update, read => read);
        }




        public virtual LuResult<T> DeleteSingleById<T>(TId id, Func<TDboRead, T> returnFunc)
        {
            var originalEntity = GetSingleById(id);
            if (!originalEntity)
            {
                return originalEntity.To<T>();
            }
            var res = DataAccess.DeleteSingleById(id, returnFunc);
            if (res)
            {
                _notificationsBusiness.NotifyDelete(EntityType, originalEntity.Data);
            }
            return res;
        }

        public virtual LuResult<TId> DeleteSingleByIdId(TId id)
        {
            return DeleteSingleById(id, read => (TId)((dynamic)read).Id);
        }

        public virtual LuResult<TDboRead> DeleteSingleByIdDbo(TId id)
        {
            return DeleteSingleById(id, read => read);
        }
    }
}