CourierOld/Game/CourierOld/Assets/Code/App/BootstrapInstaller.cs

using System.Collections.Generic;
using Code.App.Loading;
using Code.App.StateMachine;
using Code.Audio;
using Code.Configs;
using Code.Constants;
using Code.Gameplay.Camera;
using Code.Gameplay.Orders.Order;
using Code.Gameplay.Player;
using Code.Input;
using Code.Scenes;
using Code.StaticData;
using Code.UI;
using Code.UI.Panels;
using Cysharp.Threading.Tasks;
using Reflex.Core;
using Reflex.Injectors;
using UnityEngine;
using UnityEngine.InputSystem;

namespace Code.App
{
    public class BootstrapInstaller : MonoBehaviour, IInstaller
    {
        public void InstallBindings(ContainerBuilder containerBuilder)
        {
            InstallStaticData(containerBuilder, out IStaticDataService staticDataService);
            
            InstallInfrastructureUnit(containerBuilder, staticDataService);

            containerBuilder.AddSingleton(typeof(LoadingManager), typeof(ILoadingManager));
            
            containerBuilder.AddSingleton(typeof(InputService), typeof(IInputService));
            containerBuilder.AddSingleton(typeof(PlayerFactory), typeof(IPlayerFactory));

            InitializeCamera(containerBuilder, staticDataService);
            
            containerBuilder.AddSingleton(typeof(UIFactory), typeof(IUIFactory));
            containerBuilder.AddSingleton(typeof(UIService), typeof(IUIService));
            
            containerBuilder.AddSingleton(typeof(AudioFactory), typeof(IAudioFactory));
            containerBuilder.AddSingleton(typeof(AudioService), typeof(IAudioService));
            
            containerBuilder.AddSingleton(typeof(SceneLoaderService), typeof(ISceneLoaderService));
            
            containerBuilder.OnContainerBuilt += Bootstrap;
        }

        private void InitializeCamera(ContainerBuilder containerBuilder, IStaticDataService staticDataService)
        {
            Camera camera = Instantiate(staticDataService.CameraConfig.cameraPrefab); 
            
            DontDestroyOnLoad(camera);
            containerBuilder.AddSingleton(camera);
        }

        private void InstallInfrastructureUnit(ContainerBuilder containerBuilder, IStaticDataService staticDataService)
        {
            GameObject infrastructureUnit = Instantiate(staticDataService.AppConfig.infrastructureUnitPrefab);
            DontDestroyOnLoad(infrastructureUnit);
            
            containerBuilder.AddSingleton(infrastructureUnit);
            containerBuilder.AddSingleton(infrastructureUnit.AddComponent<CoroutineRunner>(),
                typeof(ICoroutineRunner));  
            containerBuilder.AddSingleton(infrastructureUnit.AddComponent<AppStateMachine>());
            containerBuilder.AddSingleton(infrastructureUnit.AddComponent<CameraStateMachine>());
        }

        private void InstallStaticData(ContainerBuilder containerBuilder, out IStaticDataService staticDataService)
        {
            staticDataService = new StaticDataService();
            staticDataService.Load();

            containerBuilder.AddSingleton(staticDataService, typeof(IStaticDataService));
            
            containerBuilder.AddSingleton(staticDataService.InputConfig.inputActionAsset, typeof(InputActionAsset));
            containerBuilder.AddSingleton(staticDataService.InputConfig, typeof(InputConfig));
            
            containerBuilder.AddSingleton(staticDataService.CameraConfig, typeof(CameraConfig));
            containerBuilder.AddSingleton(staticDataService.CameraSettingsConfigs, typeof(Dictionary<CameraMode,CameraSettingsConfig>));
            
            containerBuilder.AddSingleton(staticDataService.PlayerConfig, typeof(PlayerConfig));
            containerBuilder.AddSingleton(staticDataService.CharacterConfig, typeof(CharacterConfig));
            
            containerBuilder.AddSingleton(staticDataService.UIConfig, typeof(UIConfig));
            
            containerBuilder.AddSingleton(staticDataService.AudioMixerConfig, typeof(AudioMixerConfig));
            containerBuilder.AddSingleton(staticDataService.SoundtrackListConfig, typeof(SoundtrackListConfig));
            containerBuilder.AddSingleton(staticDataService.SFXListConfig, typeof(SFXListConfig));
            containerBuilder.AddSingleton(staticDataService.DispatcherSoundListConfig, typeof(DispatcherSoundListConfig));
            containerBuilder.AddSingleton(staticDataService.EnemiesSoundListConfig, typeof(EnemiesSoundListConfig));
            containerBuilder.AddSingleton(staticDataService.AudioSourceSettingsConfigs, typeof(Dictionary<AudioSourceType, AudioSourceSettingsConfig>));

            containerBuilder.AddSingleton(staticDataService.OrderServiceConfig, typeof(OrderServiceConfig));
            containerBuilder.AddSingleton(staticDataService.OrderBoxConfig, typeof(OrderBoxConfig)); 
        }

        private AppStateMachine _appStateMachine;

        private void Bootstrap(Container container)
        {
            _appStateMachine = container.Resolve<AppStateMachine>();
            _appStateMachine.Initialize();
            AttributeInjector.Inject(_appStateMachine.StateMachineContext, container);
            
            CameraStateMachine cameraStateMachine = container.Resolve<CameraStateMachine>();
            AttributeInjector.Inject(cameraStateMachine.StateMachineContext, container);
            cameraStateMachine.Initialize();

#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
            BootstrapFinish(container);
#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
        }
        private async UniTaskVoid BootstrapFinish(Container container)
        {
            var loadingScreen = GameObject.FindWithTag(Tags.LoadingScreen).GetComponent<LoadingScreen>();
            DontDestroyOnLoad(loadingScreen.gameObject);

            ILoadingManager loadingManager = container.Resolve<ILoadingManager>();
            loadingManager.OnLoadingStarted += loadingScreen.Show;
            loadingManager.OnLoadingEnded += loadingScreen.Hide;

            loadingManager.RegisterLoading(LoadingWork.Bootstrap);
            
            await UniTask.WhenAll(
                container.Resolve<IUIService>().Initialize(loadingScreen),
                container.Resolve<IAudioService>().Initialize()
                );
            
            loadingManager.UnregisterLoading(LoadingWork.Bootstrap);
            
            _appStateMachine
                .SwitchState(AppState.MainMenu)
                .AllowStateTransition(AppState.Gameplay);
        }
    }
}