using FoodsharingSiegen.Contracts;
using FoodsharingSiegen.Contracts.Entity;
using FoodsharingSiegen.Contracts.Enums;
using FoodsharingSiegen.Contracts.Model;
using FoodsharingSiegen.Server.Data.Service;
using FoodsharingSiegen.Shared.Helper;
using Microsoft.AspNetCore.Components;

namespace FoodsharingSiegen.Server.Pages
{
    /// <summary>
    ///     The prospects done class (a. beging, 07.02.2023)
    /// </summary>
    public partial class ProspectsDone
    {
        #region Dependencies

        /// <summary>
        ///     Gets or sets the value of the prospect service (ab)
        /// </summary>
        [Inject]
        public ProspectService ProspectService { get; set; } = null!;

        #endregion

        #region Private Properties

        private ProspectFilter Filter { get; set; } = new();

        /// <summary>
        ///     Gets or sets the value of the prospect list (ab)
        /// </summary>
        private List<Prospect> ProspectList { get; set; } = [];

        private bool IsLoadingProspects { get; set; }

        private bool IsLoadingMoreProspects { get; set; }

        private bool HasMoreProspects { get; set; }

        private int CurrentPageSize { get; set; } = 50;

        private int CurrentSkip { get; set; }

        private ProspectSortOption CurrentSort { get; set; } = ProspectSortOption.NameAscending;

        #endregion

        #region Override InitializeDataAsync

        /// <inheritdoc />
        protected override async Task InitializeDataAsync()
        {
            // Load Filter
            var filter = await LocalStorageService.GetItem<ProspectFilter>(StorageKeys.ProspectFilter);
            if (filter != null) Filter = filter;
            
            await LoadProspects();
        }

        #endregion

        #region Private Method FilterChangedAsync

        /// <summary>
        ///     Updates the current filter with the specified ProspectFilter object.
        /// </summary>
        /// <param name="arg">The ProspectFilter object containing the updated filter criteria.</param>
        /// <returns>A task that represents the asynchronous operation.</returns>
        private async Task FilterChangedAsync(ProspectFilter arg)
        {
            Filter = arg;
            await LocalStorageService.SetItem(StorageKeys.ProspectFilter, Filter);
            CurrentSkip = 0;
            ProspectList = [];
            await LoadProspects();
        }

        #endregion

        #region Private Method LoadProspects

        /// <summary>
        ///     Loads the prospects (a. beging, 11.04.2022)
        /// </summary>
        private bool HasActiveFilter()
        {
            return !string.IsNullOrWhiteSpace(Filter.Text)
                || Filter.WithoutStepInBriefing
                || Filter.WithoutIdCheck
                || Filter.DeletedOnly
                || Filter.IdCheckPossible
                || Filter.NoActivity
                || Filter.RecentActivity;
        }

        private async Task LoadProspects()
        {
            if (IsLoadingProspects || IsLoadingMoreProspects) return;

            try
            {
                if (CurrentSkip == 0)
                {
                    IsLoadingProspects = true;
                }
                else
                {
                    IsLoadingMoreProspects = true;
                }

                await InvokeAsync(StateHasChanged);

                while (true)
                {
                    var parameter = new GetProspectsParameter
                    {
                        Skip = CurrentSkip,
                        Take = CurrentPageSize,
                        MustHaveInteractions = [InteractionType.Complete]
                    };
                    var prospectsR = await ProspectService.GetProspectsAsync(parameter);
                    if (!prospectsR.Success)
                    {
                        break;
                    }

                    var loadedProspects = prospectsR.Data ?? [];
                    if (CurrentSkip == 0)
                    {
                        ProspectList = loadedProspects;
                    }
                    else
                    {
                        ProspectList = [.. ProspectList, .. loadedProspects];
                    }

                    CurrentSkip += loadedProspects.Count;
                    HasMoreProspects = loadedProspects.Count == CurrentPageSize;

                    var filteredCount = ProspectList.ApplyFilter(Filter).Count;
                    if (!HasActiveFilter() || filteredCount > 0 || !HasMoreProspects || loadedProspects.Count == 0)
                    {
                        break;
                    }
                }

                await InvokeAsync(StateHasChanged);
            }
            finally
            {
                IsLoadingProspects = false;
                IsLoadingMoreProspects = false;
                await InvokeAsync(StateHasChanged);
            }
        }

        private async Task LoadMoreProspects()
        {
            if (IsLoadingProspects || IsLoadingMoreProspects || !HasMoreProspects) return;
            await LoadProspects();
        }

        #endregion
    }
}