using AyCode.Core.Loggers;
using DevExpress.Blazor;
using FruitBank.Common.Dtos;
using FruitBank.Common.Entities;
using FruitBank.Common.Models;
using FruitBankHybrid.Shared.Models;
using FruitBankHybrid.Shared.Services;
using FruitBankHybrid.Shared.Services.Loggers;
using FruitBankHybrid.Shared.Services.SignalRs;
using Mango.Nop.Core.Loggers;
using Microsoft.AspNetCore.Components;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using FruitBank.Common.Helpers;
using FruitBank.Common.Interfaces;
using AyCode.Core.Extensions;
using FruitBankHybrid.Shared.Extensions;
using Mango.Nop.Core.Extensions;
using Nop.Core.Domain.Orders;

namespace FruitBankHybrid.Shared.Pages
{
    public partial class MeasuringOut : ComponentBase
    {
        [Inject] public required IEnumerable<IAcLogWriterClientBase> LogWriters { get; set; }
        [Inject] public required FruitBankSignalRClient FruitBankSignalRClient { get; set; }
        [Inject] public required NavigationManager NavManager{ get; set; }
        [Inject] private IDialogService DialogService { get; set; } = null!;
        [Inject] public required LoggedInModel LoggedInModel { get; set; }

        private ILogger _logger = null!;
        private string _errorText;

        public bool HasMeasuringAccess;

        public bool LoadingPanelVisible { get; set; } = true;

        private List<OrderDto> SelectedDayOrders { get; set; } = null!;
        private OrderDto? SelectedOrder { get; set; }
        private OrderItemDto? SelectedOrderItem { get; set; }

        private List<MeasuringDateSelectorModel> _measuringDates = null!;

        protected override async Task OnInitializedAsync()
        {
            if (!LoggedInModel.IsLoggedIn) NavManager.NavigateTo("/Login");

            LoadingPanelVisible = true;
            _logger = new LoggerClient<MeasuringOut>(LogWriters.ToArray());
            _logger.Info("OnInitializedAsync");

            await RefreshOrdersFromDb(DateTime.Now);
            await base.OnInitializedAsync();
        }

        private async Task RefreshOrdersFromDb(DateTime dateTime)
        {
            LoadingPanelVisible = true;
            var orders = (await FruitBankSignalRClient.GetPendingOrderDtosForMeasuring() ?? []).Where(o => o.HasMeasuringAccess(LoggedInModel.CustomerDto?.Id, LoggedInModel.IsRevisor)).OrderBy(o => o.DateOfReceipt).ToList();

            _measuringDates = orders.Select(order => new MeasuringDateSelectorModel(order.Id, order.DateOfReceiptOrCreated, order.IsMeasured)).ToList();

            SelectedDayOrders = orders.Where(order => MeasuringService.DaysEqual(order.DateOfReceiptOrCreated, dateTime)).OrderBy(x => x.DateOfReceipt).ToList();

            foreach (var orderDto in SelectedDayOrders) PrepareOrderDto(orderDto);

            SelectedOrder = LoggedInModel.IsRevisor
                ? SelectedDayOrders.FirstOrDefault(o => o is { IsComplete: false, IsMeasured: true })
                : SelectedDayOrders.FirstOrDefault(o => o.MeasurementOwnerId == 0 || (o.MeasurementOwnerId == (LoggedInModel.CustomerDto?.Id ?? 0) && !o.IsMeasured));

            SelectedOrder ??= SelectedDayOrders.FirstOrDefault();
            LoadingPanelVisible = SelectedOrder != null; //Lefut a change és ott lesz false! - J.
        }

        private async Task OnMeasuringDateChanged(DateTime selectedDateTime)
            => await RefreshOrdersFromDb(selectedDateTime);

        private void OnCustomDisabledMeasuringDate(CalendarCustomDisabledDateEventArgs args)
            => MeasuringService.OnCustomDisabledDate(args, _measuringDates);

        private string GetMeasuringDateCssClassNames(DateTime date)
            => MeasuringService.GetShippingDateCssClassNames(date, _measuringDates);

        private string GetOrderItemPalletsCssClassNames(string fieldName, OrderItemPallet orderItemPallet)
            => MeasuringService.GetCustomItemPalletsCssClassNames(fieldName, orderItemPallet, orderItemPallet.OrderItemDto!.IsMeasurable);

        private bool IsOrderItemPalletMeasuredAndValid(OrderItemPallet orderItemPallet)
            => MeasuringService.IsCustomItemPalletMeasuredAndValid(orderItemPallet, orderItemPallet.OrderItemDto!.IsMeasurable);

        private async Task OnSelectedOrderChanged(SelectedDataItemChangedEventArgs<OrderDto> eventArgs)
        {
            //var orderDtosFromDb = await FruitBankSignalRClient.GetPendingOrderDtos();
            //if (orderDtosFromDb != null) RefreshOrderGenericAttributes(orderDtosFromDb, SelectedDayOrders);
            //else MessageBox.ShowMessageBox("Hiba", "Az adatok letöltése sikertelen!", MessageBoxRenderStyle.Danger);

            var orderDto = eventArgs.DataItem;
            if (orderDto != null && !LoadingPanelVisible)
            {
                //LoadingPanelVisible = true;
                var orderFromDb = await FruitBankSignalRClient.GetOrderDtoById(orderDto.Id);

                if (orderFromDb != null)
                {
                    orderDto.OrderStatus = orderFromDb.OrderStatus;
                    orderDto.GenericAttributes.UpdateBaseEntityCollection(orderFromDb.GenericAttributes, false);

                    //if (LoggedInModel.IsRevisor)
                    //{
                    //    orderDto.OrderItemDtos.UpdateCollection(orderFromDb.OrderItemDtos, false);

                    //    var orderItemPalletsByOrderId = orderFromDb.OrderItemDtos.Where(o => o.OrderItemPallets.Count > 0).ToDictionary(k => k.Id, v => v.OrderItemPallets);
                    //    foreach (var orderItemDto in orderDto.OrderItemDtos)
                    //    {
                    //        if (orderItemPalletsByOrderId.TryGetValue(orderDto.Id, out var orderItemPallets))
                    //            orderItemDto.OrderItemPallets.UpdateCollection(orderItemPallets, false);
                    //    }
                    //}
                }
            }

            LoadingPanelVisible = false;
            HasMeasuringAccess = orderDto?.HasMeasuringAccess(LoggedInModel.CustomerDto?.Id, LoggedInModel.IsRevisor) ?? false;

            StateHasChanged();

            if (!HasMeasuringAccess && orderDto != null)
                await DialogService.ShowMessageBoxAsync("Információ", "A mérés már folyamatban, válasszon másik rendelést!", MessageBoxRenderStyle.Info);
        }

        private Task OnOrderItemPalletValueChanged(OrderItemPallet orderItemPallet, OrderItemDto selectedOrderItemDto)
        {
            StateHasChanged();
            return Task.CompletedTask;
        }

        private async Task OnOrderItemPalletSaved(OrderItemPallet? orderItemPallet, OrderItemDto selectedOrderItemDto)
        {
            if (orderItemPallet != null)
            {
                selectedOrderItemDto.OrderItemPallets.UpdateCollection(orderItemPallet, false);
                //MeasuringValuesHelper.SetShippingItemTotalMeasuringValues(SelectedShippingItem);
            }
            else await DialogService.ShowMessageBoxAsync("Hiba", "Adatok mentése sikertelen volt, ellenőrizze a mérés adatait!", MessageBoxRenderStyle.Danger);

            StateHasChanged();
        }

        private Task AddNewPalletItemClick(OrderItemDto selectedOrderItemDto)
        {
            if (selectedOrderItemDto.OrderItemPallets[^1].Id > 0)
            {
                selectedOrderItemDto.OrderItemPallets.Add(MeasuringService.CreateNewOrderItemPallet(selectedOrderItemDto, LoggedInModel.CustomerDto));
                StateHasChanged();
            }

            return Task.CompletedTask;
        }

        private Task LastPalletItemDeleteClick(OrderItemDto selectedOrderItemDto)
        {
            if (selectedOrderItemDto.OrderItemPallets.Count <= 1) return Task.CompletedTask;

            var lastPalletItem = selectedOrderItemDto.OrderItemPallets[^1];

            if (lastPalletItem.Id > 0) return Task.CompletedTask;
            selectedOrderItemDto.OrderItemPallets.Remove(lastPalletItem);

            StateHasChanged();
            return Task.CompletedTask;
        }

        private async Task OnOrdersRefreshClick()
            => await RefreshOrdersFromDb(SelectedDayOrders.FirstOrDefault()?.DateOfReceiptOrCreated ?? DateTime.Now);

        private async Task OnStartMeasuringClick()
        {
            if (SelectedOrder == null || !LoggedInModel.IsLoggedIn || SelectedOrder.MeasurementOwnerId != 0) return;
            
            var confirmed = !LoggedInModel.IsRevisor || await DialogService.ShowConfirmBoxAsync("Megerősítés", "Ha elindítja a mérést, senki más nem tudja befelyezni! Biztoan folytatja?", MessageBoxRenderStyle.Info);
            if (!confirmed) return;

            var responseOrderDto = await FruitBankSignalRClient.StartMeasuring(SelectedOrder.Id, LoggedInModel.CustomerDto!.Id);
            if (responseOrderDto != null)
            {
                PrepareOrderDto(responseOrderDto);

                //SelectedOrder.GenericAttributes.UpdateBaseEntityCollection(responseOrderDto.GenericAttributes, false);
                SelectedDayOrders.UpdateCollection(responseOrderDto, false);
                SelectedOrder = responseOrderDto;
            }
            else await DialogService.ShowMessageBoxAsync("Hiba", "Nem sikerült a mérést elindítani!", MessageBoxRenderStyle.Danger);

            StateHasChanged();
        }

        private async Task OnMeasuringAuditorClick()
        {
            if (SelectedOrder != null && LoggedInModel.IsRevisor && SelectedOrder.IsMeasured && SelectedOrder.OrderStatus != OrderStatus.Complete)
            {
                if (await DialogService.ShowConfirmBoxAsync("Megerősítés", "Biztoan jóváhagyja a rendelést? Jóváhagyás után a mérések nem módosíthatóak!", MessageBoxRenderStyle.Info))
                {
                    var responseOrderDto = await FruitBankSignalRClient.SetOrderStatusToComplete(SelectedOrder.Id, LoggedInModel.CustomerDto!.Id);
                    if (responseOrderDto != null)
                    {
                        PrepareOrderDto(responseOrderDto);

                        SelectedDayOrders.UpdateCollection(responseOrderDto, false);
                        SelectedOrder = responseOrderDto;

                        //await DialogService.ShowMessageBoxAsync("Információ", "Adatok mentése sikeres volt!", MessageBoxRenderStyle.Info);
                    }
                    else await DialogService.ShowMessageBoxAsync("Hiba", "Rendelés jóváhagyása sikertelen volt, ellenőrizze a mérés adatait!", MessageBoxRenderStyle.Danger);

                    StateHasChanged();
                }
            }
        }

        private void PrepareOrderDto(OrderDto orderDto)
        {
            foreach (var orderItemDto in orderDto.OrderItemDtos.Where(orderItem => orderItem.OrderItemPallets.Count == 0))
            {
                orderItemDto.OrderItemPallets.Add(MeasuringService.CreateNewOrderItemPallet(orderItemDto, LoggedInModel.CustomerDto));
            }
        }

        private static void RefreshOrderGenericAttributes(List<OrderDto> srcOrderDtos, List<OrderDto> destOrderDtos)
        {
            var orderAttributesByOrderId = srcOrderDtos.Where(o => o.GenericAttributes.Count > 0).ToDictionary(k => k.Id, v => v.GenericAttributes);
            foreach (var orderDto in destOrderDtos)
            {
                if (orderAttributesByOrderId.TryGetValue(orderDto.Id, out var genericAttributes))
                    orderDto.GenericAttributes.UpdateBaseEntityCollection(genericAttributes, false);
            }
        }
    }
}