Infratest/Assets/Code/Infrastructure/App/PapaInstaller.cs

using Code.Infrastructure.Camera;
using Code.Infrastructure.Configs;
using Code.Infrastructure.Input;
using Code.Infrastructure.Loadings;
using Code.Infrastructure.SceneLoader;
using Code.Infrastructure.UI;
using Reflex.Core;
using Reflex.Enums;
using UnityEngine;
using Resolution = Reflex.Enums.Resolution;

namespace Code.Infrastructure.App
{
    public class PapaInstaller : MonoBehaviour, IInstaller, 
        ISceneConfigsLoadedHandle,
        IInputServiceInitializedHandle,
        ICameraInitializedHandle,
        IUIInitializedHandle,
        IUIPanelLoaded
    {
        public void InstallBindings(ContainerBuilder containerBuilder)
        {
            containerBuilder.RegisterType(typeof(EventBus.EventBus), Lifetime.Singleton, Resolution.Eager);
            containerBuilder.RegisterType(typeof(ConfigLocator), new[] { typeof(IConfigLocator) }, Lifetime.Singleton, Resolution.Eager);
            containerBuilder.RegisterType(typeof(SceneLoader.SceneLoader), Lifetime.Singleton, Resolution.Eager);
            containerBuilder.RegisterType(typeof(InputService),new[] { typeof(IInputService) }, Lifetime.Singleton, Resolution.Eager);
            
            containerBuilder.OnContainerBuilt += Bootstrap;
            
            containerBuilder.RegisterType(typeof(AppStateMachine), Lifetime.Singleton, Resolution.Lazy); 
            containerBuilder.RegisterType(typeof(AppStateMachineContext), Lifetime.Singleton, Resolution.Lazy); 
            
            containerBuilder.RegisterType(typeof(CameraFactory), Lifetime.Singleton, Resolution.Lazy); 
            containerBuilder.RegisterType(typeof(CameraStateMachine), Lifetime.Singleton, Resolution.Lazy); 
            containerBuilder.RegisterType(typeof(CameraStateMachineContext), Lifetime.Singleton, Resolution.Lazy); 
            
            containerBuilder.RegisterType(typeof(UIFactory), new []{typeof(IUIFactory)}, Lifetime.Singleton, Resolution.Eager);
            containerBuilder.RegisterType(typeof(UIService), new []{typeof(IUIService)}, Lifetime.Singleton, Resolution.Eager);
            
            // UIFactory
            // Logo
            // Scene configs
            // Input service
            // Camera
            _initialLoading = new Loading(5, () => EssentialLoadEnded(_thatRightContainer));
        }
        
        private Loading _initialLoading;
        private Container _thatRightContainer;
        private void Bootstrap(Container container)
        {
            _thatRightContainer = container;
            
            container.Resolve<EventBus.EventBus>().Subscribe(this);
            
            container.Resolve<CameraFactory>().CreateCameraStateMachine(container.Resolve<CameraStateMachine>()).Forget();
            
        }

        private void EssentialLoadEnded(Container container)
        {
            container.Resolve<EventBus.EventBus>().Unsubscribe(this);
            container.Resolve<AppStateMachine>().SwitchState(AppStates.Bootstrap).AllowStateTransition(AppStates.Gameplay);   
        }

        public void SceneConfigsLoaded()
        {  
            _initialLoading.DoProgress();
        }

        public void InputServiceInitialized()
        { 
            _initialLoading.DoProgress();
        }

        public void CameraInitialized(CameraStateMachineContext.CameraLoadedData data)
        {
            _thatRightContainer.Resolve<CameraStateMachineContext>().cameraLoadedData = data;
            _thatRightContainer.Resolve<CameraStateMachine>().SwitchState(CameraMode.None)
                .AllowStateTransition(CameraMode.FirstPerson); 
            
            _initialLoading.DoProgress();
        }

        public void UIInitialized()
        {
            _initialLoading.DoProgress();
            
            _thatRightContainer.Resolve<IUIService>().TryLoadPanel(UIPanelType.Logo);
            _thatRightContainer.Resolve<IUIService>().TryLoadPanel(UIPanelType.Loading);
        }

        public void UILoaded(UIPanelType uiPanelType)
        {
            if (_initialLoading.Completed) return;

            switch (uiPanelType)
            {
                case UIPanelType.Logo:
                    _thatRightContainer.Resolve<IUIService>().OpenPanel(UIPanelType.Logo);
            
                    _initialLoading.DoProgress();
                    break;
                case UIPanelType.Loading:
                    // _thatRightContainer.Resolve<IUIService>().OpenPanel(UIPanelType.Logo);
                    break;
            }
        }
    } 
}