public class OrdersViewModel : BaseItemsPageViewModel<BaseViewModel>
    {
        private const int PaginationSize = 10;

        private readonly IOrdersManager ordersManager;
        private readonly IUserDialogs userDialogs;
        private readonly IEmployeesManager employeesManager;
        private readonly INomenclatureManager nomenclatureManager;
        private readonly IUserSession userSession;

        private IDisposable[]? itemSubscriptions;

        public OrdersViewModel(
            IOrdersManager ordersManager,
            IUserDialogs userDialogs,
            IEmployeesManager employeesManager,
            INomenclatureManager nomenclatureManager,
            IUserSession userSession)
        {
            this.ordersManager = ordersManager;
            this.userDialogs = userDialogs;
            this.employeesManager = employeesManager;
            this.nomenclatureManager = nomenclatureManager;
            this.userSession = userSession;

            FiltersItems = new MvxObservableCollection<SelectableItemViewModel<OrdersFilterMode>>(CreateItems(OrdersFilterMode.All));
            PaginationViewModel = new PaginationViewModel(LoadMoreItemsAsync, PaginationSize);
            MainToolbarViewModel = CompositionRoot.Container.Resolve<MainToolbarViewModel>();

            GoToFeedCommand = this.CreateCommand(GoToFeedAsync);
            GoToContactsCommand = this.CreateCommand(GoToContactsAsync);
            AddOrderCommand = this.CreateCommand(AddOrderAsync);
            DeleteOrdersCommand = this.CreateCommand(DeleteOrdersAsync);
            CancelCommand = this.CreateCommand(Cancel);
            FilterItemSelectedCommand = this.CreateCommand<SelectableItemViewModel<OrdersFilterMode>>(FilterItemSelected);
        }

        public IMvxCommand AddOrderCommand { get; }
        public IMvxCommand DeleteOrdersCommand { get; }
        public IMvxCommand FilterItemSelectedCommand { get; }
        public IMvxCommand CancelCommand { get; }
        public IMvxCommand GoToFeedCommand { get; }
        public IMvxCommand GoToContactsCommand { get; }

        public PaginationViewModel PaginationViewModel { get; }

        public MainToolbarViewModel MainToolbarViewModel { get; }

        public SelectableItemViewModel<OrdersFilterMode>? SelectedFilter => FiltersItems.FirstOrDefault(item => item.IsSelected);

        private bool isSelectionMode;
        public bool IsSelectionMode
        {
            get => isSelectionMode;
            set => SetProperty(ref isSelectionMode, value, OnIsSelectionModeChanged);
        }

        public string SeletedItemsCount => GetItemsCount();

        public bool IsAnyItemSelect => SelectedItemsCount > 0;

        private int selectedItemsCount;
        public int SelectedItemsCount
        {
            get => selectedItemsCount;
            set
            {
                SetProperty(ref selectedItemsCount, value);
                RaisePropertyChanged(nameof(IsAnyItemSelect));
                RaisePropertyChanged(nameof(SeletedItemsCount));
            }
        }

        public MvxObservableCollection<SelectableItemViewModel<OrdersFilterMode>> FiltersItems { get; set; }

        public override Task InitializeAsync()
        {
            return RefreshDataAsync();
        }

        protected override Task RefreshDataAsync()
        {
            Items.Clear();
            PaginationViewModel.Reset();

            return Task.WhenAll(
                base.RefreshDataAsync(),
                PaginationViewModel.LoadMoreItemsCommand.ExecuteAsync());
        }

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

            itemSubscriptions?.ForEach(subscription => subscription.Dispose());
            itemSubscriptions = Items
                .OfType<OrderItemViewModel>()
                .Select(item => item.SubscribeToPropertyChanged(nameof(OrderItemViewModel.IsSelected), () => OnAnyItemIsSelectedChanged(item)))
                .ToArray();
        }

        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                itemSubscriptions?.ForEach(subscription => subscription.Dispose());
                itemSubscriptions = null;
            }

            base.Dispose(disposing);
        }

        private async Task<int> LoadMoreItemsAsync(int pageIndex, int pageSize)
        {
            var selectedFilterMode = SelectedFilter?.Key ?? OrdersFilterMode.All;

            var response = await ordersManager.GetOrdersAsync(selectedFilterMode, pageIndex, pageSize, CancellationToken.None);
            if (!response.IsSuccessful)
            {
                return 0;
            }

            var items = response.Data.Items.Select(order => new OrderItemViewModel(
                order,
                ItemTappedAsync,
                ItemLongTappedAsync,
                ExecutionStateWrapper)).ToArray();

            Items.AddRange(items);

            PaginationViewModel.SetTotalItemsCount(response.Data.TotalCount);
            return items.Length;
        }

        private async Task ItemTappedAsync(OrderItemViewModel orderItemViewModel)
        {
            var order = await NavigationManager.NavigateAsync<OrderDetailsViewModel, Order, Order?>(orderItemViewModel.Order);
            if (order is null)
            {
                Items.Remove(orderItemViewModel);
                return;
            }

            orderItemViewModel.UpdateOrder(order!);
        }

        protected async Task ItemLongTappedAsync(OrderItemViewModel orderItemViewModel)
        {
            var result = await userDialogs.ActionSheetAsync(
                AppStrings.SelectActions,
                AppStrings.Cancel,
                AppStrings.Delete,
                null,
                AppStrings.Select,
                AppStrings.Edit);

            if (result == AppStrings.Cancel)
            {
                return;
            }

            if (result == AppStrings.Select)
            {
                IsSelectionMode = true;
                orderItemViewModel.IsSelected = true;
                return;
            }

            if (result == AppStrings.Delete)
            {
                await ordersManager.DeleteAsync(orderItemViewModel.Order.Id, CancellationToken.None);
                Items.Remove(orderItemViewModel);
                return;
            }

            if (result == AppStrings.Edit)
            {
                await EditAsync(orderItemViewModel);
            }
        }

        private async Task EditAsync(OrderItemViewModel orderItemViewModel)
        {
            var employeesIds = orderItemViewModel.Order.Executors.Select(executor => executor.EmployeeId).ToArray();
            var workIds = orderItemViewModel.Order.ListOfWork
                .Where(work => work.NomenclatureId.HasValue)
                .Select(work => work.NomenclatureId!.Value)
                .ToArray();

            var getEmployeesTask = employeesManager.GetEmployeesByIdsAsync(employeesIds);
            var getWorksTask = nomenclatureManager.GetWorksByNumenclatureIdsAsync(workIds, CancellationToken.None);

            await Task.WhenAll(getEmployeesTask, getWorksTask);

            if (!getEmployeesTask.Result.IsSuccessful ||
                !getWorksTask.Result.IsSuccessful)
            {
                return;
            }

            var employeeExecutorMappings = getEmployeesTask.Result.Data
            .Join(
                orderItemViewModel.Order.Executors,
                employee => employee.Id,
                executor => executor.EmployeeId,
                (employee, executor) => new { employee, executor })
            .ToDictionary(kv => kv.employee, kv => kv.executor);

            var worksMappings = getWorksTask.Result.Data
            .Join(
                orderItemViewModel.Order.ListOfWork,
                work => work.Id,
                orderWork => orderWork.NomenclatureId,
                (work, orderWork) => new { work, orderWork })
            .ToDictionary(kv => kv.work, kv => kv.orderWork);

            var navigationParams = OrderSaveNavigationParams.Edit(
                orderItemViewModel.Order,
                employeeExecutorMappings,
                worksMappings);

            var updatedOrder = await NavigationManager.NavigateAsync<OrderSaveViewModel, OrderSaveNavigationParams, Order?>(navigationParams);
            orderItemViewModel.UpdateOrder(updatedOrder!);
        }

        private void OnAnyItemIsSelectedChanged(OrderItemViewModel itemViewModel)
        {
            if (!IsSelectionMode)
            {
                return;
            }

            if (itemViewModel.IsSelected)
            {
                SelectedItemsCount++;
                return;
            }

            SelectedItemsCount--;
        }

        private async Task DeleteOrdersAsync()
        {
            var selectedItems = Items
                .OfType<OrderItemViewModel>()
                .Where(item => item.IsSelected)
                .ToArray();

            var selectedItemsIds = selectedItems
                .Select(item => item.Order.Id)
                .ToArray();

            var response = await ordersManager.DeleteAsync(selectedItemsIds, CancellationToken.None);
            if (response.IsSuccessful)
            {
                Items.RemoveItems(selectedItems);
            }

            Cancel();
        }

        private void OnIsSelectionModeChanged()
        {
            Items.OfType<OrderItemViewModel>().ForEach(item => item.IsSelectionMode = IsSelectionMode);
        }

        private async Task AddOrderAsync()
        {
            var order = await NavigationManager.NavigateAsync<OrderSaveViewModel, OrderSaveNavigationParams, Order?>(OrderSaveNavigationParams.Add());
            if (order is null)
            {
                return;
            }

            await RefreshDataAsync();
        }

        private SelectableItemViewModel<OrdersFilterMode>[] CreateItems(OrdersFilterMode selectedMode)
        {
            var values = Enum.GetValues(typeof(OrdersFilterMode)).Cast<OrdersFilterMode>().ToList();
            if (userSession.User!.UserRole == UserRole.Client)
            {
                values.Remove(OrdersFilterMode.OnlyMy);
            }

            return values
                .Select(mode => new SelectableItemViewModel<OrdersFilterMode>(mode, mode.ToLocalizedString(), mode == selectedMode))
                .ToArray();
        }

        private Task FilterItemSelected(SelectableItemViewModel<OrdersFilterMode> itemViewModel)
        {
            FiltersItems.ForEach(item => item.IsSelected = item == itemViewModel);

            return RefreshDataAsync();
        }

        private void Cancel()
        {
            IsSelectionMode = false;
            SelectedItemsCount = 0;
            Items.OfType<OrderItemViewModel>().ForEach(item => item.IsSelected = false);
        }

        private Task GoToFeedAsync() =>
            NavigationManager.NavigateAsync<FeedViewModel>();

        private Task GoToContactsAsync() =>
            NavigationManager.NavigateAsync<ContactsViewModel>();

        private string GetItemsCount()
        {
            if (IsAnyItemSelect)
            {
                return string.Format(AppStrings.SelectTemplate, SelectedItemsCount);
            }

            return AppStrings.SelectOrder;
        }
    }