using System;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using AutoMapper;
using iTero.Application.Abstractions;
using iTero.Orders.Application.Abstractions;
using iTero.Orders.Domain.Entities;
using iTero.Orders.EntityFrameworkRepository.Model;
using iTero.Orders.WebApi.Contract;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;
using DalCasePartnerLink = iTero.Orders.EntityFrameworkRepository.Model.CasePartnerLink;
using DomainCasePartnerLink = iTero.Orders.Domain.Entities.CasePartnerLink;

namespace iTero.Orders.EntityFrameworkRepository
{
    public class OrdersEntityFrameworkRepository : IOrdersRepository, IDisposable
    {
        private readonly ILogger<OrdersEntityFrameworkRepository> logger;
        private readonly IMapper mapper;
        private readonly OrdersDBContext ordersDbContext;
        private readonly IPropertyScopeManager<FlowPhaseDescriptor> _flowPhaseScopeManager;

        public OrdersEntityFrameworkRepository(
            OrdersDBContext ordersDbContext, ILogger<OrdersEntityFrameworkRepository> logger, IMapper mapper, IPropertyScopeManager<FlowPhaseDescriptor> flowPhaseScopeManager)
        {
            this.ordersDbContext = ordersDbContext;
            this.logger = logger;
            this.mapper = mapper;
            _flowPhaseScopeManager = flowPhaseScopeManager;
        }

        public async Task<bool> HealthcheckAsync(CancellationToken cancellationToken)
        {
            using (_flowPhaseScopeManager.BeginScope(
                new FlowPhaseDescriptor() {Flow = "healthchek", Phase = "ordersdb"}))

            {
                try
                {
                    var canConnect = await ordersDbContext.Database.CanConnectAsync(cancellationToken);
                    if (canConnect)
                        logger.LogInformation("Healthcheck successful");
                    else
                        logger.LogWarning("Healthcheck issue - cannot connect to the database");
                    return canConnect;

                }
                catch (Exception e)
                {
                    logger.LogError(e, "healthcheck issue");
                    return false;
                }
            }
        }

        public async Task<RegisteredOrder> RegisterOrderAsync(NewOrder order, Guid eventId,
            DomainCasePartnerLink[] casePartnerLinks)
        {
            using var transaction = ordersDbContext.Database.BeginTransaction();
            var orderHeader = mapper.Map<OrderHeader>(order);
            ordersDbContext.OrderHeaders.Add(orderHeader);
            ordersDbContext.CasePartnerLinks.AddRange(
                casePartnerLinks.Select(cpl =>
                {
                    var dalCpl = mapper.Map<DalCasePartnerLink>(cpl);
                    dalCpl.OrderHeader = orderHeader;
                    return dalCpl;
                })
            );

            ordersDbContext.EventLog.Add(new EventLogEntry
            {
                OrderHeader = orderHeader, EventType = EventType.OrderRegistered, Id = eventId
            });

            await ordersDbContext.SaveChangesAsync();
            transaction.Commit();

            foreach (var od in ordersDbContext.ChangeTracker.Entries().ToArray())
            {
                od.State = EntityState.Detached;
            }

            var savedOrder = mapper.Map<RegisteredOrder>(orderHeader);
            return savedOrder;
        }

        public async Task<Order> SaveOrderAsync(Order order, Guid eventId, EventType eventType, DomainCasePartnerLink[] casePartnerLinks, CancellationToken cancellationToken)
        {
            using var transaction = ordersDbContext.Database.BeginTransaction();
            var orderHeader = mapper.Map<OrderHeader>(order);
            ordersDbContext.OrderHeaders.Update(orderHeader);
            await ordersDbContext.EventLog.AddAsync(new EventLogEntry
            {
                OrderHeader = orderHeader, EventType = eventType, Id = eventId
            }, cancellationToken);
            var existingLinks = await ordersDbContext.CasePartnerLinks
                .Where(x => x.OrderHeader.OrderHeaderId == orderHeader.OrderHeaderId)
                .Select(x => mapper.Map<DomainCasePartnerLink>(x)).ToListAsync(cancellationToken);
            var missingLinks = casePartnerLinks.Where(x=>!existingLinks.Contains(x)).ToList();

            await ordersDbContext.CasePartnerLinks.AddRangeAsync(
                missingLinks.Select(cpl =>
                {
                    var dalCpl = mapper.Map<DalCasePartnerLink>(cpl);
                    dalCpl.OrderHeader = orderHeader;
                    return dalCpl;
                }), cancellationToken);
            await ordersDbContext.SaveChangesAsync(cancellationToken);
            transaction.Commit();
            order = mapper.Map<Order>(orderHeader);
            return order;
        }

        public async Task<Order> GetOrderByIdAsync(long orderHeaderId)
        {
            var orderHeader = (await ordersDbContext.OrderHeaders.AsNoTracking()
                    .Include(oh => oh.OrderDetails)
                    .ThenInclude(od => od.WorkOrders)
                    .Include(oh=>oh.CasePartnerLinks)
                    .Where(oh => oh.OrderHeaderId == orderHeaderId).ToArrayAsync())
                .FirstOrDefault();

            if (orderHeader == default)
            {
                return default;
            }

            var order = mapper.Map<Order>(orderHeader);
            return order;
        }

        public async Task<Guid?> GetEventIdByOrderIdAndTypeAsync(long orderHeaderId, EventType eventType)
        {
            var eventId = (await ordersDbContext.EventLog.AsNoTracking()
                .SingleOrDefaultAsync(evt =>
                    evt.EventType == eventType && evt.OrderHeader.OrderHeaderId == orderHeaderId))?.Id;
            return eventId;
        }

        public async Task<Order> GetOrderByEventIdAsync(string eventId, EventType eventType)
        {
            var orderHeader = (await ordersDbContext.EventLog.AsNoTracking()
                    .Include(el => el.OrderHeader)
                    .ThenInclude(oh => oh.OrderDetails)
                    .ThenInclude(od => od.WorkOrders)
                    .Where(el => el.Id == Guid.Parse(eventId)).ToArrayAsync())
                .FirstOrDefault()?.OrderHeader;

            if (orderHeader == default)
            {
                return default;
            }

            var order = eventType switch{
                EventType.OrderRegistered => mapper.Map<RegisteredOrder>(orderHeader),
                EventType.ScanningDoneHandled => mapper.Map<Order>(orderHeader)
                };

            return order;
        }

        public async Task<DomainCasePartnerLink[]> GetCasePartnerLinksAsync(long orderId,
            CancellationToken cancellationToken)
        {
            var links = await ordersDbContext.CasePartnerLinks
                .AsNoTracking()
                .Include(cpl => cpl.OrderHeader)
                .ThenInclude(oh => oh.OrderDetails)
                .ThenInclude(od => od.WorkOrders)
                .Where(x => x.OrderHeader.OrderHeaderId == orderId)
                .ToArrayAsync(cancellationToken);

            return mapper.Map<DomainCasePartnerLink[]>(links);
        }

        public void Dispose()
        {
            ordersDbContext.Dispose();
        }
    }
}