using MedicalDatabaseContracts;
using MedicalDatabaseContracts.Models;
using MedicalDatabaseContracts.SearchModels;
using MedicalDatabaseContracts.ViewModels;
using Microsoft.Extensions.Logging;

namespace MedicalBusinessLogic.BusinessLogics
{
    public abstract class AbstractLogic<M, V, S> : ILogic<M, V, S>
        where M : AbstractModel
        where V : AbstractViewModel
        where S : AbstractSearchModel
    {
        protected readonly ILogger<AbstractLogic<M, V, S>> _logger;
        protected readonly IStorage<M> _storage;

        protected AbstractLogic(ILogger<AbstractLogic<M, V, S>> logger, IStorage<M> storage)
        {
            _logger = logger;
            _storage = storage;
        }

        protected abstract void CheckModelIsValid(M model, bool modelUpdate = false);

        protected abstract bool CheckModelBySearchModel(M model, S searchModel);

        protected abstract V GetViewModel(M model);

        public bool DeleteAll(out double elapsedMilliseconds)
        {
            elapsedMilliseconds = 0;
            try
            {
                _storage.DeleteAll(out elapsedMilliseconds);
                _logger.LogInformation($"Delete ALL operation success");
                return true;
            }
            catch (Exception ex)
            {
                _logger.LogWarning($"Delete ALL operation failed: {ex.Message}");
                return false;
            }
        }

        public bool DeleteAll()
        {
            return DeleteAll(out _);
        }

        public bool Create(M model)
        {
            return Create(model, out _);
        }

        public bool Delete(int id)
        {
            return Delete(id, out _);
        }

        public V? ReadElement(int id)
        {
            return ReadElement(id, out _);
        }

        public List<V> ReadList(S? searchModel = null)
        {
            return ReadList(out _, searchModel);
        }

        public bool Update(M model)
        {
            return Update(model, out _);
        }

        public virtual List<V> ReadList(out double elapsedMilliseconds, S? searchModel = null)
        {
            var elements = _storage.GetAll(out elapsedMilliseconds);

            if (searchModel != null)
            {
                elements = elements.Where(x => CheckModelBySearchModel(x, searchModel)).ToList();
            }

            _logger.LogInformation($"ReadList count:{elements.Count}");
            return elements.Select(x => GetViewModel(x)).ToList();
        }

        public virtual V? ReadElement(int id, out double elapsedMilliseconds)
        {
            var element = _storage.Get(id, out elapsedMilliseconds);
            if (element == null)
            {
                _logger.LogWarning($"ReadElement record id:{id} failed: element not found");
                return null;
            }
            _logger.LogInformation($"ReadElement record id:{id} success");
            return GetViewModel(element);
        }

        public virtual bool Create(M model, out double elapsedMilliseconds)
        {
            elapsedMilliseconds = 0;
            try
            {
                CheckModelIsValid(model);
                _storage.Insert(model, out elapsedMilliseconds);
                _logger.LogInformation($"Insert operation success");
                return true;
            }
            catch (Exception ex)
            {
                _logger.LogWarning($"Insert operation failed: {ex.Message}");
                return false;
            }
        }

        public virtual bool Update(M model, out double elapsedMilliseconds)
        {
            elapsedMilliseconds = 0;
            try
            {
                CheckModelIsValid(model, true);
                _storage.Update(model, out elapsedMilliseconds);
                _logger.LogInformation($"Update record id:{model.Id} operation success");
                return true;
            }
            catch (Exception ex)
            {
                _logger.LogWarning($"Update record id:{model.Id} operation failed: {ex.Message}");
                return false;
            }
        }

        public virtual bool Delete(int id, out double elapsedMilliseconds)
        {
            elapsedMilliseconds = 0;
            try
            {
                _storage.Delete(id, out elapsedMilliseconds);
                _logger.LogInformation($"Delete operation success");
                return true;
            }
            catch (Exception ex)
            {
                _logger.LogWarning($"Delete operation failed: {ex.Message}");
                return false;
            }
        }
    }
}