using System;
using Luticate2.Utils.Dbo.Basic;
using Luticate2.Utils.Dbo.PaginatedRequest;
using Luticate2.Utils.Dbo.Result;
using Luticate2.Utils.Interfaces;
using Luticate2.Utils.Utils;

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 ILuNotificationsBusiness _notificationsBusiness;

        protected virtual string EntityType { get; set; }

        protected virtual Func<string, TDboRead, bool> NotifyCreateFilter { get; set; }

        protected virtual Func<string, TDboRead, TDboRead, bool> NotifyUpdateFilter { get; set; }

        protected virtual Func<string, TDboRead, bool> NotifyDeleteFilter { get; set; }

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

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

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

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


        public TId GetDboId(TDboRead obj)
        {
            return DataAccess.GetDboId(obj);
        }

        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,
                    NotifyCreateFilter != null ? s => NotifyCreateFilter(s, newEntity.Data) : (Func<string, bool>) null);
                return LuResult<T>.Ok(returnFunc(newEntity.Data));
            }
            return newEntity.To<T>();
        }




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


        public virtual LuResult<LuPaginatedDbo<TDboRead>> GetMultiple(LuPaginatedRequestDbo request)
        {
            return DataAccess.GetMultiple(request);
        }




        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,
                    NotifyUpdateFilter != null ? s => NotifyUpdateFilter(s, originalEntity.Data, editedEntity.Data) : (Func<string, bool>) null);
                return LuResult<T>.Ok(returnFunc(editedEntity.Data));
            }
            return editedEntity.To<T>();
        }




        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,
                    NotifyDeleteFilter != null ? s => NotifyDeleteFilter(s, originalEntity.Data) : (Func<string, bool>) null);
            }
            return res;
        }
    }
}