ExplorePanelPlugin.cs

using System;
using Arch.Core;
using Arch.SystemGroups;
using CommunicationData.URLHelpers;
using Cysharp.Threading.Tasks;
using DCL.AssetsProvision;
using DCL.Audio;
using DCL.AvatarRendering.Emotes;
using DCL.AvatarRendering.Emotes.Equipped;
using DCL.AvatarRendering.Loading;
using DCL.AvatarRendering.Wearables;
using DCL.AvatarRendering.Wearables.Equipped;
using DCL.AvatarRendering.Wearables.Helpers;
using DCL.AvatarRendering.Wearables.ThirdParty;
using DCL.Backpack.Gifting.Services.PendingTransfers;
using DCL.Backpack;
using DCL.Backpack.BackpackBus;
using DCL.Browser;
using DCL.CharacterPreview;
using DCL.ExplorePanel;
using DCL.Input;
using DCL.Landscape.Settings;
using DCL.MapRenderer;
using DCL.Navmap;
using DCL.PlacesAPIService;
using DCL.Profiles;
using DCL.Profiles.Self;
using DCL.Quality;
using DCL.Settings;
using DCL.SpringBones;
using DCL.Settings.Configuration;
using DCL.UserInAppInitializationFlow;
using DCL.Web3.Authenticators;
using DCL.Web3.Identities;
using DCL.WebRequests;
using ECS;
using ECS.Prioritization;
using Global.Dynamic;
using MVC;
using System.Threading;
using DCL.Backpack.AvatarSection.Outfits.Repository;
using DCL.Chat.MessageBus;
using DCL.Clipboard;
using DCL.Communities;
using DCL.Communities.CommunitiesBrowser;
using DCL.Communities.CommunitiesDataProvider;
using DCL.Communities.EventInfo;
using DCL.Credits;
using DCL.Donations;
using DCL.Events;
using DCL.EventsApi;
using DCL.FeatureFlags;
using DCL.Friends;
using DCL.Friends.UserBlocking;
using DCL.InWorldCamera;
using DCL.Navmap.ScriptableObjects;
using DCL.InWorldCamera.CameraReelGallery;
using DCL.InWorldCamera.CameraReelGallery.Components;
using DCL.InWorldCamera.CameraReelStorageService;
using DCL.Ipfs;
using DCL.MapRenderer.MapLayers.HomeMarker;
using DCL.MarketplaceCredits;
using DCL.Multiplayer.Connections.DecentralandUrls;
using DCL.Optimization.PerformanceBudgeting;
using DCL.Passport;
using DCL.PerformanceAndDiagnostics.Analytics;
using DCL.Places;
using DCL.PrivateWorlds;
using DCL.Quality.Runtime;
using DCL.RealmNavigation;
using DCL.UI.Profiles.Helpers;
using DCL.SDKComponents.MediaStream.Settings;
using DCL.Settings.Settings;
using DCL.SkyBox;
using DCL.UI;
using DCL.UI.ProfileElements;
using DCL.UI.Profiles;
using DCL.Utilities;
using Utility;
using DCL.VoiceChat;
using ECS.SceneLifeCycle.IncreasingRadius;
using ECS.SceneLifeCycle.Realm;
using Global;
using Global.AppArgs;
using Runtime.Wearables;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.Audio;
using UnityEngine.InputSystem;
using UnityEngine.Pool;
using Object = UnityEngine.Object;

// ReSharper disable UnusedAutoPropertyAccessor.Local
namespace DCL.PluginSystem.Global
{
    public class ExplorePanelPlugin : IDCLGlobalPlugin<ExplorePanelPlugin.ExplorePanelSettings>
    {
        private readonly IEventBus eventBus;
        private readonly IAssetsProvisioner assetsProvisioner;
        private readonly MapRendererContainer mapRendererContainer;
        private readonly IMVCManager mvcManager;
        private readonly IPlacesAPIService placesAPIService;
        private readonly IProfileRepository profileRepository;
        private readonly IUserInAppInitializationFlow userInAppInitializationFlow;
        private readonly ISelfProfile selfProfile;
        private readonly IEquippedWearables equippedWearables;
        private readonly IEquippedEmotes equippedEmotes;
        private readonly ICompositeWeb3Provider web3Authenticator;
        private readonly IWeb3IdentityCache web3IdentityCache;
        private readonly ICameraReelStorageService cameraReelStorageService;
        private readonly ICameraReelScreenshotsStorage cameraReelScreenshotsStorage;
        private readonly ISystemClipboard systemClipboard;
        private readonly IDecentralandUrlsSource decentralandUrlsSource;
        private readonly IWearableStorage wearableStorage;
        private readonly ICharacterPreviewFactory characterPreviewFactory;
        private readonly UnityAppWebBrowser webBrowser;
        private readonly IEmoteStorage emoteStorage;
        private readonly IWebRequestController webRequestController;
        private readonly CharacterPreviewEventBus characterPreviewEventBus;
        private readonly IBackpackEventBus backpackEventBus;
        private readonly IThirdPartyNftProviderSource thirdPartyNftProviderSource;
        private readonly IWearablesProvider wearablesProvider;
        private readonly ICursor cursor;
        private readonly IEmoteProvider emoteProvider;
        private readonly Arch.Core.World world;
        private readonly Entity playerEntity;
        private readonly IMapPathEventBus mapPathEventBus;
        private readonly IRealmData realmData;
        private readonly PublishIpfsEntityCommand publishIpfsEntityCommand;
        private readonly IRendererFeaturesCache rendererFeaturesCache;
        private readonly IProfileCache profileCache;
        private readonly URLDomain assetBundleURL;
        private readonly IInputBlock inputBlock;
        private readonly IChatMessagesBus chatMessagesBus;
        private readonly ISystemMemoryCap systemMemoryCap;
        private readonly VolumeBus volumeBus;
        private readonly HttpEventsApiService eventsApiService;
        private readonly GoogleUserCalendar userCalendar;
        private readonly ISystemClipboard clipboard;
        private readonly INavmapBus navmapBus;
        private readonly NavmapCommandFactory navmapCommandFactory;
        private readonly IAppArgs appArgs;
        private readonly IUserBlockingCache userBlockingCache;
        private readonly SceneLoadingLimit sceneLoadingLimit;
        private readonly WarningNotificationView inWorldWarningNotificationView;
        private readonly ProfileChangesBus profileChangesBus;
        private readonly CommunitiesDataProvider communitiesDataProvider;
        private readonly INftNamesProvider nftNamesProvider;
        private readonly IThumbnailProvider thumbnailProvider;
        private readonly ProfileRepositoryWrapper profileRepositoryWrapper;
        private readonly UpscalingController upscalingController;
        private readonly GalleryEventBus galleryEventBus;
        private readonly ICommunityCallOrchestrator communityCallOrchestrator;
        private readonly JoinedCommunitiesVoiceLiveTracker joinedCommunitiesVoiceLiveTracker;
        private readonly IPendingTransferService ownedNftFilter;
        private readonly MarketplaceCreditsAPIClient marketplaceCreditsAPIClient;
        private readonly IPassportBridge passportBridge;
        private readonly DCLInput dclInput;
        private readonly SmartWearableCache smartWearableCache;
        private readonly HomePlaceEventBus homePlaceEventBus;
        private readonly IAnalyticsController analytics;
        private readonly CommunityDataService communityDataService;
        private readonly ILoadingStatus loadingStatus;
        private readonly ImageControllerProvider imageControllerProvider;
        private readonly IFriendsService? friendsService;
        private readonly IDonationsService donationsService;
        private readonly IRealmNavigator realmNavigator;
        private readonly IWorldPermissionsService worldPermissionsService;
        private ICreditsPanelController creditsPanelController = new NullCreditsPanelController();
        private readonly bool isVoiceChatFeatureEnabled;
        private readonly bool isChatTranslationFeatureEnabled;

        private NavmapController? navmapController;
        private SettingsController? settingsController;
        private BackpackSubPlugin? backpackSubPlugin;
        private CategoryFilterController? categoryFilterController;
        private SearchResultPanelController? searchResultPanelController;
        private PlacesAndEventsPanelController? placesAndEventsPanelController;
        private NavmapView? navmapView;
        private PlaceInfoPanelController? placeInfoPanelController;
        private NavmapSearchBarController? searchBarController;
        private EventInfoPanelController? eventInfoPanelController;
        private CommunitiesBrowserController? communitiesBrowserController;
        private ExplorePanelController? explorePanelController;
        private PlacesController? placesController;
        private PlaceDetailPanelController? placeDetailPanelController;
        private EventsController? eventsController;
        private EventDetailPanelController? eventDetailPanelController;
        private readonly SpringBoneSimulationSettings springBoneSimulationSettings;

        public ExplorePanelPlugin(IEventBus eventBus,
            IAssetsProvisioner assetsProvisioner,
            IMVCManager mvcManager,
            MapRendererContainer mapRendererContainer,
            IPlacesAPIService placesAPIService,
            IWebRequestController webRequestController,
            IWeb3IdentityCache web3IdentityCache,
            ICameraReelStorageService cameraReelStorageService,
            ICameraReelScreenshotsStorage cameraReelScreenshotsStorage,
            ISystemClipboard systemClipboard,
            IDecentralandUrlsSource decentralandUrlsSource,
            IWearableStorage wearableStorage,
            ICharacterPreviewFactory characterPreviewFactory,
            IProfileRepository profileRepository,
            ICompositeWeb3Provider web3Authenticator,
            IUserInAppInitializationFlow userInAppInitializationFlow,
            ISelfProfile selfProfile,
            IEquippedWearables equippedWearables,
            IEquippedEmotes equippedEmotes,
            UnityAppWebBrowser webBrowser,
            IEmoteStorage emoteStorage,
            IRealmData realmData,
            IProfileCache profileCache,
            CharacterPreviewEventBus characterPreviewEventBus,
            IMapPathEventBus mapPathEventBus,
            IBackpackEventBus backpackEventBus,
            IThirdPartyNftProviderSource thirdPartyNftProviderSource,
            IWearablesProvider wearablesProvider,
            ICursor cursor,
            IInputBlock inputBlock,
            IEmoteProvider emoteProvider,
            Arch.Core.World world,
            Entity playerEntity,
            IChatMessagesBus chatMessagesBus,
            ISystemMemoryCap systemMemoryCap,
            VolumeBus volumeBus,
            HttpEventsApiService eventsApiService,
            GoogleUserCalendar userCalendar,
            ISystemClipboard clipboard,
            INavmapBus navmapBus,
            NavmapCommandFactory navmapCommandFactory,
            IAppArgs appArgs,
            IUserBlockingCache userBlockingCache,
            ProfileChangesBus profileChangesBus,
            SceneLoadingLimit sceneLoadingLimit,
            WarningNotificationView inWorldWarningNotificationView,
            ProfileRepositoryWrapper profileDataProvider,
            UpscalingController upscalingController,
            CommunitiesDataProvider communitiesDataProvider,
            INftNamesProvider nftNamesProvider,
            IVoiceChatOrchestrator communityCallOrchestrator,
            GalleryEventBus galleryEventBus,
            IThumbnailProvider thumbnailProvider,
            IPassportBridge passportBridge,
            HomePlaceEventBus homePlaceEventBus,
            SmartWearableCache smartWearableCache,
            ImageControllerProvider imageControllerProvider,
            IAnalyticsController analytics,
            CommunityDataService communityDataService,
            ILoadingStatus loadingStatus,
            IDonationsService donationsService,
            IRealmNavigator realmNavigator,
            IFriendsService? friendsService,
            PublishIpfsEntityCommand publishIpfsEntityCommand,
            IWorldPermissionsService worldPermissionsService,
            IRendererFeaturesCache rendererFeaturesCache,
            SpringBoneSimulationSettings springBoneSimulationSettings,
            JoinedCommunitiesVoiceLiveTracker joinedCommunitiesVoiceLiveTracker,
            IPendingTransferService ownedNftFilter,
            MarketplaceCreditsAPIClient marketplaceCreditsAPIClient
            )
        {
            this.eventBus = eventBus;
            this.assetsProvisioner = assetsProvisioner;
            this.mvcManager = mvcManager;
            this.mapRendererContainer = mapRendererContainer;
            this.placesAPIService = placesAPIService;
            this.webRequestController = webRequestController;
            this.web3IdentityCache = web3IdentityCache;
            this.cameraReelStorageService = cameraReelStorageService;
            this.cameraReelScreenshotsStorage = cameraReelScreenshotsStorage;
            this.systemClipboard = systemClipboard;
            this.decentralandUrlsSource = decentralandUrlsSource;
            this.wearableStorage = wearableStorage;
            this.characterPreviewFactory = characterPreviewFactory;
            this.profileRepository = profileRepository;
            this.web3Authenticator = web3Authenticator;
            this.userInAppInitializationFlow = userInAppInitializationFlow;
            this.selfProfile = selfProfile;
            this.equippedWearables = equippedWearables;
            this.equippedEmotes = equippedEmotes;
            this.webBrowser = webBrowser;
            this.realmData = realmData;
            this.profileCache = profileCache;
            this.emoteStorage = emoteStorage;
            this.characterPreviewEventBus = characterPreviewEventBus;
            this.mapPathEventBus = mapPathEventBus;
            this.backpackEventBus = backpackEventBus;
            this.thirdPartyNftProviderSource = thirdPartyNftProviderSource;
            this.wearablesProvider = wearablesProvider;
            this.inputBlock = inputBlock;
            this.cursor = cursor;
            this.emoteProvider = emoteProvider;
            this.world = world;
            this.playerEntity = playerEntity;
            this.chatMessagesBus = chatMessagesBus;
            this.systemMemoryCap = systemMemoryCap;
            this.volumeBus = volumeBus;
            this.eventsApiService = eventsApiService;
            this.userCalendar = userCalendar;
            this.clipboard = clipboard;
            this.navmapBus = navmapBus;
            this.navmapCommandFactory = navmapCommandFactory;
            this.appArgs = appArgs;
            this.userBlockingCache = userBlockingCache;
            this.profileChangesBus = profileChangesBus;
            this.sceneLoadingLimit = sceneLoadingLimit;
            this.inWorldWarningNotificationView = inWorldWarningNotificationView;
            this.profileRepositoryWrapper = profileDataProvider;
            this.upscalingController = upscalingController;
            this.communitiesDataProvider = communitiesDataProvider;
            this.nftNamesProvider = nftNamesProvider;
            this.galleryEventBus = galleryEventBus;
            this.communityCallOrchestrator = communityCallOrchestrator;
            this.thumbnailProvider = thumbnailProvider;
            dclInput = DCLInput.Instance;
            this.homePlaceEventBus = homePlaceEventBus;
            this.passportBridge = passportBridge;
            this.smartWearableCache = smartWearableCache;
            this.imageControllerProvider = imageControllerProvider;
            this.analytics = analytics;
            this.communityDataService = communityDataService;
            this.loadingStatus = loadingStatus;
            this.donationsService = donationsService;
            this.realmNavigator = realmNavigator;
            this.friendsService = friendsService;
            this.publishIpfsEntityCommand = publishIpfsEntityCommand;
            this.worldPermissionsService = worldPermissionsService;
            this.rendererFeaturesCache = rendererFeaturesCache;
            this.springBoneSimulationSettings = springBoneSimulationSettings;
            this.joinedCommunitiesVoiceLiveTracker = joinedCommunitiesVoiceLiveTracker;
            this.ownedNftFilter = ownedNftFilter;
            this.marketplaceCreditsAPIClient = marketplaceCreditsAPIClient;
        }

        public void Dispose()
        {
            upscalingController.Dispose();
            categoryFilterController?.Dispose();
            navmapController?.Dispose();
            settingsController?.Dispose();
            backpackSubPlugin?.Dispose();
            placeInfoPanelController?.Dispose();
            communitiesBrowserController?.Dispose();
            placesController?.Dispose();
            explorePanelController?.Dispose();
            eventsController?.Dispose();
            eventDetailPanelController?.Dispose();
            placeDetailPanelController?.Dispose();
            creditsPanelController.Dispose();

            dclInput.Shortcuts.MainMenu.performed -= OnInputShortcutsMainMenuPerformedAsync;
            dclInput.Shortcuts.Map.performed -= OnInputShortcutsMapPerformedAsync;
            dclInput.Shortcuts.Settings.performed -= OnInputShortcutsSettingsPerformedAsync;
            dclInput.Shortcuts.Backpack.performed -= OnInputShortcutsBackpackPerformedAsync;
            dclInput.Shortcuts.CameraReel.performed -= OnInputShortcutsCameraReelPerformedAsync;
            dclInput.Shortcuts.Places.performed += OnInputShortcutsPlacesPerformed;
        }

        public void InjectToWorld(ref ArchSystemsWorldBuilder<Arch.Core.World> builder, in GlobalPluginArguments arguments) { }

        public async UniTask InitializeAsync(ExplorePanelSettings settings, CancellationToken ct)
        {
            dclInput.Shortcuts.MainMenu.performed += OnInputShortcutsMainMenuPerformedAsync;
            dclInput.Shortcuts.Map.performed += OnInputShortcutsMapPerformedAsync;
            dclInput.Shortcuts.Settings.performed += OnInputShortcutsSettingsPerformedAsync;
            dclInput.Shortcuts.Backpack.performed += OnInputShortcutsBackpackPerformedAsync;

            if (FeaturesRegistry.Instance.IsEnabled(FeatureId.DISCOVER))
                dclInput.Shortcuts.Places.performed += OnInputShortcutsPlacesPerformed;

            if (FeaturesRegistry.Instance.IsEnabled(FeatureId.CAMERA_REEL))
                dclInput.Shortcuts.CameraReel.performed += OnInputShortcutsCameraReelPerformedAsync;

            var outfitsRepository = new OutfitsRepository(publishIpfsEntityCommand, nftNamesProvider, selfProfile);

            backpackSubPlugin = new BackpackSubPlugin(
                assetsProvisioner,
                web3IdentityCache,
                characterPreviewFactory,
                wearableStorage,
                selfProfile,
                profileCache,
                equippedWearables,
                equippedEmotes,
                emoteStorage,
                characterPreviewEventBus,
                backpackEventBus,
                thirdPartyNftProviderSource,
                wearablesProvider,
                inputBlock,
                cursor,
                emoteProvider,
                world,
                playerEntity,
                appArgs,
                webBrowser,
                inWorldWarningNotificationView,
                thumbnailProvider,
                profileChangesBus,
                outfitsRepository,
                realmData,
                webRequestController,
                nftNamesProvider,
                eventBus,
                smartWearableCache,
                mvcManager,
                decentralandUrlsSource,
                ownedNftFilter
            );

            ExplorePanelView panelViewAsset = (await assetsProvisioner.ProvideMainAssetValueAsync(settings.ExplorePanelPrefab, ct: ct)).GetComponent<ExplorePanelView>();
            ControllerBase<ExplorePanelView, ExplorePanelParameter>.ViewFactoryMethod viewFactoryMethod = ExplorePanelController.Preallocate(panelViewAsset, null, out ExplorePanelView explorePanelView);

            ProvidedAsset<AudioMixer> generalAudioMixer = await assetsProvisioner.ProvideMainAssetAsync(settings.GeneralAudioMixer, ct);

            ProvidedAsset<LandscapeData> landscapeData = await assetsProvisioner.ProvideMainAssetAsync(settings.LandscapeData, ct);

            ProvidedAsset<CategoryMappingSO> categoryMappingSO = await assetsProvisioner.ProvideMainAssetAsync(settings.CategoryMappingSO, ct);

            ProvidedAsset<PlaceCategoriesSO> placeCategoriesSO = await assetsProvisioner.ProvideMainAssetAsync(settings.PlaceCategoriesSO, ct);

            navmapView = explorePanelView.GetComponentInChildren<NavmapView>();
            categoryFilterController = new CategoryFilterController(navmapView.categoryToggles, mapRendererContainer.MapRenderer, navmapBus);

            NavmapZoomController zoomController = new (navmapView.zoomView, navmapBus);

            ObjectPool<PlaceElementView> placeElementsPool = await InitializePlaceElementsPoolAsync(navmapView.SearchBarResultPanel, ct);
            ObjectPool<EventElementView> eventElementsPool = await InitializeEventElementsForPlacePoolAsync(navmapView.PlacesAndEventsPanelView.PlaceInfoPanelView, ct);
            ObjectPool<EventScheduleElementView> eventScheduleElementsPool = await InitializeEventScheduleElementsPoolAsync(navmapView.PlacesAndEventsPanelView.EventInfoPanelView, ct);

            searchResultPanelController = new SearchResultPanelController(navmapView.SearchBarResultPanel,
                placeElementsPool, navmapBus);

            searchBarController = new NavmapSearchBarController(navmapView.SearchBarView,
                navmapView.HistoryRecordPanelView, navmapView.PlacesAndEventsPanelView.SearchFiltersView,
                inputBlock, navmapBus, categoryMappingSO.Value);

            SharePlacesAndEventsContextMenuController shareContextMenu = new (navmapView.ShareContextMenuView,
                navmapView.WorldsWarningNotificationView, clipboard, webBrowser, decentralandUrlsSource);

            placeInfoPanelController = new PlaceInfoPanelController(navmapView.PlacesAndEventsPanelView.PlaceInfoPanelView,
                imageControllerProvider, placesAPIService, mapPathEventBus, navmapBus, chatMessagesBus, eventsApiService,
                eventElementsPool, shareContextMenu, webBrowser, mvcManager, homePlaceEventBus, donationsService, cameraReelStorageService, cameraReelScreenshotsStorage,
                new ReelGalleryConfigParams(
                    settings.PlaceGridLayoutFixedColumnCount,
                    settings.PlaceThumbnailHeight,
                    settings.PlaceThumbnailWidth,
                    false,
                    false),
                false,
                galleryEventBus: galleryEventBus);

            eventInfoPanelController = new EventInfoPanelController(navmapView.PlacesAndEventsPanelView.EventInfoPanelView,
                navmapBus, chatMessagesBus, eventsApiService, eventScheduleElementsPool,
                userCalendar, shareContextMenu, webBrowser, decentralandUrlsSource, imageControllerProvider);

            placesAndEventsPanelController = new PlacesAndEventsPanelController(navmapView.PlacesAndEventsPanelView,
                searchBarController, searchResultPanelController, placeInfoPanelController, eventInfoPanelController,
                zoomController);

            navmapCommandFactory.AttachUiControllers(placesAndEventsPanelController, searchResultPanelController,
                searchBarController, placeInfoPanelController, eventInfoPanelController);

            IMapRenderer mapRenderer = mapRendererContainer.MapRenderer;

            SatelliteController satelliteController = new (navmapView.GetComponentInChildren<SatelliteView>(),
                navmapView.MapCameraDragBehaviorData, mapRenderer, webBrowser);

            PlaceInfoToastController placeToastController = new (navmapView.PlaceToastView,
                new PlaceInfoPanelController(navmapView.PlaceToastView.PlacePanelView,
                    imageControllerProvider, placesAPIService, mapPathEventBus, navmapBus, chatMessagesBus, eventsApiService,
                    eventElementsPool, shareContextMenu, webBrowser, mvcManager, homePlaceEventBus, donationsService, galleryEventBus: galleryEventBus),
                placesAPIService, eventsApiService, navmapBus);

            QualitySettingsController qualitySettingsController = new QualitySettingsController(
                settings.QualityPresets,
                upscalingController,
                settings.RealmPartitionSettings,
                landscapeData.Value,
                rendererFeaturesCache,
                appArgs,
                analytics,
                springBoneSimulationSettings);

            settingsController = new SettingsController(
                explorePanelView.GetComponentInChildren<SettingsView>(),
                settings.SettingsMenuConfiguration,
                qualitySettingsController,
                generalAudioMixer.Value,
                settings.VideoPrioritizationSettings,
                settings.ControlsSettingsAsset,
                systemMemoryCap,
                settings.ChatSettingsAsset,
                userBlockingCache,
                sceneLoadingLimit,
                volumeBus,
                assetsProvisioner,
                eventBus,
                settings.pointAtMarkerVisibilitySettings);

            await settingsController.InitializeAsync();

            navmapController = new NavmapController(
                navmapView: explorePanelView.GetComponentInChildren<NavmapView>(),
                mapRendererContainer.MapRenderer,
                realmData,
                mapPathEventBus,
                world,
                playerEntity,
                navmapBus,
                UIAudioEventsBus.Instance,
                placesAndEventsPanelController,
                searchBarController,
                zoomController,
                satelliteController,
                placesAPIService,
                homePlaceEventBus);

            await backpackSubPlugin.InitializeAsync(settings.BackpackSettings, explorePanelView.GetComponentInChildren<BackpackView>(), ct);

            CameraReelView cameraReelView = explorePanelView.GetComponentInChildren<CameraReelView>();

            var cameraReelController = new CameraReelController(cameraReelView,
                new CameraReelGalleryController(
                    cameraReelView.CameraReelGalleryView,
                    this.cameraReelStorageService,
                    cameraReelScreenshotsStorage,
                    new ReelGalleryConfigParams(settings.GridLayoutFixedColumnCount, settings.ThumbnailHeight, settings.ThumbnailWidth, true, true), true,
                    galleryEventBus,
                    cameraReelView.CameraReelOptionsButton,
                    webBrowser, decentralandUrlsSource, systemClipboard,
                    settings.CameraReelGalleryMessages,
                    mvcManager),
                cameraReelStorageService,
                web3IdentityCache,
                mvcManager,
                cursor,
                galleryEventBus,
                settings.StorageProgressBarText);

            CommunitiesBrowserView communitiesBrowserView = explorePanelView.GetComponentInChildren<CommunitiesBrowserView>();

            communitiesBrowserController = new CommunitiesBrowserController(
                communitiesBrowserView,
                cursor,
                communitiesDataProvider,
                webRequestController,
                inputBlock,
                mvcManager,
                profileRepositoryWrapper,
                selfProfile,
                nftNamesProvider,
                communityCallOrchestrator,
                analytics,
                communityDataService,
                loadingStatus,
                webBrowser,
                decentralandUrlsSource);

            var placesCardSocialActionsController = new PlacesCardSocialActionsController(placesAPIService, realmNavigator, webBrowser, clipboard, decentralandUrlsSource, navmapBus, mapPathEventBus, homePlaceEventBus);
            var placesThumbnailLoader = new ThumbnailLoader(new SpriteCache(webRequestController));
            PlacesView placesView = explorePanelView.GetComponentInChildren<PlacesView>();
            placesController = new PlacesController(placesView, cursor, placesAPIService, placeCategoriesSO.Value, inputBlock, selfProfile, webBrowser,
                friendsService, profileRepositoryWrapper, mvcManager, placesThumbnailLoader, placesCardSocialActionsController, homePlaceEventBus, worldPermissionsService, eventsApiService);

            PlaceDetailPanelView placeDetailPanelViewAsset = (await assetsProvisioner.ProvideMainAssetValueAsync(settings.PlaceDetailPanelPrefab, ct: ct)).GetComponent<PlaceDetailPanelView>();
            var placeDetailPanelViewFactory = PlaceDetailPanelController.CreateLazily(placeDetailPanelViewAsset, null);
            placeDetailPanelController = new PlaceDetailPanelController(placeDetailPanelViewFactory, placesThumbnailLoader, profileRepository,
                placesCardSocialActionsController, navmapBus, mapPathEventBus, homePlaceEventBus, mvcManager, worldPermissionsService);
            mvcManager.RegisterController(placeDetailPanelController);

            EventCardActionsController eventCardActionsController = new EventCardActionsController(eventsApiService, webBrowser, realmNavigator, clipboard, decentralandUrlsSource);
            var eventsThumbnailLoader = new ThumbnailLoader(new SpriteCache(webRequestController));
            EventsView eventsView = explorePanelView.GetComponentInChildren<EventsView>();
            eventsController = new EventsController(eventsView, cursor, eventsApiService, placesAPIService, webBrowser, decentralandUrlsSource, mvcManager,
                eventsThumbnailLoader, eventCardActionsController, profileRepositoryWrapper, friendsService, communitiesDataProvider);

            EventDetailPanelView eventDetailPanelViewAsset = (await assetsProvisioner.ProvideMainAssetValueAsync(settings.EventInfoPrefab, ct: ct)).GetComponent<EventDetailPanelView>();
            var eventInfoViewFactory = EventDetailPanelController.CreateLazily(eventDetailPanelViewAsset, null);
            eventDetailPanelController = new EventDetailPanelController(eventInfoViewFactory,
                eventsThumbnailLoader,
                eventCardActionsController);
            mvcManager.RegisterController(eventDetailPanelController);

            bool userCreditsEnabled = FeaturesRegistry.Instance.IsEnabled(FeatureId.USER_CREDITS);
            explorePanelView.CreditsPanelView.gameObject.SetActive(userCreditsEnabled);

            if (userCreditsEnabled)
                creditsPanelController = new CreditsPanelController(explorePanelView.CreditsPanelView, marketplaceCreditsAPIClient, profileChangesBus, web3IdentityCache);

            explorePanelController = new
                ExplorePanelController(
                    viewFactoryMethod,
                    navmapController,
                    settingsController,
                    backpackSubPlugin.backpackController!,
                    cameraReelController,
                    new SidebarProfileButtonPresenter(explorePanelView.ProfileWidget, web3IdentityCache, profileRepository, profileChangesBus),
                    new ProfileMenuController(() => explorePanelView.ProfileMenuView,
                        web3IdentityCache,
                        world,
                        playerEntity,
                        webBrowser,
                        web3Authenticator,
                        userInAppInitializationFlow,
                        profileCache,
                        passportBridge,
                        profileRepositoryWrapper),
                    communitiesBrowserController,
                    placesController,
                    eventsController,
                    inputBlock,
                    eventsApiService,
                    mvcManager,
                    joinedCommunitiesVoiceLiveTracker,
                    creditsPanelController);

            mvcManager.RegisterController(explorePanelController);

            bool isCommunitiesFeatureEnabled = await CommunitiesFeatureAccess.Instance.IsUserAllowedToUseTheFeatureAsync(ct, ignoreAllowedList: true);

            if (isCommunitiesFeatureEnabled)
                dclInput.Shortcuts.Communities.performed += OnInputShortcutsCommunitiesPerformed;

            if (appArgs.HasFlag(AppArgsFlags.FORCE_OPEN_BACKPACK))
                BackpackDeepLinkOpener.OpenBackpackWhenLandedAsync(mvcManager, loadingStatus, ct).Forget();
        }

        private async UniTask<ObjectPool<PlaceElementView>> InitializePlaceElementsPoolAsync(SearchResultPanelView view, CancellationToken ct)
        {
            PlaceElementView asset = (await assetsProvisioner.ProvideInstanceAsync(view.ResultRef, ct: ct)).Value;

            return new ObjectPool<PlaceElementView>(
                CreatePoolElements,
                actionOnGet: result => result.gameObject.SetActive(true),
                actionOnRelease: result => result.gameObject.SetActive(false),
                defaultCapacity: 8
            );

            PlaceElementView CreatePoolElements()
            {
                PlaceElementView placeElementView = Object.Instantiate(asset, view.searchResultsContainer);
                placeElementView.ConfigurePlaceImageController(imageControllerProvider);
                return placeElementView;
            }
        }

        private async UniTask<ObjectPool<EventElementView>> InitializeEventElementsForPlacePoolAsync(PlaceInfoPanelView view, CancellationToken ct)
        {
            EventElementView asset = (await assetsProvisioner.ProvideInstanceAsync(view.EventElementViewRef, ct: ct)).Value;

            return new ObjectPool<EventElementView>(
                CreatePoolElements,
                actionOnGet: result => result.gameObject.SetActive(true),
                actionOnRelease: result => result.gameObject.SetActive(false),
                defaultCapacity: 8
            );

            EventElementView CreatePoolElements()
            {
                EventElementView placeElementView = Object.Instantiate(asset, view.EventsContentContainer.transform);
                return placeElementView;
            }
        }

        private void OnInputShortcutsBackpackPerformedAsync(InputAction.CallbackContext _) =>
            mvcManager.ShowAsync(ExplorePanelController.IssueCommand(new ExplorePanelParameter(ExploreSections.Backpack)));

        private void OnInputShortcutsSettingsPerformedAsync(InputAction.CallbackContext _) =>
            mvcManager.ShowAsync(ExplorePanelController.IssueCommand(new ExplorePanelParameter(ExploreSections.Settings)));

        private void OnInputShortcutsMapPerformedAsync(InputAction.CallbackContext _) =>
            mvcManager.ShowAsync(ExplorePanelController.IssueCommand(new ExplorePanelParameter(ExploreSections.Navmap)));

        private void OnInputShortcutsMainMenuPerformedAsync(InputAction.CallbackContext _) =>
            mvcManager.ShowAsync(ExplorePanelController.IssueCommand(default(ExplorePanelParameter)));

        private void OnInputShortcutsCameraReelPerformedAsync(InputAction.CallbackContext obj) =>
            mvcManager.ShowAsync(ExplorePanelController.IssueCommand(new ExplorePanelParameter(ExploreSections.CameraReel)));

        private void OnInputShortcutsCommunitiesPerformed(InputAction.CallbackContext obj) =>
            mvcManager.ShowAsync(ExplorePanelController.IssueCommand(new ExplorePanelParameter(ExploreSections.Communities)));

        private void OnInputShortcutsPlacesPerformed(InputAction.CallbackContext obj) =>
            mvcManager.ShowAsync(ExplorePanelController.IssueCommand(new ExplorePanelParameter(ExploreSections.Places)));

        private async UniTask<ObjectPool<EventScheduleElementView>> InitializeEventScheduleElementsPoolAsync(EventInfoPanelView view, CancellationToken ct)
        {
            EventScheduleElementView asset = (await assetsProvisioner.ProvideInstanceAsync(view.ScheduleElementRef, ct: ct)).Value;

            return new ObjectPool<EventScheduleElementView>(
                CreatePoolElements,
                actionOnGet: result => result.gameObject.SetActive(true),
                actionOnRelease: result => result.gameObject.SetActive(false),
                defaultCapacity: 8
            );

            EventScheduleElementView CreatePoolElements()
            {
                EventScheduleElementView placeElementView = Object.Instantiate(asset, view.ScheduleElementsContainer);
                return placeElementView;
            }
        }

        [Serializable]
        public class ExplorePanelSettings : IDCLPluginSettings
        {
            [field: SerializeField] public AssetReferenceGameObject ExplorePanelPrefab { get; private set; } = null!;
            [field: SerializeField] public BackpackSettings BackpackSettings { get; private set; } = null!;
            [field: SerializeField] public string[] EmbeddedEmotes { get; private set; } = null!;
            [field: SerializeField] public SettingsMenuConfiguration SettingsMenuConfiguration { get; private set; } = null!;
            [field: SerializeField] public AssetReferenceT<AudioMixer> GeneralAudioMixer { get; private set; } = null!;
            [field: SerializeField] public RealmPartitionSettingsAsset RealmPartitionSettings { get; private set; } = null!;
            [field: SerializeField] public VideoPrioritizationSettings VideoPrioritizationSettings { get; private set; } = null!;
            [field: SerializeField] public LandscapeDataRef LandscapeData { get; private set; } = null!;
            [field: SerializeField] public QualitySettingsAsset QualitySettingsAsset { get; private set; } = null!;
            [field: SerializeField] public SkyboxSettingsAsset SkyboxSettingsAsset { get; private set; } = null!;
            [field: SerializeField] public ControlsSettingsAsset ControlsSettingsAsset { get; private set; } = null!;
            [field: SerializeField] public ChatSettingsAsset ChatSettingsAsset { get; private set; } = null!;
            [field: SerializeField] public AssetReferenceT<CategoryMappingSO> CategoryMappingSO { get; private set; } = null!;

            [field: SerializeField]
            public PointAtMarkerVisibilitySettings pointAtMarkerVisibilitySettings { get; private set; }

            [field: Header("Camera Reel")]
            [field: Tooltip("Spaces will be HTTP sanitized, care for special characters")]
            [field: SerializeField] public CameraReelGalleryMessagesConfiguration CameraReelGalleryMessages { get; private set; } = null!;
            [field: SerializeField] public string StorageProgressBarText { get; private set; } = null!;
            [field: SerializeField] public int GridLayoutFixedColumnCount { get; private set; }
            [field: SerializeField] public int ThumbnailHeight { get; private set; }
            [field: SerializeField] public int ThumbnailWidth { get; private set; }
            [field: Header("Place Reel")] [field: SerializeField] public int PlaceGridLayoutFixedColumnCount { get; private set; }
            [field: SerializeField] public int PlaceThumbnailHeight { get; private set; }
            [field: SerializeField] public int PlaceThumbnailWidth { get; private set; }
            [field: SerializeField] public AssetReferenceT<PlaceCategoriesSO> PlaceCategoriesSO { get; private set; }
            [field: Header("Place Detail Panel")] [field: SerializeField] internal AssetReferenceGameObject PlaceDetailPanelPrefab { get; private set; }
            [field: Header("Event Detail Panel")] [field: SerializeField] internal AssetReferenceGameObject EventInfoPrefab { get; private set; }
            [field: Header("Quality Settings")] [field: SerializeField] internal QualityPresetsAsset QualityPresets { get; private set; }
        }
    }
}