DynamicWorldContainer.cs

using Arch.Core;
using CommunicationData.URLHelpers;
using Cysharp.Threading.Tasks;
using DCL.ApplicationBlocklistGuard;
using DCL.AssetsProvision;
using DCL.Audio;
using DCL.AvatarRendering.Emotes;
using DCL.AvatarRendering.Emotes.Equipped;
using DCL.AvatarRendering.Wearables;
using DCL.AvatarRendering.Wearables.Equipped;
using DCL.AvatarRendering.Wearables.Helpers;
using DCL.AvatarRendering.Wearables.ThirdParty;
using DCL.Backpack.BackpackBus;
using DCL.BadgesAPIService;
using DCL.Browser;
using DCL.CharacterPreview;
using DCL.Chat.ChatServices;
using DCL.Chat.Commands;
using DCL.Chat.History;
using DCL.Chat.MessageBus;
using DCL.ChatArea;
using DCL.Clipboard;
using DCL.Communities;
using DCL.SpringBones;
using DCL.Communities.CommunitiesCard.Members;
using DCL.Communities.CommunitiesDataProvider;
using DCL.DebugUtilities;
using DCL.Diagnostics;
using DCL.Donations;
using DCL.EventsApi;
using DCL.FeatureFlags;
using DCL.Friends;
using DCL.Friends.Passport;
using DCL.Friends.UserBlocking;
using DCL.Input;
using DCL.InWorldCamera;
using DCL.InWorldCamera.CameraReelStorageService;
using DCL.LOD.Systems;
using DCL.MapRenderer;
using DCL.Multiplayer.Connections.Archipelago.AdapterAddress.Current;
using DCL.Multiplayer.Connections.Archipelago.Rooms;
using DCL.Multiplayer.Connections.Archipelago.Rooms.Chat;
using DCL.Multiplayer.Connections.DecentralandUrls;
using DCL.Multiplayer.Connections.GateKeeper.Meta;
using DCL.Multiplayer.Connections.GateKeeper.Rooms;
using DCL.Multiplayer.Connections.GateKeeper.Rooms.Options;
using DCL.Multiplayer.Connections.Messaging.Hubs;
using DCL.Multiplayer.Connections.Pools;
using DCL.Multiplayer.Connections.RoomHubs;
using DCL.Multiplayer.Connections.Rooms.Connective;
using DCL.Multiplayer.Connections.Rooms.Status;
using DCL.Multiplayer.Connections.Systems.Throughput;
using DCL.Multiplayer.Connectivity;
using DCL.Multiplayer.Emotes;
using DCL.Multiplayer.HealthChecks;
using DCL.Multiplayer.Movement;
using DCL.Multiplayer.Movement.Systems;
using DCL.Multiplayer.Profiles.BroadcastProfiles;
using DCL.Multiplayer.Profiles.Entities;
using DCL.Multiplayer.Profiles.Poses;
using DCL.Multiplayer.Profiles.RemoteAnnouncements;
using DCL.Multiplayer.Profiles.RemoteProfiles;
using DCL.Multiplayer.Profiles.Tables;
using DCL.Multiplayer.SDK.Systems.GlobalWorld;
using DCL.Navmap;
using DCL.NftInfoAPIService;
using DCL.Notifications;
using DCL.Optimization.Pools;
using DCL.PerformanceAndDiagnostics.Analytics;
using DCL.PlacesAPIService;
using DCL.PluginSystem;
using DCL.PluginSystem.Global;
using DCL.Profiles;
using DCL.Profiles.Self;
using DCL.RealmNavigation;
using DCL.Rendering.GPUInstancing.Systems;
using DCL.RuntimeDeepLink;
using DCL.SceneLoadingScreens.LoadingScreen;
using DCL.SkyBox;
using DCL.SocialService;
using DCL.UI;
using DCL.UI.ConfirmationDialog;
using DCL.UI.InputFieldFormatting;
using DCL.UI.MainUI;
using DCL.UI.ProfileElements;
using DCL.UI.Profiles.Helpers;
using DCL.Prefs;
using DCL.UserInAppInitializationFlow;
using DCL.Utilities;
using DCL.Utilities.Extensions;
using DCL.VoiceChat;
using DCL.VoiceChat.Nearby;
using DCL.VoiceChat.Nearby.MutePersistence;
using DCL.Web3.Identities;
using ECS.Prioritization.Components;
using ECS.SceneLifeCycle;
using ECS.SceneLifeCycle.CurrentScene;
using ECS.SceneLifeCycle.Realm;
using Global.AppArgs;
using Global.Dynamic.ChatCommands;
using Global.Dynamic.RealmUrl;
using Global.Versioning;
using DCL.LiveKit.Public;
using LiveKit.Internal.FFIClients.Pools;
using LiveKit.Internal.FFIClients.Pools.Memory;
using MVC;
using MVC.PopupsController.PopupCloser;
using SceneRunner.Debugging.Hub;
using System;
using System.Buffers;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using DCL.MapRenderer.MapLayers.HomeMarker;
using DCL.Backpack.Gifting.Services;
using DCL.Backpack.Gifting.Services.PendingTransfers;
using DCL.Backpack.Gifting.Services.SnapshotEquipped;
using DCL.Chat;
using DCL.NotificationsBus;
using DCL.PluginSystem.SmartWearables;
using DCL.Optimization.AdaptivePerformance.Systems;
using DCL.PluginSystem.World;
using DCL.SDKComponents.AvatarLocomotion;
using DCL.PerformanceAndDiagnostics.Analytics.DecoratorBased;
using DCL.PrivateWorlds;
using DCL.Translation;
using System.Diagnostics.CodeAnalysis;
using UnityEngine;
using UnityEngine.Audio;
using UnityEngine.EventSystems;
using UnityEngine.Pool;
using Utility;
using Utility.Ownership;
using Utility.PriorityQueue;
using MultiplayerPlugin = DCL.PluginSystem.Global.MultiplayerPlugin;
using Object = UnityEngine.Object;

namespace Global.Dynamic
{
    public class DynamicWorldContainer : DCLWorldContainer<DynamicWorldSettings>
    {
        private readonly IChatMessagesBus chatMessagesBus;
        private readonly IChatHistory chatHistory;
        private readonly IProfileBroadcast profileBroadcast;
        private readonly SocialServicesContainer socialServicesContainer;
        private readonly ISelfProfile selfProfile;
        private readonly BannedNotificationHandler bannedNotificationHandler;
        private readonly ProfileRepositoryWrapper profileRepositoryWrapper;
        private readonly JoinedCommunitiesVoiceLiveTracker joinedCommunitiesVoiceLiveTracker;

        public IMVCManager MvcManager { get; }

        public IGlobalRealmController RealmController { get; }

        public IRealmNavigator RealmNavigator { get; }

        public GlobalWorldFactory GlobalWorldFactory { get; }

        public IReadOnlyList<IDCLGlobalPlugin> GlobalPlugins { get; }

        public IProfileRepository ProfileRepository { get; }

        public IUserInAppInitializationFlow UserInAppInAppInitializationFlow { get; }

        public IMessagePipesHub MessagePipesHub { get; }

        public IRemoteMetadata RemoteMetadata { get; }

        public IRoomHub RoomHub { get; }

        public ISystemClipboard SystemClipboard { get; }

        public IChatHistory ChatHistory => chatHistory;

        private DynamicWorldContainer(
            IMVCManager mvcManager,
            IGlobalRealmController realmController,
            IRealmNavigator realmNavigator,
            GlobalWorldFactory globalWorldFactory,
            IReadOnlyList<IDCLGlobalPlugin> globalPlugins,
            IProfileRepository profileRepository,
            IUserInAppInitializationFlow userInAppInAppInitializationFlow,
            IChatMessagesBus chatMessagesBus,
            IChatHistory chatHistory,
            IMessagePipesHub messagePipesHub,
            IRemoteMetadata remoteMetadata,
            IProfileBroadcast profileBroadcast,
            IRoomHub roomHub,
            SocialServicesContainer socialServicesContainer,
            ISelfProfile selfProfile,
            ISystemClipboard systemClipboard,
            BannedNotificationHandler bannedNotificationHandler,
            ProfileRepositoryWrapper profileRepositoryWrapper,
            JoinedCommunitiesVoiceLiveTracker joinedCommunitiesVoiceLiveTracker)
        {
            MvcManager = mvcManager;
            RealmController = realmController;
            RealmNavigator = realmNavigator;
            GlobalWorldFactory = globalWorldFactory;
            GlobalPlugins = globalPlugins;
            ProfileRepository = profileRepository;
            UserInAppInAppInitializationFlow = userInAppInAppInitializationFlow;
            MessagePipesHub = messagePipesHub;
            RemoteMetadata = remoteMetadata;
            RoomHub = roomHub;
            SystemClipboard = systemClipboard;
            this.chatMessagesBus = chatMessagesBus;
            this.chatHistory = chatHistory;
            this.profileBroadcast = profileBroadcast;
            this.socialServicesContainer = socialServicesContainer;
            this.selfProfile = selfProfile;
            this.bannedNotificationHandler = bannedNotificationHandler;
            this.profileRepositoryWrapper = profileRepositoryWrapper;
            this.joinedCommunitiesVoiceLiveTracker = joinedCommunitiesVoiceLiveTracker;
        }

        public override void Dispose()
        {
            bannedNotificationHandler.Dispose();
            chatMessagesBus.Dispose();
            profileBroadcast.Dispose();
            MessagePipesHub.Dispose();
            socialServicesContainer.Dispose();
            selfProfile.Dispose();
            profileRepositoryWrapper.Dispose();
            joinedCommunitiesVoiceLiveTracker.Dispose();
        }

        [SuppressMessage("ReSharper", "MethodHasAsyncOverloadWithCancellation")]
        public static async UniTask<(DynamicWorldContainer? container, bool success)> CreateAsync(
            BootstrapContainer bootstrapContainer,
            DynamicWorldDependencies dynamicWorldDependencies,
            DynamicWorldParams dynamicWorldParams,
            AudioClipConfig backgroundMusic,
            World globalWorld,
            Entity playerEntity,
            IAppArgs appArgs,
            ICoroutineRunner coroutineRunner,
            DCLVersion dclVersion,
            RealmUrls realmUrls,
            CancellationToken ct)
        {
            DynamicSettings dynamicSettings = dynamicWorldDependencies.DynamicSettings;
            StaticContainer staticContainer = dynamicWorldDependencies.StaticContainer;
            IWeb3IdentityCache identityCache = dynamicWorldDependencies.Web3IdentityCache;
            IAssetsProvisioner assetsProvisioner = dynamicWorldDependencies.AssetsProvisioner;
            IDebugContainerBuilder debugBuilder = dynamicWorldDependencies.DebugContainerBuilder;
            var explorePanelNavmapBus = new ObjectProxy<INavmapBus>();
            INavmapBus sharedNavmapCommandBus = new SharedNavmapBus(explorePanelNavmapBus);

            // If we have many undesired delays when using the third-party providers, it might be useful to cache it at app's bootstrap
            // So far, the chance of using it is quite low, so it's preferable to do it lazy avoiding extra requests & memory allocations
            IThirdPartyNftProviderSource thirdPartyNftProviderSource = new RealmThirdPartyNftProviderSource(staticContainer.WebRequestsContainer.WebRequestController,
                bootstrapContainer.DecentralandUrlsSource);

            var placesAPIService = new PlacesAPIService(new PlacesAPIClient(staticContainer.WebRequestsContainer.WebRequestController, bootstrapContainer.DecentralandUrlsSource));

            var eventsApiService = new HttpEventsApiService(staticContainer.WebRequestsContainer.WebRequestController, bootstrapContainer.DecentralandUrlsSource);

            var mapPathEventBus = new MapPathEventBus();
            NotificationsBusController.Initialize(new NotificationsBusController());

            DefaultTexturesContainer defaultTexturesContainer = null!;
            LODContainer lodContainer = null!;

            IOnlineUsersProvider baseUserProvider = new ArchipelagoHttpOnlineUsersProvider(staticContainer.WebRequestsContainer.WebRequestController,
                URLAddress.FromString(bootstrapContainer.DecentralandUrlsSource.Url(DecentralandUrl.RemotePeers)));

            var onlineUsersProvider = new WorldInfoOnlineUsersProviderDecorator(
                baseUserProvider,
                staticContainer.WebRequestsContainer.WebRequestController,
                URLAddress.FromString(bootstrapContainer.DecentralandUrlsSource.Url(DecentralandUrl.RemotePeersWorld)));

            async UniTask InitializeContainersAsync(IPluginSettingsContainer settingsContainer, CancellationToken ct)
            {
                // Init other containers
                defaultTexturesContainer =
                    await DefaultTexturesContainer
                         .CreateAsync(
                              settingsContainer,
                              assetsProvisioner,
                              appArgs,
                              ct
                          )
                         .ThrowOnFail();

                lodContainer =
                    await LODContainer
                         .CreateAsync(
                              assetsProvisioner,
                              staticContainer,
                              settingsContainer,
                              staticContainer.RealmData,
                              defaultTexturesContainer.TextureArrayContainerFactory,
                              debugBuilder,
                              dynamicWorldParams.EnableLOD,
                              staticContainer.GPUInstancingService,
                              ct
                          )
                         .ThrowOnFail();
            }

            try { await InitializeContainersAsync(dynamicWorldDependencies.SettingsContainer, ct); }
            catch (Exception) { return (null, false); }

            CursorSettings cursorSettings = (await assetsProvisioner.ProvideMainAssetAsync(dynamicSettings.CursorSettings, ct)).Value;
            ProvidedAsset<Texture2D> normalCursorAsset = await assetsProvisioner.ProvideMainAssetAsync(cursorSettings.NormalCursor, ct);
            ProvidedAsset<Texture2D> interactionCursorAsset = await assetsProvisioner.ProvideMainAssetAsync(cursorSettings.InteractionCursor, ct);

            var unityEventSystem = new UnityEventSystem(EventSystem.current.EnsureNotNull());
            var dclCursor = new DCLCursor(normalCursorAsset.Value, interactionCursorAsset.Value, cursorSettings.NormalCursorHotspot, cursorSettings.InteractionCursorHotspot);

            staticContainer.QualityContainer.AddDebugViews(debugBuilder);

            var realmSamplingData = new RealmSamplingData();

            ExposedGlobalDataContainer exposedGlobalDataContainer = staticContainer.ExposedGlobalDataContainer;

            PopupCloserView popupCloserView = Object.Instantiate((await assetsProvisioner.ProvideMainAssetAsync(dynamicSettings.PopupCloserView, CancellationToken.None)).Value.GetComponent<PopupCloserView>()).EnsureNotNull();
            MainUIView mainUIView = Object.Instantiate((await assetsProvisioner.ProvideMainAssetAsync(dynamicSettings.MainUIView, CancellationToken.None)).Value.GetComponent<MainUIView>()).EnsureNotNull();

            var coreMvcManager = new MVCManager(new WindowStackManager(), new CancellationTokenSource(), popupCloserView);

            var supportRequestService = new SupportRequestService(bootstrapContainer.WebBrowser);

            IMVCManager mvcManager = dynamicWorldParams.EnableAnalytics
                ? new MVCManagerAnalyticsDecorator(coreMvcManager, bootstrapContainer.Analytics.Controller, supportRequestService)
                : coreMvcManager;

            var loadingScreenTimeout = new LoadingScreenTimeout();
            ILoadingScreen loadingScreen = new LoadingScreen(mvcManager, loadingScreenTimeout);

            var nftInfoAPIClient = new OpenSeaAPIClient(staticContainer.WebRequestsContainer.WebRequestController, bootstrapContainer.DecentralandUrlsSource);
            var wearableCatalog = new WearableStorage();
            var trimmedWearableCatalog = new TrimmedWearableStorage();
            var trimmedEmoteCatalog = new TrimmedEmoteStorage();
            var characterPreviewFactory = new CharacterPreviewFactory(staticContainer.ComponentsContainer.ComponentPoolsRegistry, appArgs);
            IWebBrowser webBrowser = bootstrapContainer.WebBrowser;
            ISystemClipboard clipboard = new UnityClipboard();

            ChatSharedAreaEventBus chatSharedAreaEventBus = new ChatSharedAreaEventBus();

            GalleryEventBus galleryEventBus = new GalleryEventBus();

            static IMultiPool MultiPoolFactory() =>
                new DCLMultiPool();

            var memoryPool = new ArrayMemoryPool(ArrayPool<byte>.Shared!);

            var builderDTOsURL = URLDomain.FromString(bootstrapContainer.DecentralandUrlsSource.Url(DecentralandUrl.BuilderApiDtos));
            var builderContentURL = URLDomain.FromString(bootstrapContainer.DecentralandUrlsSource.Url(DecentralandUrl.BuilderApiContent));

            IEmoteStorage emotesCache = staticContainer.EmoteStorage;
            staticContainer.CacheCleaner.Register(trimmedEmoteCatalog);
            var equippedWearables = new EquippedWearables();
            var equippedEmotes = new EquippedEmotes();

            var selfEmotes = new List<URN>();
            ParseParamsForcedEmotes(bootstrapContainer.AppArgs, ref selfEmotes);
            ParseDebugForcedEmotes(bootstrapContainer.DebugSettings.EmotesToAddToUserProfile, ref selfEmotes);

            IProfileRepository profilesRepository = staticContainer.ProfilesContainer.Repository;
            IProfileCache profileCache = staticContainer.ProfilesContainer.Cache;

            var selfProfile = new SelfProfile(profilesRepository, identityCache, equippedWearables, wearableCatalog,
                emotesCache, equippedEmotes, selfEmotes, profileCache, globalWorld, playerEntity);

            IGiftingPersistence giftingPersistence = new PlayerPrefsGiftingPersistence();
            IPendingTransferService pendingTransferService = new PendingTransferService(giftingPersistence);
            IAvatarEquippedStatusProvider equippedStatusProvider = new AvatarEquippedStatusProvider(selfProfile);
            var communitiesDataProvider = new CommunitiesDataProvider(staticContainer.WebRequestsContainer.WebRequestController, bootstrapContainer.DecentralandUrlsSource, identityCache);
            var communityMembershipChecker = new CommunityMembershipCheckerAdapter(communitiesDataProvider);
            IWorldPermissionsService worldPermissionsService = new WorldPermissionsService(staticContainer.WebRequestsContainer.WebRequestController,
                bootstrapContainer.DecentralandUrlsSource,
                identityCache,
                communityMembershipChecker);
            IEmoteProvider emoteProvider = new ApplicationParamsEmoteProvider(appArgs,
                new EcsEmoteProvider(globalWorld, identityCache), builderDTOsURL.Value);

            var wearablesProvider = new ApplicationParametersWearablesProvider(appArgs,
                new ECSWearablesProvider(identityCache, globalWorld), builderDTOsURL.Value);

            //TODO should be unified with LaunchMode
            bool localSceneDevelopment = !string.IsNullOrEmpty(dynamicWorldParams.LocalSceneDevelopmentRealm);

            var teleportController = new TeleportController(staticContainer.SceneReadinessReportQueue);

            var realmContainer = RealmContainer.Create(
                staticContainer,
                identityCache,
                dynamicWorldParams.StaticLoadPositions,
                debugBuilder,
                loadingScreenTimeout,
                loadingScreen,
                localSceneDevelopment,
                bootstrapContainer.DecentralandUrlsSource,
                appArgs,
                teleportController,
                bootstrapContainer.Environment,
                worldPermissionsService);

            var terrainContainer = TerrainContainer.Create(staticContainer, realmContainer, dynamicWorldParams.EnableLandscape, localSceneDevelopment);

            SceneRoomLogMetaDataSource playSceneMetaDataSource = new SceneRoomMetaDataSource(staticContainer.RealmData, staticContainer.CharacterContainer.Transform, globalWorld, dynamicWorldParams.IsolateScenesCommunication, bootstrapContainer.DecentralandUrlsSource).WithLog();
            SceneRoomLogMetaDataSource localDevelopmentMetaDataSource = new LocalSceneDevelopmentSceneRoomMetaDataSource(staticContainer.WebRequestsContainer.WebRequestController).WithLog();

            var gateKeeperSceneRoomOptions = new GateKeeperSceneRoomOptions(staticContainer.LaunchMode,
                bootstrapContainer.DecentralandUrlsSource,
                playSceneMetaDataSource,
                localDevelopmentMetaDataSource,
                appArgs,
                staticContainer.RealmData);

            IGateKeeperSceneRoom gateKeeperSceneRoom = new GateKeeperSceneRoom(staticContainer.WebRequestsContainer.WebRequestController,
                    gateKeeperSceneRoomOptions).AsActivatable();

            var currentAdapterAddress = ICurrentAdapterAddress.NewDefault(staticContainer.RealmData);

            var archipelagoIslandRoom = IArchipelagoIslandRoom.NewDefault(
                identityCache,
                MultiPoolFactory(),
                new ArrayMemoryPool(),
                staticContainer.CharacterContainer.CharacterObject,
                currentAdapterAddress,
                staticContainer.WebRequestsContainer.WebRequestController,
                staticContainer.RealmData
            );

            var reloadSceneController = new ECSReloadScene(staticContainer.ScenesCache, globalWorld, playerEntity, localSceneDevelopment, staticContainer.CacheCleaner);

            var chatRoom = new ChatConnectiveRoom(staticContainer.WebRequestsContainer.WebRequestController, URLAddress.FromString(bootstrapContainer.DecentralandUrlsSource.Url(DecentralandUrl.ChatAdapter)));

            var voiceChatRoom = new VoiceChatActivatableConnectiveRoom();

            IRoomHub roomHub = new RoomHub(
                localSceneDevelopment ? IConnectiveRoom.Null.INSTANCE : archipelagoIslandRoom,
                gateKeeperSceneRoom,
                chatRoom,
                voiceChatRoom
            );

            var islandThroughputBunch = new ThroughputBufferBunch(new ThroughputBuffer(), new ThroughputBuffer());
            var sceneThroughputBunch = new ThroughputBufferBunch(new ThroughputBuffer(), new ThroughputBuffer());
            var chatThroughputBunch = new ThroughputBufferBunch(new ThroughputBuffer(), new ThroughputBuffer());

            var messagePipesHub = new MessagePipesHub(roomHub, MultiPoolFactory(), memoryPool, islandThroughputBunch, sceneThroughputBunch, chatThroughputBunch);

            var remoteMetadata = new DebounceRemoteMetadata(new RemoteMetadata(roomHub, staticContainer.RealmData, bootstrapContainer.DecentralandUrlsSource));

            var remoteAnnouncements = new RemoteAnnouncements(messagePipesHub);
            var remoteProfiles = new RemoteProfiles(profilesRepository, remoteMetadata);

            var roomsStatus = new RoomsStatus(
                roomHub,

                //override allowed only in Editor
                Application.isEditor
                    ? new LinkedBox<(bool use, LKConnectionQuality quality)>(
                        () => (bootstrapContainer.DebugSettings.OverrideConnectionQuality, bootstrapContainer.DebugSettings.ConnectionQuality)
                    )
                    : new Box<(bool use, LKConnectionQuality quality)>((false, LKConnectionQuality.QualityExcellent))
            );

            var entityParticipantTable = new EntityParticipantTable();
            staticContainer.EntityParticipantTableProxy.SetObject(entityParticipantTable);

            var queuePoolFullMovementMessage = new ObjectPool<SimplePriorityQueue<NetworkMovementMessage>>(
                () => new SimplePriorityQueue<NetworkMovementMessage>(),
                actionOnRelease: queue => queue.Clear()
            );

            var remoteEntities = new RemoteEntities(
                entityParticipantTable,
                staticContainer.ComponentsContainer.ComponentPoolsRegistry,
                queuePoolFullMovementMessage,
                staticContainer.EntityCollidersGlobalCache
            );

            var worldAccessGate = new PrivateWorldAccessHandler(worldPermissionsService, mvcManager, staticContainer.RealmData);
            var realmNavigatorContainer = RealmNavigationContainer.Create
                (staticContainer, bootstrapContainer, lodContainer, realmContainer, remoteEntities, remoteAnnouncements, remoteProfiles, globalWorld, roomHub, terrainContainer.Landscape, exposedGlobalDataContainer, loadingScreen, placesAPIService, worldAccessGate);

            IHealthCheck livekitHealthCheck = bootstrapContainer.DebugSettings.EnableEmulateNoLivekitConnection
                ? new IHealthCheck.AlwaysFails()
                : new StartLiveKitRooms(roomHub);

            livekitHealthCheck = dynamicWorldParams.EnableAnalytics
                ? livekitHealthCheck.WithFailAnalytics(bootstrapContainer.Analytics.Controller)
                : livekitHealthCheck;

            bool includeCameraReel = FeaturesRegistry.Instance.IsEnabled(FeatureId.CAMERA_REEL);
            bool includeFriends = FeaturesRegistry.Instance.IsEnabled(FeatureId.FRIENDS);
            bool includeMarketplaceCredits = FeaturesRegistry.Instance.IsEnabled(FeatureId.MARKETPLACE_CREDITS);
            bool includeBannedUsersFromScene = FeaturesRegistry.Instance.IsEnabled(FeatureId.BANNED_USERS_FROM_SCENE);

            CommunitiesFeatureAccess.Initialize(new CommunitiesFeatureAccess(identityCache, appArgs));
            bool includeCommunities = await CommunitiesFeatureAccess.Instance.IsUserAllowedToUseTheFeatureAsync(ct, ignoreAllowedList: true, cacheResult: false);

            var chatHistory = new ChatHistory();
            IEventBus emotesEventBus = new EventBus(true);

            var emoteWheelShortcutHandler = new EmoteWheelShortcutHandler(emotesEventBus);

            var moderationDataProvider = new ModerationDataProvider(staticContainer.WebRequestsContainer.WebRequestController, bootstrapContainer.DecentralandUrlsSource);
            var bannedNotificationHandler = new BannedNotificationHandler(
                staticContainer.WebRequestsContainer.WebRequestController,
                bootstrapContainer.DecentralandUrlsSource,
                bootstrapContainer.IdentityCache!,
                moderationDataProvider,
                mvcManager,
                bootstrapContainer.WebBrowser);

            var initializationFlowContainer = InitializationFlowContainer.Create(staticContainer,
                bootstrapContainer,
                realmContainer,
                realmNavigatorContainer,
                terrainContainer,
                loadingScreen,
                livekitHealthCheck,
                mvcManager,
                selfProfile,
                dynamicWorldParams,
                appArgs,
                backgroundMusic,
                roomHub,
                localSceneDevelopment,
                staticContainer.CharacterContainer,
                moderationDataProvider);

            IRealmNavigator realmNavigator = realmNavigatorContainer.RealmNavigator;
            HomePlaceEventBus homePlaceEventBus = new HomePlaceEventBus();
            ChatEventBus chatEventBus = new ChatEventBus();

            MapRendererContainer? mapRendererContainer =
                await MapRendererContainer
                   .CreateAsync(
                        dynamicWorldDependencies.SettingsContainer,
                        staticContainer,
                        bootstrapContainer.DecentralandUrlsSource,
                        assetsProvisioner,
                        placesAPIService,
                        eventsApiService,
                        mapPathEventBus,
                        staticContainer.MapPinsEventBus,
                        realmNavigator,
                        staticContainer.RealmData,
                        sharedNavmapCommandBus,
                        onlineUsersProvider,
                        identityCache,
                        homePlaceEventBus,
                        chatEventBus,
                        ct
                    );

            var worldInfoHub = new LocationBasedWorldInfoHub(
                new WorldInfoHub(staticContainer.SingletonSharedDependencies.SceneMapping),
                staticContainer.CharacterContainer.CharacterObject
            );

            dynamicWorldDependencies.WorldInfoTool.Initialize(worldInfoHub);

            var characterDataPropagationUtility = new CharacterDataPropagationUtility(staticContainer.ComponentsContainer.ComponentPoolsRegistry.AddComponentPool<SDKProfile>());

            var currentSceneInfo = new CurrentSceneInfo();

            var chatTeleporter = new ChatTeleporter(realmNavigator, new ChatEnvironmentValidator(bootstrapContainer.Environment), bootstrapContainer.DecentralandUrlsSource);

            var reloadSceneChatCommand = new ReloadSceneChatCommand(reloadSceneController, globalWorld, playerEntity, staticContainer.ScenesCache, teleportController, localSceneDevelopment);

            var chatMessageFactory = new ChatMessageFactory(profileCache, identityCache);

            // LEGACY HACK — do not add new consumers. Kept only for Settings group + ExplorePanelPlugin; pass `userBlockingCache` directly instead. See ObjectProxy<T>.
            var userBlockingCacheProxy = new ObjectProxy<IUserBlockingCache>();
            IFriendsEventBus friendsEventBus = new DefaultFriendsEventBus();
            IUserBlockingCache userBlockingCache = FeaturesRegistry.Instance.IsEnabled(FeatureId.FRIENDS_USER_BLOCKING)
                ? new UserBlockingCache(friendsEventBus)
                : new NullUserBlockingCache();
            userBlockingCacheProxy.SetObject(userBlockingCache);
            var currentChannelService = new CurrentChannelService();

            var chatCommands = new List<IChatCommand>
            {
                new GoToChatCommand(chatTeleporter, staticContainer.WebRequestsContainer.WebRequestController, bootstrapContainer.DecentralandUrlsSource),
                new GoToLocalChatCommand(chatTeleporter),
                new DebugPanelChatCommand(debugBuilder),
                new ShowEntityChatCommand(worldInfoHub),
                reloadSceneChatCommand,
                new LoadPortableExperienceChatCommand(staticContainer.PortableExperiencesController),
                new KillPortableExperienceChatCommand(staticContainer.PortableExperiencesController, staticContainer.SmartWearableCache),
                new VersionChatCommand(dclVersion),
                new SupportChatCommand(supportRequestService),
                new RoomsChatCommand(roomHub),
                new LogsChatCommand(),
                new SceneAdminsChatCommand(),
                new AppArgsCommand(appArgs),
                new LogMatrixChatCommand((RuntimeReportsHandlingSettings)bootstrapContainer.DiagnosticsContainer.Settings),
                new AnrSimulateChatCommand(),
#if UNITY_STANDALONE_WIN
                new AnrDumpChatCommand(),
#endif
            };

            chatCommands.Add(new HelpChatCommand(chatCommands, appArgs));


            IChatMessagesBus coreChatMessageBus = new MultiplayerChatMessagesBus(messagePipesHub, chatMessageFactory, userBlockingCache, bootstrapContainer.Environment, identityCache, roomHub)
                                                 .WithSelfResend(identityCache, chatMessageFactory)
                                                 .WithIgnoreSymbols()
                                                 .WithCommands(chatCommands, staticContainer.LoadingStatus)
                                                 .WithDebugPanel(debugBuilder);

            IChatMessagesBus chatMessagesBus = dynamicWorldParams.EnableAnalytics
                ? new ChatMessagesBusAnalyticsDecorator(coreChatMessageBus, bootstrapContainer.Analytics.Controller, profileCache, selfProfile)
                : coreChatMessageBus;

            IDonationsService donationsService;
            if (FeaturesRegistry.Instance.IsEnabled(FeatureId.DONATIONS))
            {
                IDonationsService coreDonationsService = new DonationsService(staticContainer.ScenesCache, staticContainer.EthereumApi,
                    staticContainer.WebRequestsContainer.WebRequestController, staticContainer.RealmData,
                    placesAPIService, bootstrapContainer.Environment,
                    bootstrapContainer.DecentralandUrlsSource, localSceneDevelopment);

                donationsService = dynamicWorldParams.EnableAnalytics ? new DonationsServiceAnalyticsDecorator(coreDonationsService, bootstrapContainer.Analytics.Controller) : coreDonationsService;
            }
            else
                donationsService = new DonationsServiceDisabled();

            var coreBackpackEventBus = new BackpackEventBus();

            ISocialServiceEventBus socialServiceEventBus = new SocialServiceEventBus();
            var socialServiceContainer = new SocialServicesContainer(bootstrapContainer.DecentralandUrlsSource, identityCache, socialServiceEventBus, appArgs);

            var voiceChatContainer = new VoiceChatContainer(
                socialServiceContainer.socialServicesRPC,
                socialServiceEventBus,
                roomHub,
                identityCache,
                staticContainer.WebRequestsContainer.WebRequestController,
                staticContainer.ScenesCache,
                realmNavigator,
                staticContainer.RealmData,
                bootstrapContainer.DecentralandUrlsSource,
                chatEventBus,
                currentChannelService
            );

            ChatOpener.Initialize(new ChatOpener(chatEventBus, mvcManager));

            IBackpackEventBus backpackEventBus = dynamicWorldParams.EnableAnalytics
                ? new BackpackEventBusAnalyticsDecorator(coreBackpackEventBus, bootstrapContainer.Analytics.Controller)
                : coreBackpackEventBus;

            var profileBroadcast = new DebounceProfileBroadcast(
                new ProfileBroadcast(messagePipesHub, selfProfile)
            );

            var multiplayerEmotesMessageBus = new MultiplayerEmotesMessageBus(messagePipesHub, dynamicSettings.MultiplayerDebugSettings, userBlockingCache);

            // Configure proxies for scene-side masked emote system
            staticContainer.EmotesMessageBusProxy.SetObject(multiplayerEmotesMessageBus);

            var characterPreviewEventBus = new CharacterPreviewEventBus();
            var upscaleController = new UpscalingController(mvcManager);

            AudioMixer generalAudioMixer = (await assetsProvisioner.ProvideMainAssetAsync(dynamicSettings.GeneralAudioMixer, ct)).Value;
            var audioMixerVolumesController = new AudioMixerVolumesController(generalAudioMixer);

            var multiplayerMovementMessageBus = new MultiplayerMovementMessageBus(messagePipesHub, entityParticipantTable, globalWorld);

            var badgesAPIClient = new BadgesAPIClient(staticContainer.WebRequestsContainer.WebRequestController, bootstrapContainer.DecentralandUrlsSource);

            ICameraReelImagesMetadataDatabase cameraReelImagesMetadataDatabase = new CameraReelImagesMetadataRemoteDatabase(staticContainer.WebRequestsContainer.WebRequestController, bootstrapContainer.DecentralandUrlsSource);
            ICameraReelScreenshotsStorage cameraReelScreenshotsStorage = new CameraReelS3BucketScreenshotsStorage(staticContainer.WebRequestsContainer.WebRequestController);

            var cameraReelStorageService = new CameraReelRemoteStorageService(cameraReelImagesMetadataDatabase, cameraReelScreenshotsStorage, identityCache.Identity?.Address);

            GoogleUserCalendar userCalendar = new GoogleUserCalendar(webBrowser);
            var clipboardManager = new ClipboardManager(clipboard);
            ITextFormatter hyperlinkTextFormatter = new HyperlinkTextFormatter(profileCache, selfProfile);

            NotificationsRequestController notificationsRequestController = new (staticContainer.WebRequestsContainer.WebRequestController, bootstrapContainer.DecentralandUrlsSource, identityCache);

            var friendServiceProxy = new ObjectProxy<IFriendsService>();
            var friendOnlineStatusCacheProxy = new ObjectProxy<FriendsConnectivityStatusTracker>();
            var friendsCacheProxy = new ObjectProxy<FriendsCache>();

            ISpriteCache thumbnailCache = new SpriteCache(staticContainer.WebRequestsContainer.WebRequestController);
            var profileRepositoryWrapper = new ProfileRepositoryWrapper(profilesRepository, profileCache, thumbnailCache, identityCache);
            GetProfileThumbnailCommand.Initialize(new GetProfileThumbnailCommand(profileRepositoryWrapper));

            var communitiesEventBus = new CommunitiesEventBus();

            var profileChangesBus = new ProfileChangesBus();

            var translationSettings = new PlayerPrefsTranslationSettings();

            GenericUserProfileContextMenuSettings genericUserProfileContextMenuSettingsSo = (await assetsProvisioner.ProvideMainAssetAsync(dynamicSettings.GenericUserProfileContextMenuSettings, ct)).Value;
            CommunityVoiceChatContextMenuConfiguration communityVoiceChatContextMenuSettingsSo = (await assetsProvisioner.ProvideMainAssetAsync(dynamicSettings.CommunityVoiceChatContextMenuSettings, ct)).Value;

            var communitiesDataService = new CommunityDataService(chatHistory,
                mvcManager,
                communitiesEventBus,
                communitiesDataProvider,
                identityCache);

            var joinedCommunitiesVoiceLiveTracker = new JoinedCommunitiesVoiceLiveTracker(
                voiceChatContainer.VoiceChatOrchestrator,
                communitiesDataService);

            // Local scene development scenes are excluded from deeplink runtime handling logic
            if (appArgs.HasFlag(AppArgsFlags.LOCAL_SCENE) == false)
            {
                DeepLinkHandle deepLinkHandleImplementation = new DeepLinkHandle(dynamicWorldParams.StartParcel, chatTeleporter, ct, communitiesDataService);
                deepLinkHandleImplementation.StartListenForDeepLinksAsync(ct).Forget();
            }

            var passportBridge = new MVCPassportBridge(mvcManager);

            NearbyMuteService? nearbyMuteService = FeaturesRegistry.Instance.IsEnabled(FeatureId.NEARBY_VOICE_CHAT)
                ? new NearbyMuteService(
                    new NearbyMuteCache(),
                    new RestNearbyMuteRepository(
                        staticContainer.WebRequestsContainer.WebRequestController,
                        bootstrapContainer.DecentralandUrlsSource))
                : null;

            NearbyVoiceChatStateModel? nearbyStateModel = FeaturesRegistry.Instance.IsEnabled(FeatureId.NEARBY_VOICE_CHAT)
                ? new NearbyVoiceChatStateModel(
                    DCLPlayerPrefs.GetBool(DCLPrefKeys.NEARBY_VOICE_CHAT_DISABLED)
                        ? NearbyVoiceChatState.DISABLED
                        : NearbyVoiceChatState.IDLE)
                : null;

            IMVCManagerMenusAccessFacade menusAccessFacade = new MVCManagerMenusAccessFacade(
                mvcManager,
                profileCache,
                friendServiceProxy,
                chatEventBus,
                genericUserProfileContextMenuSettingsSo,
                bootstrapContainer.Analytics.Controller,
                onlineUsersProvider,
                realmNavigator,
                friendOnlineStatusCacheProxy,
                profilesRepository,
                communityVoiceChatContextMenuSettingsSo,
                voiceChatContainer.VoiceChatOrchestrator,
                includeCommunities,
                communitiesDataProvider,
                bootstrapContainer.WebBrowser,
                bootstrapContainer.DecentralandUrlsSource,
                selfProfile,
                nearbyMuteService);

            ViewDependencies.Initialize(new ViewDependencies(
                unityEventSystem,
                menusAccessFacade,
                clipboardManager,
                dclCursor,
                new ContextMenuOpener(mvcManager),
                identityCache,
                new ConfirmationDialogOpener(mvcManager)));

            var realmNftNamesProvider = new RealmNftNamesProvider(staticContainer.WebRequestsContainer.WebRequestController,
                bootstrapContainer.DecentralandUrlsSource);

            var thumbnailProvider = new ECSThumbnailProvider(bootstrapContainer.DecentralandUrlsSource, globalWorld);

            var bannedSceneController = new ECSBannedScene(staticContainer.ScenesCache, globalWorld, playerEntity);

            var springBoneSimulationSettings = new SpringBoneSimulationSettings();

            var globalPlugins = new List<IDCLGlobalPlugin>
            {
                new ResourceUnloadingPlugin(staticContainer.SingletonSharedDependencies.MemoryBudget, staticContainer.CacheCleaner, staticContainer.SceneLoadingLimit),
                new AdaptivePerformancePlugin(staticContainer.Profiler, staticContainer.LoadingStatus),
                new LightSourceDebugPlugin(staticContainer.DebugContainerBuilder, globalWorld),
                new MultiplayerPlugin(
                    assetsProvisioner,
                    archipelagoIslandRoom,
                    gateKeeperSceneRoom,
                    chatRoom,
                    roomHub,
                    roomsStatus,
                    profilesRepository,
                    profileBroadcast,
                    debugBuilder,
                    staticContainer.LoadingStatus,
                    entityParticipantTable,
                    messagePipesHub,
                    remoteMetadata,
                    remoteAnnouncements,
                    remoteProfiles,
                    staticContainer.CharacterContainer.CharacterObject,
                    staticContainer.RealmData,
                    remoteEntities,
                    staticContainer.ScenesCache,
                    emotesCache,
                    characterDataPropagationUtility,
                    staticContainer.ComponentsContainer.ComponentPoolsRegistry,
                    islandThroughputBunch,
                    sceneThroughputBunch,
                    voiceChatRoom),
                staticContainer.ProfilesContainer.CreatePlugin(),
                new WorldInfoPlugin(worldInfoHub, debugBuilder, chatHistory),
                new CharacterMotionPlugin(staticContainer.CharacterContainer.CharacterObject, debugBuilder, staticContainer.ComponentsContainer.ComponentPoolsRegistry,
                    staticContainer.SceneReadinessReportQueue, terrainContainer.Landscape, staticContainer.ScenesCache, assetsProvisioner, identityCache, friendsCacheProxy),
                new InputPlugin(dclCursor, unityEventSystem, assetsProvisioner, multiplayerEmotesMessageBus, emoteWheelShortcutHandler, mvcManager),
                new GlobalInteractionPlugin(assetsProvisioner, staticContainer.EntityCollidersGlobalCache, exposedGlobalDataContainer.GlobalInputEvents, unityEventSystem, staticContainer.ScenesCache, mvcManager, menusAccessFacade, exposedGlobalDataContainer.ExposedCameraData.CameraEntityProxy),
                new CharacterCameraPlugin(assetsProvisioner, realmSamplingData, exposedGlobalDataContainer.ExposedCameraData, debugBuilder, dynamicWorldDependencies.CommandLineArgs),
                new WearablePlugin(
                    staticContainer.WebRequestsContainer.WebRequestController,
                    staticContainer.RealmData,
                    bootstrapContainer.DecentralandUrlsSource,
                    staticContainer.CacheCleaner,
                    wearableCatalog,
                    trimmedWearableCatalog,
                    bootstrapContainer.Analytics.EntitiesAnalytics,
                    builderContentURL.Value),
                new EmotePlugin(
                    staticContainer.WebRequestsContainer.WebRequestController,
                    emotesCache,
                    staticContainer.RealmData,
                    multiplayerEmotesMessageBus,
                    debugBuilder,
                    assetsProvisioner,
                    selfProfile,
                    mvcManager,
                    staticContainer.CacheCleaner,
                    entityParticipantTable,
                    dclCursor,
                    staticContainer.InputBlock,
                    globalWorld,
                    playerEntity,
                    builderContentURL.Value,
                    thumbnailProvider,
                    staticContainer.ScenesCache,
                    bootstrapContainer.DecentralandUrlsSource,
                    bootstrapContainer.Analytics.EntitiesAnalytics,
                    emotesEventBus,
                    trimmedEmoteCatalog,
                staticContainer.EmotesContainer.EmotePlayer),
                new ProfilingPlugin(staticContainer.Profiler, staticContainer.RealmData,
                    staticContainer.SingletonSharedDependencies.MemoryBudget, debugBuilder,
                    staticContainer.ScenesCache, dclVersion, dynamicSettings.AdaptivePhysicsSettings,
                    staticContainer.SceneLoadingLimit, appArgs, staticContainer.LoadingStatus),
                #if UNITY_EDITOR
                    new RenderingSystemPlugin(debugBuilder),
                #endif
                new AvatarPlugin(
                    staticContainer.ComponentsContainer.ComponentPoolsRegistry,
                    assetsProvisioner,
                    staticContainer.SingletonSharedDependencies.FrameTimeBudget,
                    staticContainer.SingletonSharedDependencies.MemoryBudget,
                    staticContainer.QualityContainer.RendererFeaturesCache,
                    staticContainer.RealmData,
                    staticContainer.MainPlayerAvatarBaseProxy,
                    debugBuilder,
                    staticContainer.CacheCleaner,
                    dynamicSettings.NametagsData,
                    defaultTexturesContainer.TextureArrayContainerFactory,
                    wearableCatalog,
                    userBlockingCache,
                    includeBannedUsersFromScene),
                new MainUIPlugin(mvcManager, mainUIView, includeFriends),
                new ProfilePlugin(profilesRepository, profileCache, staticContainer.CacheCleaner),
                new MapRendererPlugin(mapRendererContainer.MapRenderer),
                new SidebarPlugin(
                    assetsProvisioner,
                    mvcManager,
                    mainUIView,
                    notificationsRequestController,
                    identityCache,
                    profilesRepository,
                    staticContainer.WebRequestsContainer.WebRequestController,
                    webBrowser,
                    dynamicWorldDependencies.CompositeWeb3Provider,
                    initializationFlowContainer.InitializationFlow,
                    profileCache,
                    globalWorld,
                    playerEntity,
                    chatHistory,
                    profileRepositoryWrapper,
                    profileChangesBus,
                    selfProfile,
                    staticContainer.RealmData,
                    staticContainer.SceneRestrictionBusController,
                    bootstrapContainer.DecentralandUrlsSource,
                    passportBridge,
                    chatEventBus,
                    eventsApiService,
                    staticContainer.SmartWearableCache,
                    supportRequestService,
                    joinedCommunitiesVoiceLiveTracker),
                new ErrorPopupPlugin(mvcManager, assetsProvisioner),
                new PrivateWorldsPlugin(
                    mvcManager,
                    assetsProvisioner,
                    roomHub,
                    worldPermissionsService,
                    worldAccessGate,
                    staticContainer.InputBlock,
                    staticContainer.RealmData,
                    realmNavigator,
                    chatHistory),
                new MinimapPlugin(
                    mainUIView.MinimapView.EnsureNotNull(),
                    mapRendererContainer.MapRenderer,
                    mvcManager,
                    placesAPIService,
                    staticContainer.RealmData,
                    realmNavigator,
                    staticContainer.ScenesCache,
                    mapPathEventBus,
                    staticContainer.SceneRestrictionBusController,
                    dynamicWorldParams.StartParcel.Peek(),
                    clipboard,
                    bootstrapContainer.DecentralandUrlsSource,
                    chatMessagesBus,
                    reloadSceneChatCommand,
                    roomHub,
                    staticContainer.LoadingStatus,
                    includeBannedUsersFromScene,
                    homePlaceEventBus,
                    donationsService),
                new ChatPlugin(
                    mvcManager,
                    menusAccessFacade,
                    chatMessagesBus,
                    chatEventBus,
                    chatHistory,
                    entityParticipantTable,
                    dynamicSettings.NametagsData,
                    mainUIView,
                    staticContainer.InputBlock,
                    globalWorld,
                    playerEntity,
                    roomHub,
                    assetsProvisioner,
                    hyperlinkTextFormatter,
                    profileCache,
                    chatEventBus,
                    identityCache,
                    staticContainer.LoadingStatus,
                    userBlockingCache,
                    socialServiceContainer.socialServicesRPC,
                    friendsEventBus,
                    chatMessageFactory,
                    profileRepositoryWrapper,
                    friendServiceProxy,
                    communitiesDataProvider,
                    communitiesDataService,
                    thumbnailCache,
                    communitiesEventBus,
                    voiceChatContainer.VoiceChatOrchestrator,
                    mainUIView.SidebarView.unreadMessagesButton.transform,
                    translationSettings,
                    staticContainer.WebRequestsContainer.WebRequestController,
                    bootstrapContainer.DecentralandUrlsSource,
                    chatSharedAreaEventBus,
                    messagePipesHub,
                    bootstrapContainer.Environment,
                    bootstrapContainer.Analytics.Controller,
                    currentChannelService),
                new ExplorePanelPlugin(
                    chatEventBus,
                    assetsProvisioner,
                    mvcManager,
                    mapRendererContainer,
                    placesAPIService,
                    staticContainer.WebRequestsContainer.WebRequestController,
                    identityCache,
                    cameraReelStorageService,
                    cameraReelStorageService,
                    clipboard,
                    bootstrapContainer.DecentralandUrlsSource,
                    wearableCatalog,
                    characterPreviewFactory,
                    profilesRepository,
                    dynamicWorldDependencies.CompositeWeb3Provider,
                    initializationFlowContainer.InitializationFlow,
                    selfProfile,
                    equippedWearables,
                    equippedEmotes,
                    webBrowser,
                    emotesCache,
                    staticContainer.RealmData,
                    profileCache,
                    characterPreviewEventBus,
                    mapPathEventBus,
                    backpackEventBus,
                    thirdPartyNftProviderSource,
                    wearablesProvider,
                    dclCursor,
                    staticContainer.InputBlock,
                    emoteProvider,
                    globalWorld,
                    playerEntity,
                    chatMessagesBus,
                    staticContainer.MemoryCap,
                    bootstrapContainer.VolumeBus,
                    eventsApiService,
                    userCalendar,
                    clipboard,
                    explorePanelNavmapBus,
                    appArgs,
                    userBlockingCacheProxy,
                    profileChangesBus,
                    staticContainer.SceneLoadingLimit,
                    mainUIView.WarningNotification,
                    profileRepositoryWrapper,
                    upscaleController,
                    communitiesDataProvider,
                    realmNftNamesProvider,
                    voiceChatContainer.VoiceChatOrchestrator,
                    galleryEventBus,
                    thumbnailProvider,
                    passportBridge,
                    homePlaceEventBus,
                    staticContainer.SmartWearableCache,
                    staticContainer.ImageControllerProvider,
                    bootstrapContainer.Analytics.Controller,
                    communitiesDataService,
                    staticContainer.LoadingStatus,
                    donationsService,
                    realmNavigator,
                    friendServiceProxy,
                    staticContainer.PublishIpfsEntityCommand,
                    worldPermissionsService,
                    staticContainer.QualityContainer.RendererFeaturesCache,
                    springBoneSimulationSettings,
                    joinedCommunitiesVoiceLiveTracker
                ),
                new GiftingPlugin(assetsProvisioner,
                    mvcManager,
                    pendingTransferService,
                    staticContainer.WebRequestsContainer.WebRequestController,
                    equippedStatusProvider,
                    profilesRepository,
                    staticContainer.InputBlock,
                    wearablesProvider,
                    wearableCatalog,
                    emotesCache,
                    emoteProvider,
                    identityCache,
                    thumbnailProvider,
                    chatEventBus,
                    webBrowser,
                    bootstrapContainer.CompositeWeb3Provider,
                    bootstrapContainer.DecentralandUrlsSource,
                    staticContainer.ImageControllerProvider),
                new CharacterPreviewPlugin(staticContainer.ComponentsContainer.ComponentPoolsRegistry, assetsProvisioner, staticContainer.CacheCleaner),
                staticContainer.WebRequestsContainer.CreatePlugin(localSceneDevelopment),
                new Web3AuthenticationPlugin(assetsProvisioner, dynamicWorldDependencies.CompositeWeb3Provider, debugBuilder, mvcManager, selfProfile, webBrowser, staticContainer.RealmData, identityCache, characterPreviewFactory, dynamicWorldDependencies.SplashScreen, audioMixerVolumesController, staticContainer.InputBlock, characterPreviewEventBus, backgroundMusic, globalWorld, bootstrapContainer.AppArgs, wearablesProvider, staticContainer.WebRequestsContainer.WebRequestController, bootstrapContainer.DecentralandUrlsSource, profileChangesBus),
                new SkyboxPlugin(assetsProvisioner, dynamicSettings.DirectionalLight, staticContainer.ScenesCache, staticContainer.SceneRestrictionBusController, staticContainer.RealmData, !appArgs.HasFlagWithValueFalse(AppArgsFlags.SKYBOX_TIME_ENABLED)),
                new LoadingScreenPlugin(assetsProvisioner, mvcManager, audioMixerVolumesController,
                    staticContainer.InputBlock, debugBuilder, staticContainer.LoadingStatus),
                new ExternalUrlPromptPlugin(assetsProvisioner, webBrowser, mvcManager, dclCursor),
                new TeleportPromptPlugin(
                    assetsProvisioner,
                    mvcManager,
                    staticContainer.ImageControllerProvider,
                    placesAPIService,
                    dclCursor,
                    chatMessagesBus
                ),
                new ChangeRealmPromptPlugin(
                    assetsProvisioner,
                    mvcManager,
                    dclCursor,
                    realmUrl => chatMessagesBus.SendWithUtcNowTimestamp(ChatChannel.NEARBY_CHANNEL, $"/{ChatCommandsUtils.COMMAND_GOTO} {realmUrl}", ChatMessageOrigin.RESTRICTED_ACTION_API)),
                new NftPromptPlugin(assetsProvisioner, webBrowser, mvcManager, nftInfoAPIClient, staticContainer.ImageControllerProvider, dclCursor),
                staticContainer.CharacterContainer.CreateGlobalPlugin(),
                staticContainer.QualityContainer.CreatePlugin(),
                new MultiplayerMovementPlugin(
                    assetsProvisioner,
                    multiplayerMovementMessageBus,
                    debugBuilder,
                    remoteEntities,
                    staticContainer.CharacterContainer.Transform,
                    dynamicSettings.MultiplayerDebugSettings,
                    appArgs,
                    entityParticipantTable,
                    staticContainer.RealmData,
                    remoteMetadata),
                new AudioPlaybackPlugin(terrainContainer.GenesisTerrain, terrainContainer.WorldsTerrain, assetsProvisioner, dynamicWorldParams.EnableLandscape, audioMixerVolumesController, staticContainer.RealmData),
                new RealmDataDirtyFlagPlugin(staticContainer.RealmData),
                new NotificationPlugin(
                    assetsProvisioner,
                    mvcManager,
                    staticContainer.ImageControllerProvider,
                    notificationsRequestController,
                    identityCache,
                    profilesRepository),
                new RewardPanelPlugin(mvcManager, assetsProvisioner, staticContainer.ImageControllerProvider),
                new PassportPlugin(
                    assetsProvisioner,
                    mvcManager,
                    dclCursor,
                    profilesRepository,
                    characterPreviewFactory,
                    characterPreviewEventBus,
                    selfProfile,
                    webBrowser,
                    bootstrapContainer.DecentralandUrlsSource,
                    badgesAPIClient,
                    staticContainer.InputBlock,
                    remoteMetadata,
                    cameraReelStorageService,
                    cameraReelStorageService,
                    globalWorld,
                    playerEntity,
                    friendServiceProxy,
                    friendOnlineStatusCacheProxy,
                    onlineUsersProvider,
                    realmNavigator,
                    identityCache,
                    realmNftNamesProvider,
                    profileChangesBus,
                    includeCommunities,
                    profileRepositoryWrapper,
                    voiceChatContainer.VoiceChatOrchestrator,
                    galleryEventBus,
                    clipboard,
                    communitiesDataProvider,
                    thumbnailProvider,
                    staticContainer.ImageControllerProvider
                ),
                new GenericPopupsPlugin(assetsProvisioner, mvcManager, clipboardManager),
                new ColorPickerPlugin(assetsProvisioner, mvcManager),
                new GenericContextMenuPlugin(assetsProvisioner, mvcManager, profileRepositoryWrapper),
                realmNavigatorContainer.CreatePlugin(),
                new GPUInstancingPlugin(staticContainer.GPUInstancingService, assetsProvisioner, staticContainer.RealmData, staticContainer.LoadingStatus, exposedGlobalDataContainer.ExposedCameraData),
                new ConfirmationDialogPlugin(assetsProvisioner, mvcManager, profileRepositoryWrapper),
                new BannedUsersPlugin(roomHub, staticContainer.RealmData, bannedSceneController, staticContainer.LoadingStatus, includeBannedUsersFromScene),
                new SmartWearablesGlobalPlugin(wearableCatalog,
                    backpackEventBus,
                    staticContainer.PortableExperiencesController,
                    staticContainer.ScenesCache,
                    staticContainer.SmartWearableCache,
                    assetsProvisioner,
                    staticContainer.LoadingStatus,
                    mvcManager,
                    thumbnailProvider,
                    identityCache),
                new AvatarLocomotionOverridesGlobalPlugin(),
                new JumpIndicatorPlugin(assetsProvisioner),
                new SpringBonesPlugin(springBoneSimulationSettings),
                new EnsureClockSyncPlugin(realmNavigator, mvcManager, bootstrapContainer.RealmClock, staticContainer.WebRequestsContainer.WebRequestController, bootstrapContainer.DecentralandUrlsSource),
            };

            if (donationsService.DonationFeatureEnabled)
                globalPlugins.Add(new DonationsPlugin(
                    mvcManager,
                    assetsProvisioner,
                    donationsService,
                    staticContainer.ProfilesContainer.Repository,
                    playerEntity,
                    globalWorld,
                    webBrowser,
                    bootstrapContainer.DecentralandUrlsSource,
                    staticContainer.InputBlock,
                    dynamicWorldDependencies.CompositeWeb3Provider));

            // ReSharper disable once MethodHasAsyncOverloadWithCancellation
            if (FeaturesRegistry.Instance.IsEnabled(FeatureId.STOP_ON_DUPLICATE_IDENTITY))
                globalPlugins.Add(new DuplicateIdentityPlugin(roomHub, mvcManager, assetsProvisioner));

            // ReSharper disable once MethodHasAsyncOverloadWithCancellation
            if (FeaturesRegistry.Instance.IsEnabled(FeatureId.VOICE_CHAT))
                globalPlugins.Add(
                    new VoiceChatPlugin(
                        roomHub,
                        mainUIView.ChatMainView.VoiceChatPanelView,
                        voiceChatContainer,
                        profileRepositoryWrapper,
                        entityParticipantTable,
                        globalWorld,
                        playerEntity,
                        communitiesDataProvider,
                        staticContainer.ImageControllerProvider,
                        assetsProvisioner,
                        chatSharedAreaEventBus,
                        debugBuilder,
                        staticContainer.LoadingStatus,
                        staticContainer.ScenesCache,
                        staticContainer.SceneRestrictionBusController,
                        mainUIView.SidebarView.NearbyVoiceChatButton,
                        mainUIView.SidebarView.NearbyVoiceWidget,
                        mainUIView.SidebarView.NearbyVoiceTip,
                        bootstrapContainer.VolumeBus,
                        userBlockingCache,
                        nearbyMuteService,
                        nearbyStateModel)
                );

            if (!appArgs.HasFlagWithValueFalse(AppArgsFlags.LANDSCAPE_TERRAIN_ENABLED))
                globalPlugins.Add(terrainContainer.CreatePlugin(staticContainer, bootstrapContainer, mapRendererContainer, debugBuilder));

            if (localSceneDevelopment)
                globalPlugins.Add(new LocalSceneDevelopmentPlugin(reloadSceneController, realmUrls));
            else
            {
                globalPlugins.Add(lodContainer.LODPlugin);
                globalPlugins.Add(lodContainer.RoadPlugin);
            }


            if (FeaturesRegistry.Instance.IsEnabled(FeatureId.LOCAL_SCENE_DEVELOPMENT) || FeaturesRegistry.Instance.IsEnabled(FeatureId.SELF_PREVIEW_BUILDER_COLLECTIONS))
                globalPlugins.Add(new GlobalGLTFLoadingPlugin(staticContainer.WebRequestsContainer.WebRequestController, staticContainer.RealmData, builderContentURL.Value, localSceneDevelopment, staticContainer.ComponentsContainer.ComponentPoolsRegistry.RootContainerTransform()));

            globalPlugins.AddRange(staticContainer.SharedPlugins);

            if (includeFriends)
            {
                // TODO many circular dependencies - adjust the flow and get rid of ObjectProxy
                var friendsContainer = new FriendsContainer(
                    mainUIView,
                    mvcManager,
                    assetsProvisioner,
                    identityCache,
                    profilesRepository,
                    staticContainer.LoadingStatus,
                    staticContainer.InputBlock,
                    selfProfile,
                    passportBridge,
                    onlineUsersProvider,
                    realmNavigator,
                    dynamicWorldParams.EnableAnalytics,
                    bootstrapContainer.Analytics.Controller,
                    socialServiceEventBus,
                    socialServiceContainer.socialServicesRPC,
                    friendsEventBus,
                    friendServiceProxy,
                    friendOnlineStatusCacheProxy,
                    friendsCacheProxy,
                    userBlockingCache,
                    profileRepositoryWrapper,
                    voiceChatContainer.VoiceChatOrchestrator,
                    bootstrapContainer.WebBrowser,
                    bootstrapContainer.DecentralandUrlsSource
                );

                globalPlugins.Add(friendsContainer);
            }

            if (includeCameraReel)
                globalPlugins.Add(new InWorldCameraPlugin(
                    selfProfile,
                    staticContainer.RealmData,
                    playerEntity,
                    placesAPIService,
                    staticContainer.CharacterContainer.CharacterObject,
                    coroutineRunner,
                    cameraReelStorageService,
                    cameraReelStorageService,
                    mvcManager,
                    clipboard,
                    bootstrapContainer.DecentralandUrlsSource,
                    webBrowser,
                    profilesRepository,
                    realmNavigator,
                    assetsProvisioner,
                    wearableCatalog,
                    wearablesProvider,
                    dclCursor,
                    globalWorld,
                    debugBuilder,
                    dynamicSettings.NametagsData,
                    profileRepositoryWrapper,
                    identityCache,
                    thumbnailProvider,
                    galleryEventBus
                    ));

            if (includeMarketplaceCredits)
            {
                globalPlugins.Add(new MarketplaceCreditsPlugin(
                    mainUIView,
                    assetsProvisioner,
                    webBrowser,
                    staticContainer.InputBlock,
                    selfProfile,
                    staticContainer.WebRequestsContainer.WebRequestController,
                    bootstrapContainer.DecentralandUrlsSource,
                    mvcManager,
                    staticContainer.RealmData,
                    identityCache,
                    staticContainer.LoadingStatus,
                    hyperlinkTextFormatter,
                    staticContainer.ImageControllerProvider));
            }

            if (includeCommunities)
                globalPlugins.Add(new CommunitiesPlugin(
                    mvcManager,
                    assetsProvisioner,
                    staticContainer.InputBlock,
                    cameraReelStorageService,
                    cameraReelScreenshotsStorage,
                    profileRepositoryWrapper,
                    friendServiceProxy,
                    communitiesDataProvider,
                    staticContainer.WebRequestsContainer.WebRequestController,
                    placesAPIService,
                    selfProfile,
                    realmNavigator,
                    clipboard,
                    webBrowser,
                    eventsApiService,
                    chatEventBus,
                    galleryEventBus,
                    communitiesEventBus,
                    socialServiceContainer.socialServicesRPC,
                    profilesRepository,
                    bootstrapContainer.DecentralandUrlsSource,
                    identityCache,
                    voiceChatContainer.VoiceChatOrchestrator,
                    bootstrapContainer.Analytics.Controller,
                    homePlaceEventBus,
                    socialServiceEventBus,
                    worldPermissionsService));

            if (dynamicWorldParams.EnableAnalytics)
                globalPlugins.Add(new AnalyticsPlugin(
                        bootstrapContainer.Analytics.Controller,
                        staticContainer.Profiler,
                        staticContainer.LoadingStatus,
                        staticContainer.RealmData,
                        staticContainer.MainPlayerAvatarBaseProxy,
                        identityCache,
                        debugBuilder,
                        cameraReelStorageService,
                        entityParticipantTable,
                        staticContainer.ScenesCache,
                        chatEventBus,
                        translationSettings,
                        nearbyStateModel,
                        nearbyMuteService
                    )
                );

            if (localSceneDevelopment || appArgs.HasFlag(AppArgsFlags.SCENE_CONSOLE))
                globalPlugins.Add(new DebugMenuPlugin(
                    bootstrapContainer.DiagnosticsContainer,
                    staticContainer.InputBlock,
                    assetsProvisioner,
                    debugBuilder
                    ));

            if (!localSceneDevelopment)
                globalPlugins.Add(new ConnectionStatusPanelPlugin(roomsStatus, currentSceneInfo, assetsProvisioner, appArgs));

            var globalWorldFactory = new GlobalWorldFactory(
                in staticContainer,
                exposedGlobalDataContainer.CameraSamplingData,
                realmSamplingData,
                bootstrapContainer.DecentralandUrlsSource,
                staticContainer.RealmData,
                globalPlugins,
                debugBuilder,
                staticContainer.ScenesCache,
                dynamicWorldParams.HybridSceneParams,
                currentSceneInfo,
                lodContainer.LodCache,
                lodContainer.RoadCoordinates,
                lodContainer.LODSettings,
                multiplayerEmotesMessageBus,
                globalWorld,
                staticContainer.SceneReadinessReportQueue,
                profilesRepository,
                bootstrapContainer.UseRemoteAssetBundles,
                lodContainer.RoadAssetsPool,
                staticContainer.SceneLoadingLimit,
                dynamicWorldParams.StartParcel,
                bootstrapContainer.Analytics.EntitiesAnalytics
            );

            staticContainer.RoomHubProxy.SetObject(roomHub);

            var container = new DynamicWorldContainer(
                mvcManager,
                realmContainer.RealmController,
                realmNavigator,
                globalWorldFactory,
                globalPlugins,
                profilesRepository,
                initializationFlowContainer.InitializationFlow,
                chatMessagesBus,
                chatHistory,
                messagePipesHub,
                remoteMetadata,
                profileBroadcast,
                roomHub,
                socialServiceContainer,
                selfProfile,
                clipboard,
                bannedNotificationHandler,
                profileRepositoryWrapper,
                joinedCommunitiesVoiceLiveTracker
            );

            // Init itself
            await dynamicWorldDependencies.SettingsContainer.InitializePluginAsync(container, ct)!.ThrowOnFail();

            return (container, true);
        }

        private static void ParseDebugForcedEmotes(IReadOnlyCollection<string>? debugEmotes, ref List<URN> parsedEmotes)
        {
            if (debugEmotes?.Count > 0)
                parsedEmotes.AddRange(debugEmotes.Select(emote => new URN(emote)));
        }

        private static void ParseParamsForcedEmotes(IAppArgs appParams, ref List<URN> parsedEmotes)
        {
            if (appParams.TryGetValue(AppArgsFlags.FORCED_EMOTES, out string? csv) && !string.IsNullOrEmpty(csv!))
                parsedEmotes.AddRange(csv.Split(',', StringSplitOptions.RemoveEmptyEntries)?.Select(emote => new URN(emote)) ?? ArraySegment<URN>.Empty);
        }
    }
}