using AyCode.Blazor.Components.Services;
using AyCode.Core.Enums;
using AyCode.Core.Helpers;
using AyCode.Core.Interfaces;
using AyCode.Core;
using AyCode.Services.SignalRs;
using DevExpress.Blazor;
using DevExpress.ClipboardSource.SpreadsheetML;
using DevExpress.Data.Design;
using Microsoft.AspNetCore.Components;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TIAMSharedUI.Shared.Components.Grids;
using TIAMWebApp.Shared.Application.Utility;
using AyCode.Core.Extensions;
using AyCode.Utils.Extensions;

namespace TIAMSharedUI.Shared.Components.Cards
{
    public class CardBase<TDataItem> : ComponentBase where TDataItem : class, IId<Guid>
    {
        public CardBase() { }

        protected bool IsFirstInitializeParameters;
        private SignalRDataSource<TDataItem> _dataSource = null!;
        private IList<TDataItem> _dataSourceParam = [];
        private string _cardLogName;


        [Parameter] public LoggerClient Logger { get; set; }
        [Parameter] public string CardName { get; set; }
        [Parameter] public Guid[]? ContextIds { get; set; }

        private string? _filterText = null;

        [Parameter]
        public string? FilterText
        {
            get => _filterText;
            set
            {
                _filterText = value;

                if (_dataSource != null! && _dataSource.FilterText != value)
                {
                    _dataSource.FilterText = value;
                    LoadDataSourceAsync().Forget();
                }
            }
        }

        [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] public EventCallback<IList<TDataItem>> OnDataSourceChanged { get; set; }


        /// <summary>
        /// After the server has responded!
        /// </summary>
        [Parameter]
        public EventCallback<TDataItem> OnCardItemChanged { 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)
                {
                    Logger.Error($"{_cardLogName} Use the DataSource parameter instead of Data!");
                    throw new NullReferenceException($"{_cardLogName} Use the DataSource parameter instead of Data!");
                }

                return _dataSource!;
            }
            set
            {
                _dataSourceParam = value; 

                if (_dataSource != null! && _dataSourceParam is List<TDataItem> workingReferenceList)
                    _dataSource.SetWorkingReferenceList(workingReferenceList);
            }
        }

        protected override async Task OnInitializedAsync()
        {
            if (Logger == null)
                throw new NullReferenceException($"[{GetType().Name}] Logger == null");

            if (SignalRClient == null)
            {
                Logger.Error($"[{GetType().Name}] SignalRClient == null");
                throw new NullReferenceException($"[{GetType().Name}] SignalRClient == null");
            }

            var crudTags = new SignalRCrudTags(GetAllMessageTag, GetItemMessageTag, AddMessageTag, UpdateMessageTag, RemoveMessageTag);
            _dataSource = new SignalRDataSource<TDataItem>(SignalRClient, crudTags, ContextIds);
            _dataSource.FilterText = FilterText;

            //Data = _dataSource;

            _dataSource.OnDataSourceLoaded += OnDataSourceLoaded;            

            await base.OnInitializedAsync();
        }

        
        private Task OnDataSourceLoaded()
        {
            Logger.Debug($"{_cardLogName} OnDataSourceLoaded; Count: {_dataSource.Count}");
            
            //_dataSource.LoadItem(_dataSource.First().Id).Forget();
            return OnDataSourceChanged.InvokeAsync(_dataSource);
        }

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

            if (firstRender)
            {
                if (_dataSourceParam != null!) await _dataSource.LoadDataSource(_dataSourceParam, true, true);
                else _dataSource.LoadDataSourceAsync(true).Forget();
            }
        }



        protected override Task OnParametersSetAsync()
        
        {
            if (!IsFirstInitializeParameters)
            {
                //if (typeof(TDataItem) is IId<Guid> || typeof(TDataItem) is IId<int>)
                

                IsFirstInitializeParameters = true;
            }

            return Task.FromResult(base.OnParametersSetAsync);
        }


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

            if (CardName.IsNullOrWhiteSpace()) CardName = $"{typeof(TDataItem).Name}Card";

            _cardLogName = $"[{CardName}]";

        }

        public Task AddOrUpdateDataItem(TDataItem dataItem) => _dataSource.AddOrUpdate(dataItem, true);

        public Task RemoveDataItem(TDataItem dataItem) => _dataSource.Remove(dataItem, true);
        //public Task RemoveDataItem(TDataItem dataItem, int messageTag) => PostDataToServerAsync(dataItem, messageTag, TrackingState.Remove);

        public Task RemoveDataItem(Guid id) => RemoveDataItem(id, RemoveMessageTag);

        public Task RemoveDataItem(Guid id, int messageTag)
        {
            var dataItem = _dataSource.FirstOrDefault(x => x.Id == id);
            if (dataItem == null) return Task.CompletedTask;

            return _dataSource.Remove(dataItem, true);
        }

        public Task LoadDataSourceAsync()
        {
            return _dataSource.LoadDataSourceAsync(false);
        }
    }
}