using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using AyCode.Core.Helpers;
using AyCode.Interfaces.Entities;
using AyCode.Services.Loggers;
using AyCode.Services.SignalRs;
using AyCode.Utils.Extensions;
using DevExpress.Blazor;
using DevExpress.Blazor.Internal;
using Microsoft.AspNetCore.Components;
using Newtonsoft.Json.Linq;
using TIAM.Entities.Transfers;
using TIAM.Services;
using TIAMWebApp.Shared.Application.Services;
using TIAMWebApp.Shared.Application.Utility;

namespace TIAMSharedUI.Shared.Components
{
    public class TiamGrid<TDataItem> : DxGrid where TDataItem : class, IEntityGuid
    {
        private bool _initialParametersSet;
        private IList<TDataItem>? _dataSource;


        public TiamGrid() : base()
        { }

        [Parameter] public LoggerClient Logger { get; set; }
        [Parameter] public string GridName { get; set; }
        [Parameter] public AcSignalRClientBase SignalRClient { get; set; }

        [Parameter] public int GetAllMessageTag { get; set; }
        [Parameter] public int GetItemMessageTag { get; set; }
        [Parameter] public int AddMessageTag { get; set; }
        [Parameter] public int UpdateMessageTag { get; set; }
        [Parameter] public int RemoveMessageTag { get; set; }

        [Parameter]
        [DefaultValue(null)]
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "BL0007:Component parameters should be auto properties", Justification = "<Pending>")]
        public IList<TDataItem>? DataSource
        {
            get
            {
                if (_dataSource == null && Data != null)
                {
                    Logger.Error($"{GridName} Use the DataSource parameter instead of Data!");
                    throw new NullReferenceException($"{GridName} Use the DataSource parameter instead of Data!");
                }

                return _dataSource;

            }
            set
            {
                _dataSource = value;
                Data = _dataSource;

                OnDataSourceChanged.InvokeAsync(_dataSource);
            }
        }

        protected override void OnInitialized()
        {
            base.OnInitialized();
        }

        protected override async Task OnAfterRenderAsync(bool firstRender)
        {
            await base.OnAfterRenderAsync(firstRender);

            if (firstRender) RefreshDataSourceAsync().Forget();
        }

        [Parameter]
        public EventCallback<GridDataItemDeletingEventArgs> OnDataItemDeleting{ get; set; }
        protected new EventCallback<GridDataItemDeletingEventArgs> DataItemDeleting { get; set; }
        [Parameter]
        public EventCallback<GridDataItemDeletingEventArgs> OnDataItemDeleted { get; set; }

        [Parameter]
        public EventCallback<IList<TDataItem>> OnDataSourceChanged { get; set; }
        [Parameter]
        public EventCallback<TDataItem> OnDataSourceItemChanged { get; set; }

        private async Task OnItemDeleting(GridDataItemDeletingEventArgs e)
        {
            Logger.Info($"{GridName} OnItemDeleting");

            await OnDataItemDeleting.InvokeAsync(e);

            if (e.Cancel)
            {
                Logger.Debug($"{GridName} OnItemDeleting canceled");
                return;
            }
            
            var dataItem = e.DataItem as TDataItem;
            //PostDataToServerAsync(transfer, SignalRTags.DeleteTransferAsync, true).Forget();
            //await UpdateDataAsync();

            Logger.Info($"{GridName} OnDataItemDeleted");
            await OnDataItemDeleted.InvokeAsync(e);
        }

        public Task RefreshDataSourceAsync()
        {
            Logger.Info($"{GridName} UpdateAllDataAsync called");

            return SignalRClient.GetAllAsync<IList<TDataItem>>(GetAllMessageTag, response =>
            {
                if (response.Status == SignalResponseStatus.Error)
                    return;

                BeginUpdate();
                DataSource = response.ResponseData ?? [];
                EndUpdate();

                InvokeAsync(StateHasChanged).Forget();
            });
        }

        private Task PostDataToServerAsync(TDataItem transfer, int messageTag, bool isDelete = false)
        {
            Logger.Info($"{GridName} PostDataToServerAsync called; transferId " + transfer.Id);

            RefreshDataSourceItem(transfer, isDelete); //egyből látszódik a változás a grid-ben, nem csak a callback lefutásakor! felhasználóbarátabb... - J.

            return SignalRClient.PostDataAsync(messageTag, transfer, repsonse =>
            {
                if (repsonse.Status != SignalResponseStatus.Success || repsonse.ResponseData == null)
                {
                    RefreshDataSourceAsync().Forget();
                    return;
                }

                RefreshDataSourceItem(repsonse.ResponseData, isDelete);
                InvokeAsync(StateHasChanged).Forget();
            });

            //transfer = await devAdminSignalClient.PostDataAsync(SignalRTags.UpdateTransferAsync, transfer);
        }

        public void RefreshDataSourceItem(TDataItem dataItem, bool isDelete)
        {
            var transferIndex = _dataSource.FindIndex(x => x.Id == dataItem.Id);

            if (isDelete && transferIndex > -1) _dataSource.RemoveAt(transferIndex);
            else
            {
                if (transferIndex > -1) _dataSource[transferIndex] = dataItem;
                else _dataSource.Add(dataItem);
            }

            OnDataSourceItemChanged.InvokeAsync(dataItem);
        }

        protected override Task SetParametersAsyncCore(ParameterView parameters)
        {
            if (!_initialParametersSet)
            {
                base.DataItemDeleting = EventCallback.Factory.Create<GridDataItemDeletingEventArgs>(this, OnItemDeleting);
                //ShowFilterRow = true;
                //PageSize = 4;
                //ShowGroupPanel = true;
                //AllowSort = false;
                _initialParametersSet = true;
            }

            return base.SetParametersAsyncCore(parameters);
        }

        protected override void OnParametersSet()
        {
            base.OnParametersSet();

            if (GridName.IsNullOrWhiteSpace()) GridName = $"[{typeof(TDataItem).Name}Grid]";
        }
    }
}