using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using AutoMapper;
using BaseTrade.Integration.Oos94FZ.Domain.Data.Model;
using BaseTrade.Integration.Oos94FZ.Domain.EFRepositoryInterfaces;
using BaseTrade.Integration.Oos94FZ.WcfServices.Contracts.Oos94FZService.Messaging.Revision;
using Public.Common.Extensions;

namespace BaseTrade.Integration.Oos94FZ.AppServices.RevisionService
{
    public interface IRevisionFacade
    {
        Task<RevisionResult> HandleAsync(RevisionInfoDto revision);
    }

    public sealed class RevisionFacade : IRevisionFacade
    {
        private readonly IEnumerable<IRevisionHandler> _revisionHandlers;

        public RevisionFacade(IEnumerable<IRevisionHandler> revisionHandlers)
        {
            _revisionHandlers = revisionHandlers;
        }

        public Task<RevisionResult> HandleAsync(RevisionInfoDto revision)
        {
            var type = revision.GetType();
            var handler = _revisionHandlers.FirstOrDefault(x => x.CanHandle(type)) ??
                throw new InvalidOperationException($"Для удалось найти обработчик для {type.Name}.");

            return handler.HandleAsync(revision);
        }
    }

    public interface IRevisionProcessor
    {
        Task ProcessAsync(RevisionInfoDto[] revisions);
    }

    public sealed class RevisionProcessor : IRevisionProcessor
    {
        private readonly IRevisionFacade _facade;
        private readonly IIntegrationRepository<PackageImportMismatch> _repository;

        public RevisionProcessor(IRevisionFacade facade, IIntegrationRepository<PackageImportMismatch> repository)
        {
            _facade = facade;
            _repository = repository;
        }

        public async Task ProcessAsync(RevisionInfoDto[] revisions)
        {
            var results = new List<RevisionResult>();

            foreach (var revision in revisions)
                results.Add(await _facade.HandleAsync(revision));

            var mismatches = results
                .Where(x => x.Errors.IsNotEmpty())
                .Select(x => Mapper.Map(x, Mapper.Map<PackageImportMismatch>(x)))
                .ToArray();

            if (mismatches.IsEmpty())
                return;

            _repository.AddMany(mismatches);
        }
    }

    public sealed class RevisionResult
    {
        public List<string> Errors { get; set; }
    }

    public interface IRevisionHandler
    {
        Task<RevisionResult> HandleAsync(object revision);

        bool CanHandle(Type type);
    }

    public interface IRevisionHandler<in TRevision> : IRevisionHandler where TRevision : RevisionInfoDto
    {
        Task<RevisionResult> HandleAsync(TRevision revision);
    }

    public abstract class RevisionHandler<T> : IRevisionHandler<T> where T : RevisionInfoDto
    {
        private readonly RevisionResult _revisionResult = new RevisionResult();

        public async Task<RevisionResult> HandleAsync(T revision)
        {
            await HandleRevisionAsync(revision);

            return _revisionResult;
        }

        public Task<RevisionResult> HandleAsync(object revision)
            => HandleAsync((T) revision);

        public bool CanHandle(Type type)
            => typeof(T) == type;

        public abstract Task HandleRevisionAsync(T revision);

        protected RevisionHandler<T> AddError(string error)
        {
            if (string.IsNullOrWhiteSpace(error))
                throw new ArgumentException(nameof(error));

            _revisionResult.Errors = _revisionResult.Errors ?? new List<string>();
            _revisionResult.Errors.Add(error);

            return this;
        }
    }

    public sealed class ContractRevisionHandler : RevisionHandler<ContractRevisionInfoDto>
    {
        public override Task HandleRevisionAsync(ContractRevisionInfoDto revision)
        {
            AddError("Ошибка по результату ревизии.");
            AddError("Ошибка по результату ревизии.");
            AddError("Ошибка по результату ревизии.");
            AddError("Ошибка по результату ревизии.");

            return Task.CompletedTask;
        }
    }

    public sealed class ProcedureRevisionHandler : RevisionHandler<ProcedureRevisionInfoDto>
    {
        public override Task HandleRevisionAsync(ProcedureRevisionInfoDto revision)
        {
            AddError("Ошибка по результату ревизии.");
            AddError("Ошибка по результату ревизии.");
            AddError("Ошибка по результату ревизии.");

            return Task.CompletedTask;
        }
    }

    public sealed class ProcedureCancellationRevisionHandler : RevisionHandler<ProcedureCancellationRevisionInfoDto>
    {
        public override Task HandleRevisionAsync(ProcedureCancellationRevisionInfoDto revision)
        {
            AddError("Ошибка по результату ревизии.");
            AddError("Ошибка по результату ревизии.");

            return Task.CompletedTask;
        }
    }
}