LoadGameplayState

using System.Collections.Generic;
using AnimalSimulator.Data;
using AnimalSimulator.GameLogic;
using AnimalSimulator.Infrastructure.Factory;
using AnimalSimulator.Infrastructure.Tags;
using AnimalSimulator.Logic;
using AnimalSimulator.Player;
using AnimalSimulator.Services;
using AnimalSimulator.Services.Inputs;
using AnimalSimulator.Services.PersistentProgress;
using AnimalSimulator.Services.StaticData;
using AnimalSimulator.UI;
using AnimalSimulator.UI.Elements;
using AnimalSimulator.UI.Services.Factory;
using Cinemachine;
using UnityEngine;

namespace AnimalSimulator.Infrastructure.States
{
    public class LoadGameplayState : IPayloadedState<ServicesContainer>
    {
        private readonly GameStateMachine _stateMachine;

        public LoadGameplayState(GameStateMachine gameStateMachine) =>
            _stateMachine = gameStateMachine;

        public void Enter(ServicesContainer services)
        {
            // Get Services
            var progressService = services.Single<IPersistentProgressService>();

            var inputService = services.Single<IInputService>();
            var gameFactory = services.Single<IGameFactory>();

            // Get Services properties
            var progress = progressService.Progress;
            var readers = gameFactory.ProgressReaders;
            var camera = gameFactory.CreateCameraBrain();

            IZoneInfoObserver[] zoneInfoObservers = InitUI(services, camera);

            InitGameWorld(gameFactory, inputService, progress, zoneInfoObservers);
            InformProgressReaders(readers, progress);

            _stateMachine.Enter<GameLoopState>();
        }

        private static IZoneInfoObserver[] InitUI(ServicesContainer services, Camera camera)
        {
            var factory = services.Single<IUIFactory>();
            var staticDataService = services.Single<IStaticDataService>();
            var inputService = services.Single<IInputService>();

            factory.CreateRoot();

            factory.Input.CreateTouchpadForCamera();
            inputService.Initialize();

            var uiRoot = factory.UIRoot;

            var actionIcon = uiRoot.GetComponentInChildren<ActionImageIcon>();

            actionIcon.Construct(staticDataService);
            InteractableFollow follow = factory.CreateInteractableFollow();
            follow.Construct(camera, staticDataService);



            return new IZoneInfoObserver[] {follow, actionIcon};
        }

        public void Exit()
        {
        }

        private void InformProgressReaders(IEnumerable<ISavedProgressReader> readers, PlayerProgress progress)
        {
            foreach (var reader in readers)
                reader.LoadProgress(progress);
        }

        private void InitGameWorld(IGameFactory factory, IInputService input, PlayerProgress progress,
            params IZoneInfoObserver[] zoneInfoObservers)
        {
            var player = InitPlayer(factory, input);

            CameraFollow(player, factory);

            InitializeIslands(progress, player, zoneInfoObservers);
        }

        private static void InitializeIslands(PlayerProgress progress, GameObject player,
            params IZoneInfoObserver[] zoneInfoObservers)
        {
            var islands = Object.FindObjectsOfType<Island>();

            foreach (var island in islands)
            {
                var zones = island.GetComponentsInChildren<InteractZone>();

                foreach (var zone in zones)
                    zone.Construct(zoneInfoObservers);

                var uniqueId = island.GetComponent<UniqueId>();
                var id = uniqueId.Id;

                var worldData = progress.WorldData;
                var islandID = worldData.IslandID;

                if (islandID != id) continue;

                var playerTransform = player.transform;

                island.PlacePlayer(playerTransform);
            }
        }

        private GameObject InitPlayer(IGameFactory factory, IInputService input)
        {
            var player = factory.CreatePlayer();

            var inputController = player.GetComponent<PlayerInputController>();

            inputController.Construct(input);

            return player;
        }

        private void CameraFollow(GameObject player, IGameFactory gameFactory)
        {
            var camera = gameFactory.CreateLookCamera();

            var freeLook = camera.GetComponent<CinemachineFreeLook>();

            var cameraAim = player.GetComponentInChildren<CameraAim>();
            var cameraTarget = player.GetComponentInChildren<CameraTarget>();

            freeLook.Follow = cameraAim.transform;
            freeLook.LookAt = cameraTarget.transform;
        }
    }
}