using System;
using System.Collections.Generic;
using System.Linq;
using Code.D.Cleaning.CleanTools;
using Code.D.Cleaning.UI;
using Code.D.Player;
using Code.Game.Gameplay.Player;
using Code.Game.Gameplay.Player.Factory;
using Code.Infrastructure.App;
using Code.Infrastructure.Camera;
using Code.Infrastructure.Generators;
using Code.Infrastructure.Input;
using Code.Infrastructure.SceneLoader;
using Code.Infrastructure.UI;
using Code.Infrastructure.Utils;
using Cysharp.Threading.Tasks;
using KinematicCharacterController;
using ObservableCollections;
using R3;
using Reflex.Core;
using UnityEngine;
using UnityEngine.SceneManagement;

namespace Code.Game.TestingLevel
{
    [State(typeof(AppStates), typeof(AppStateMachineContext))]
    public partial class TestingState
    {
        public TestingState(AppStateMachineContext context) : base(context)
        {
        }

        public override AppStates MyState => AppStates.Testing;

        public override async UniTask EnterState()
        {
            Cursor.lockState = CursorLockMode.Locked;

            Context.InputService.EnableMap(ActionMappings.Cleaning);

            Context.AudioService.SetAudioListener(Context.Camera.Camera.GetComponent<AudioListener>());

            await Context.Camera.SwitchState(CameraMode.Cleaner);

            var waitForContainer =
                Context.SceneContainerManager.ScenesContainers
                    .ObserveDictionaryAdd()
                    .Where(x => x.Key == SceneId.Testing)
                    .Take(1)
                    .WaitAsync()
                    .AsUniTask();

            var cleaningPanel = (CleaningPanel) await Context.UIFactory.LoadPanel(UIPanelType.Cleaning,true); 
            
            var factoryConfig = new SingleConfig<PlayerFactorySettings>();
            var cleanToolsConfigs = new MultipleConfig<CleanToolConfig>();

            await UniTask.WhenAll(
                factoryConfig.LoadConfig(), 
                cleanToolsConfigs.LoadConfigs()
                );

            var factory = new PlayerFactory(factoryConfig);
            var player = await factory.CreatePlayer();
            var playerKinematicCharacterMotor = player.GetComponent<KinematicCharacterMotor>();
            var playerMovementController = player.GetComponent<PlayerMovementController>();
            var playerEquipment = player.GetComponent<PlayerEquipment>();

            CleanToolConfig[] toolsConfigs = cleanToolsConfigs.Configs.ToArray();
            List<CleanTool> cleanTools = new();

            // TODO Сделать сервис снабжения игрока
            foreach (var toolConfig in toolsConfigs)
            {
                switch (toolConfig.ToolType)
                {
                    case CleanToolType.Tryapka:
                        cleanTools.Add(new Tryapka(toolConfig.DurabilityUsageStep, toolConfig.CleanRadius, toolConfig.BrushTexture));
                        break;
                }
            }

            void InstallExtra(Scene scene, ContainerBuilder builder)
            {
                builder.RegisterValue(factoryConfig);
                builder.RegisterValue(factory, new []{typeof(IPlayerFactory)});
                builder.RegisterValue(playerKinematicCharacterMotor);
                builder.RegisterValue(playerMovementController);
                builder.RegisterValue(playerEquipment);
                builder.RegisterValue(cleanTools);
                builder.RegisterValue(cleaningPanel);
            }

            await UniTask.WhenAll(
                Context.SceneLoader
                    .LoadSceneAsync(
                        SceneId.Testing,
                        LoadSceneMode.Single,
                        true,
                        InstallExtra),
                waitForContainer
            );

            var container = Context.SceneContainerManager.ScenesContainers[SceneId.Testing];

            container.Resolve<KinematicCharacterMotor>()
                .SetPositionAndRotation(
                    container.Resolve<TestingLevelData>().playerSpawnPoint.position,
                    container.Resolve<TestingLevelData>().playerSpawnPoint.rotation);

            ((CleanerCameraState)Context.Camera.CurrentBaseState)
                .SetPlayer(container.Resolve<PlayerMovementController>());
        }

        public override async UniTask ExitState()
        {
            Context.InputService.DisableMap(ActionMappings.Cleaning);

            await Context.SceneLoader.UnloadSceneAsync(SceneId.Testing);
        }
    }
}