Untitled

using FishNet;
using FishNet.Connection;
using FishNet.Object;
using FishNet.Transporting;
using NIYClient.AnalyticsSystem;
using NIYClient.AudioSystem;
using NIYClient.CameraSystem;
using NIYClient.Core;
using NIYClient.DataSystem;
using NIYClient.DataSystem.Configs;
using NIYClient.DataSystem.Configs.Scenes;
using NIYClient.DataSystem.Game;
using NIYClient.Entity;
using NIYClient.Entity.HealthSystem;
using NIYClient.FireSystem;
using NIYClient.GameControlSystem;
using NIYClient.InventorySystem;
using NIYClient.ItemsSystem;
using NIYClient.LiquidSystem;
using NIYClient.LobbySystem;
using NIYClient.MatchmakingSystem;
using NIYClient.MissionsSystem;
using NIYClient.MultiplayerSystem;
using NIYClient.NPCSystem;
using NIYClient.PlayersSystem;
using NIYClient.RpcJournalSystem;
using NIYClient.SceneSystem;
using NIYClient.SteamSystem;
using NIYClient.UISystem;
using NIYClient.ViewSystem;
using NIYClient.VoiceSystem;
using System.Collections;
using System.Collections.Generic;
using Unity.Services.Authentication;
using UnityEngine;
using static NIYClient.AnalyticsSystem.AnalyticsManager;

namespace NIYClient.MiniFPSController
{
    public class PlayerMultiplayerController : NetworkBehaviour
    {
        [SerializeField] private EntityMediator _entityMediator;
        [SerializeField] private GameObject _cameraParent;
        [SerializeField] private FirstPersonMovement _fpsMovement;
        [SerializeField] private MeshRenderer _playerMesh;
        [SerializeField] private Material _playerControlledMaterial;
        [SerializeField] private Material _enemyControlledMaterial;
        private string _entityId;
        private bool _isHost = false;
        private bool _isLocal = false;

        private RpcJournalManager _rpcJournal;

        public override void OnStartClient()
        {
            base.OnStartClient();

            _rpcJournal = UnityContainer.Resolve<RpcJournalManager>();
            if (base.IsOwner)
            {
                //_cameraParent.SetActive(true);
                //_fpsMovement.enabled = true;
                //_playerMesh.material = _playerControlledMaterial;

                _isLocal = true;
                UnityContainer.Resolve<IPlayersManager>().SetLocalPlayerId(base.LocalConnection.ClientId.ToString());
            }
            else
            {
                //_cameraParent.SetActive(false);
                //_fpsMovement.enabled = false;
                //_playerMesh.material = _enemyControlledMaterial;
            }
            gameObject.name += base.IsOwner ? " (Player)" : " (Enemy)";
            gameObject.name += base.IsServer ? " (Host)" : " (Client)";

            _entityMediator.Init(base.IsOwner, base.IsServer);

            if (InstanceFinder.NetworkManager.IsServer)
            {
                Debug.LogError("IS SERVER!!!");

                UnityContainer.Resolve<ISceneController>().SetIsServer(true);
            }
            else
            {
                Debug.LogError("IS NOT SERVER!!!");
                UnityContainer.Resolve<ISceneController>().SetIsServer(false);
                InstanceFinder.ServerManager.OnServerConnectionState += OnServerConnectionStateChanged;
            }

            _entityId = base.NetworkObject.OwnerId.ToString();

            UnityContainer.Resolve<IPlayersManager>().AddPlayer(_entityId, _entityMediator);
            if (base.IsOwner)
            {
                _rpcJournal.AddMessage(new RpcJournalData()
                {
                    Time = Time.time,
                    Source = _entityId,
                    Data = "Local player spawned: " + _entityId
                });
                GameObject.FindObjectOfType<GameInitializatorMultiplayer>().OnStartedGamePlayer(_entityMediator);
                UnityContainer.Resolve<IUIManager>().ShowPage(PageTypes.HUDPage);
                UnityContainer.Resolve<IUIManager>().ShowPage(PageTypes.PlayersVolumesPage);

                StartCoroutine(DelayedNickCall());

                UnityContainer.Resolve<IVoiceManager>().JoinEchoChannelAsync(GetEntityId(), UnityContainer.Resolve<IMatchmakingManager>().GetHostedJoinCode(), UnityContainer.Resolve<CameraController>().gameObject);

                UnityContainer.Resolve<AnalyticsManager>().LogGameLoadingFinished();
                // stop controls
                //UnityContainer.Resolve<MessagingManager>().Game.SendMessage(GameActions.StopControls);
                //Cursor.lockState = CursorLockMode.None;
                //Cursor.visible = true;
                // sync here Items Data, > 1 - not host
                if (base.ClientManager.Clients.Count > 1)
                {
                    // client lobby page
                    //UnityContainer.Resolve<IUIManager>().ShowPage(PageTypes.GameLobbyClient);

                    // getting items data from server
                    RpcGetWorldItemsState(base.LocalConnection);

                    // getting actual list of items for each client
                    foreach (var client in base.ClientManager.Clients)
                    {
                        if (client.Value != base.LocalConnection)
                        {
                            //RpcGetInventoryData(client.Value, base.LocalConnection);
                        }
                    }
                }
                else
                {
                    // host lobby page
                    _isHost = true;
                    //UnityContainer.Resolve<IUIManager>().ShowPage(PageTypes.GameLobbyHost);
                }
            }
            else
            {
                _rpcJournal.AddMessage(new RpcJournalData()
                {
                    Time = Time.time,
                    Source = _entityId,
                    Data = "Other player spawned: " + _entityId
                });
            }

            base.ServerManager.OnRemoteConnectionState += OnRemoteConnectionStateChanged;
        }

        public override void OnStopServer()
        {
            base.OnStopServer();
            if (_isLocal)
            {
                Debug.LogError("PlayerMultiplayerController::: OnStopServer");
                UnityContainer.Resolve<IGameController>().OpenMenuLogic();
            }
        }

        public void OnDisconnectedFromServer()
        {
            if (_isLocal)
            {
                Debug.LogError("PlayerMultiplayerController::: OnDisconnectedFromServer");
                UnityContainer.Resolve<IGameController>().OpenMenuLogic();
            }
            else
            {
                PlayerData pd = UnityContainer.Resolve<IPlayersManager>().GetPlayerDataById(_entityId);
                if(pd != null)
                {
                    Debug.Log("PlayerMultiplayerController::: OnDisconnectedFromServer: " + pd.Name + " steam id " + pd.SteamId);
                    UnityContainer.Resolve<ILobbyManager>().OnPlayerDisconnect(pd.SteamId);
                }
                else
                {
                    Debug.Log("PlayerMultiplayerController::: OnDisconnectedFromServer: " + _entityId);
                }
            }
        }

        private void OnServerConnectionStateChanged(ServerConnectionStateArgs args)
        {
            switch(args.ConnectionState)
            {
                case LocalConnectionState.Started:
                    // nothing to do
                    Debug.Log("PlayerMultiplayerController::: started connection.");
                    break;
                case LocalConnectionState.Stopping:
                    Debug.Log("PlayerMultiplayerController::: stopping connection.");
                    break;
                case LocalConnectionState.Stopped:
                    Debug.Log("PlayerMultiplayerController::: stopped connection.");
                    UnityContainer.Resolve<IGameController>().OpenMenuLogic();
                    break;
            }
        }

        public string GetEntityId()
        {
            return _entityId;
        }

        public void LaunchSession()
        {
            if (!_isHost)
            {
                Debug.Log("PlayerMultiplayerController::: LaunchSession: not host. Returning");
                return;
            }

            List<PlayerMultiplayerData> playerDatas = new List<PlayerMultiplayerData>();
            ViewCharacterTypes color = ViewCharacterTypes.WomanMilitary;
            List<ViewCharacterTypes> selectedViewTypes = new List<ViewCharacterTypes>();
            Debug.Log("PlayerMultiplayerController::: LaunchSession: " + UnityContainer.Resolve<IPlayersManager>().GetAllPlayers().Count);
            Transform[] sockets = UnityContainer.Resolve<PlayerMultiplayerAvailableSockets>().GetSockets(UnityContainer.Resolve<IPlayersManager>().GetAllPlayers().Count);
            int index = 0;

            List<PlayerData> allPlayers = UnityContainer.Resolve<IPlayersManager>().GetAllPlayers();

            int filledViewTypes = 0;
            int rounds = 15000;
            int curRound = 0;
            while(filledViewTypes < allPlayers.Count && curRound < rounds)
            {
                curRound++;
                ViewCharacterTypes randomType = (ViewCharacterTypes)Random.Range(1, 6);
                if (!selectedViewTypes.Contains(randomType))
                {
                    selectedViewTypes.Add(randomType);
                    filledViewTypes++;
                }
            }
            if(curRound >= rounds)
            {
                Debug.LogError("Error: not enough view types for players. Already randomed: " + curRound);
            }

            MissionManager missionManager = UnityContainer.Resolve<MissionManager>();
            missionManager.GenerateMissions();

            foreach (PlayerData player in allPlayers)
            {
                PlayerMultiplayerData pmd = new PlayerMultiplayerData();
                pmd.PlayerId = player.Id;
                pmd.PlayerName = player.Name;
                pmd.PlayerSteamId = player.SteamId;
                pmd.PlayerAuthId = player.AuthId;
                pmd.PlayerType = selectedViewTypes[index];
                pmd.PlayerStartSocketIndex = index;
                pmd.PlayerPosition = sockets[index].position;
                pmd.PlayerRotation = sockets[index].rotation.eulerAngles;

                pmd.MissionData = missionManager.GetMissionByPlayer(player.Id);
                Debug.Log("PlayerMultiplayerController::: Player id: " + pmd.PlayerId + " name " + pmd.PlayerName + " " + pmd.PlayerType + " " + pmd.PlayerPosition + " " + pmd.PlayerRotation + " " + pmd.MissionData);
                playerDatas.Add(pmd);
                index++;
            }   

            RpcLaunchSession(playerDatas);
        }

        private void OnRemoteConnectionStateChanged(NetworkConnection connection, RemoteConnectionStateArgs arg)
        {

            switch (arg.ConnectionState)
            {
                case RemoteConnectionState.Started:
                    // nothing to do

                    break;
                case RemoteConnectionState.Stopped:

                    //Debug.Log("PlayerMultiplayerController::: stopped connection for : " + arg.ConnectionId.ToString() + " connection " + connection.ClientId.ToString());
                    UnityContainer.Resolve<IPlayersManager>().RemovePlayer(arg.ConnectionId.ToString(), this);
                    break;
            }
        }

        public override void OnStopClient()
        {
            base.OnStopClient();

            base.ServerManager.OnRemoteConnectionState -= OnRemoteConnectionStateChanged;
            if (_isLocal)
            {
                Debug.LogError("PlayerMultiplayerController::: OnStopClient");
#if UNITY_EDITOR
                if (Application.isPlaying)
                {
                    UnityContainer.Resolve<IGameController>().OpenMenuLogic();
                }
#else

                UnityContainer.Resolve<IGameController>().OpenMenuLogic();
#endif
                if (!_isHost)
                {
                    UnityContainer.Resolve<IUIManager>().ShowPopup(PopupTypes.HostLeftGame);
                }
            }
            else
            {
                PlayerData pd = UnityContainer.Resolve<IPlayersManager>().GetPlayerDataById(_entityId);
                if (pd != null)
                {
                    Debug.Log("PlayerMultiplayerController::: OnDisconnectedFromServer: " + pd.Name + " steam id " + pd.SteamId);
                    UnityContainer.Resolve<ILobbyManager>().OnPlayerDisconnect(pd.SteamId);
                }
                else
                {
                    List<string> currentActiveEntities = new List<string>();
                    foreach(PlayerData currentPlayer in UnityContainer.Resolve<IPlayersManager>().GetAllPlayers())
                    {
                        if (!currentActiveEntities.Contains(currentPlayer.SteamId))
                        {
                            currentActiveEntities.Add(currentPlayer.SteamId);
                        }
                    }

                    List<LobbyPlayerData> pld = UnityContainer.Resolve<ILobbyManager>().GetPlayers();

                    foreach(LobbyPlayerData lobbyPlayerData in pld)
                    {
                        if (!currentActiveEntities.Contains(lobbyPlayerData.PlayerId))
                        {
                            UnityContainer.Resolve<ILobbyManager>().OnPlayerDisconnect(lobbyPlayerData.PlayerId);
                        }
                        else
                        {
                            //UnityContainer.Resolve<LobbyManager>().OnPlayerConnect(lobbyPlayerData.PlayerId);
                        }
                    }

                    Debug.Log("PlayerMultiplayerController::: OnDisconnectedFromServer: " + _entityId);
                }
            }
        }

        #region PLAYER_DATA_SYSTEM
        [ServerRpc(RequireOwnership = false)]
        public void RpcSetPlayerName(string id, string name, string steamId, string authId)
        {
            _rpcJournal.AddMessage(new RpcJournalData()
            {
                Time = Time.time,
                Source = "rpc:" + _entityId + "/" + id,
                Data = "Nickname set to: " + name
            });
            RpcSetPlayerNameObserver(id, name, steamId, authId);
        }

        [ObserversRpc]
        public void RpcSetPlayerNameObserver(string id, string name, string steamId, string authId)
        {
            _rpcJournal.AddMessage(new RpcJournalData()
            {
                Time = Time.time,
                Source = "obs:" + id,
                Data = "Nickname set to: " + name
            });
            UnityContainer.Resolve<IPlayersManager>().SetPlayerNameIdSteamId(id, name, steamId, authId);
        }

        [ServerRpc(RequireOwnership = false)]
        public void RpcLaunchSession(List<PlayerMultiplayerData> playerDatas)
        {
            _rpcJournal.AddMessage(new RpcJournalData()
            {
                Time = Time.time,
                Source = "rpc:",
                Data = "RpcLaunchSession"
            });
            RpcLaunchSessionObserver(playerDatas);
        }

        [ObserversRpc]
        public void RpcLaunchSessionObserver(List<PlayerMultiplayerData> playerDatas)
        {
            _rpcJournal.AddMessage(new RpcJournalData()
            {
                Time = Time.time,
                Source = "obs:",
                Data = "RpcLaunchSession"
            });
            UnityContainer.Resolve<IPlayersManager>().SetPlayerDatas(playerDatas);
            //UnityContainer.Resolve<IUIManager>().HidePage(PageTypes.GameLobbyHost);
            //UnityContainer.Resolve<IUIManager>().HidePage(PageTypes.GameLobbyClient);

            CameraCursorLockManager.TurnOffMouse();

            UnityContainer.Resolve<IFireableManager>().GenerateFireables();

            if (_isHost)
            {
                UnityContainer.Resolve<ItemsManager>().GenerateItems();
            }
            else
            {
                RpcGetPlayersInfo(base.LocalConnection);
            }

            UnityContainer.Resolve<PlayerMultiplayerAvailableSockets>().InitGame(playerDatas.Count);

            UnityContainer.Resolve<AnalyticsManager>().LogHostLaunchedSession(UnityContainer.Resolve<IPlayersManager>().GetAllPlayers().Count, _isHost);
        }

        [ServerRpc(RequireOwnership = true)]
        public void RpcOnPlayerConnected(string id)
        {
            RpcOnPlayerConnectedObserver(id);
        }

        [ObserversRpc]
        public void RpcOnPlayerConnectedObserver(string id)
        {
            UnityContainer.Resolve<ILobbyManager>().OnPlayerConnectedScene(id);
        }

        [ServerRpc(RequireOwnership = false)]
        public void RpcSetEvacuationZone(int index)
        {
            RpcSetEvacuationZoneObserver(index);
        }

        [ObserversRpc]
        public void RpcSetEvacuationZoneObserver(int index)
        {
            UnityContainer.Resolve<IGameController>().OnSetEvacuationZone(index);
        }

        [ServerRpc]
        public void RpcSwitchIsInterrior(bool value)
        {
            RpcSwitchIsInterriorObserver(value);
        }

        [ObserversRpc]
        public void RpcSwitchIsInterriorObserver(bool value)
        {
            _entityMediator.SetInterrior(value);
        }
        #endregion

        #region WORLD_STATE_SYSTEM
        IEnumerator DelayedNickCall()
        {
            yield return new WaitForSeconds(0.1f);

            string playerNameFromSave = UnityContainer.Resolve<SteamOperationsManager>().GetLocalNickname();
            Debug.Log("PlayerMultiplayerController::: DelayedNickCall: " + playerNameFromSave + " steam id " + UnityContainer.Resolve<SteamOperationsManager>().GetSteamId());
            UnityContainer.Resolve<IPlayersManager>().SetPlayerNameIdSteamId(GetEntityId(), playerNameFromSave, UnityContainer.Resolve<SteamOperationsManager>().GetSteamId(), AuthenticationService.Instance.PlayerId);
            RpcSetPlayerName(GetEntityId(), playerNameFromSave, UnityContainer.Resolve<SteamOperationsManager>().GetSteamId(), AuthenticationService.Instance.PlayerId);

            // only if we aren't first
            //if (base.ClientManager.Clients.Count > 1)
            //{
            //    RpcGetPlayersInfo(base.LocalConnection);
            //}
            yield return new WaitForSeconds(0.5f);

            // only if we aren't first
            if (base.ClientManager.Clients.Count > 1)
            {
                RpcGetPlayersInfo(base.LocalConnection);
            }
        }

        [ServerRpc(RequireOwnership = false)]
        public void RpcGetPlayersInfo(NetworkConnection conn)
        {
            _rpcJournal.AddMessage(new RpcJournalData()
            {
                Time = Time.time,
                Source = "rpc:" + conn.ClientId,
                Data = "RpcGetPlayersInfo:"
            });
            List<PlayerSyncData> playersData = UnityContainer.Resolve<IPlayersManager>().GetPlayersInfo();
            RpcGetPlayersInfoObserver(conn, playersData);
        }

        [TargetRpc]
        public void RpcGetPlayersInfoObserver(NetworkConnection conn, List<PlayerSyncData> playersData)
        {
            _rpcJournal.AddMessage(new RpcJournalData()
            {
                Time = Time.time,
                Source = "obs:" + conn.ClientId,
                Data = "RpcGetPlayersInfoObserver: length " + playersData.Count
            });
            UnityContainer.Resolve<IPlayersManager>().SetPlayersInfo(playersData);
        }

        [ServerRpc(RequireOwnership = false)]
        public void RpcSendArtifactFinishedData(GameFinishedData gameData)
        {
            RpcSendArtifactFinishedDataObserver(gameData);
        }

        [ObserversRpc]
        public void RpcSendArtifactFinishedDataObserver(GameFinishedData gameData)
        {
            UnityContainer.Resolve<IGameController>().OnPerformArtifactFinishedData(gameData);
        }

        [ServerRpc(RequireOwnership = false)]
        public void RpcAddEvacuatedPlayer(string id)
        {
            RpcAddEvacuatedPlayerObserver(id);
        }

        [ObserversRpc]
        public void RpcAddEvacuatedPlayerObserver(string id)
        {
            UnityContainer.Resolve<IGameController>().OnPlayerEnteredEvacuation(id);
        }

        [ServerRpc(RequireOwnership = false)]
        public void RpcEvacuationStarted()
        {
            RpcEvacuationStartedObserver();
        }

        [ObserversRpc]
        public void RpcEvacuationStartedObserver()
        {
            UnityContainer.Resolve<IAudioManager>().PlaySound(AudioSoundKey.EvactuationZoneStarted);
        }

        [ServerRpc(RequireOwnership = false)]
        public void RpcSendTotalGameFinishedData(GameFinishedData gameData)
        {
            RpcSendGameTotalFinishedDataObserver(gameData);
        }

        [ObserversRpc]
        public void RpcSendGameTotalFinishedDataObserver(GameFinishedData gameData)
        {
            UnityContainer.Resolve<IGameController>().OnPerformGameResultFinishedData(gameData);
        }

        [ServerRpc]
        public void RpcOpenDoors(string transitionId)
        {
            RpcOpenDoorsObserver(transitionId);
        }

        [ObserversRpc]
        public void RpcOpenDoorsObserver(string transitionId)
        {
            UnityContainer.Resolve<TransitionManager>().OpenDoors(transitionId);
        }
        #endregion

        #region HEALTH_SYSTEM
        /// <summary>
        /// Called by clients or NPC to send damage to server and OWNER !!!
        /// </summary>
        /// <param name="attackData"></param>
        [ServerRpc(RequireOwnership = false)]
        public void RpcReceiveDamage(AttackData attackData)
        {
            _rpcJournal.AddMessage(new RpcJournalData()
            {
                Time = Time.time,
                Source = "Rpc:" + _entityId,
                Data = "RpcReceiveDamage: attacker " + (string.IsNullOrEmpty(attackData.AttackerEntityId) ? attackData.AttackerEntityType.ToString() : attackData.AttackerEntityId) + " receiver " + attackData.TargetEntityId + " damage " + attackData.Damage
            });
            RpcReceiveDamageObserver(attackData);
        }

        [ObserversRpc]
        public void RpcReceiveDamageObserver(AttackData attackData)
        {
            _rpcJournal.AddMessage(new RpcJournalData()
            {
                Time = Time.time,
                Source = "obs:" + _entityId,
                Data = "RpcReceiveDamage: attacker " + (string.IsNullOrEmpty(attackData.AttackerEntityId) ? attackData.AttackerEntityType.ToString() : attackData.AttackerEntityId) + " receiver " + attackData.TargetEntityId + " damage " + attackData.Damage
            });
            _entityMediator.HealthController.ReceiveDamageLogic(attackData);
        }

        /// <summary>
        /// Called by owner clients to regen health on server and all clients
        /// </summary>
        /// <param name="regenValue"></param>
        [ServerRpc]
        public void RpcRegenHealth(float regenValue)
        {
            _rpcJournal.AddMessage(new RpcJournalData()
            {
                Time = Time.time,
                Source = "Rpc:" + _entityId,
                Data = "RpcRegenHealth: regen value "  + regenValue
            });
            RpcRegenHealthObserver(regenValue);
        }

        [ObserversRpc]
        public void RpcRegenHealthObserver(float regenValue)
        {
            _rpcJournal.AddMessage(new RpcJournalData()
            {
                Time = Time.time,
                Source = "obs:" + _entityId,
                Data = "RpcRegenHealth: regen value " + regenValue
            });
            _entityMediator.HealthController.RegenHealth(regenValue);
        }

        [ServerRpc]
        public void RpcDropItem(int itemidIterator, InventoryItem itemData)
        {
            RpcDropItemObserver(itemidIterator, itemData);
        }

        [ObserversRpc]  
        public void RpcDropItemObserver(int itemidIterator, InventoryItem itemData)
        {
            _entityMediator.Inventory.DropItem(itemidIterator, itemData, true);
        }

        [ServerRpc]
        public void RpcInventoryOpen()
        {
            RpcInventoryOpenObserver();
        }

        [ObserversRpc(ExcludeOwner = true)]
        public void RpcInventoryOpenObserver()
        {
            _entityMediator.Inventory.OnPlayerOpenedInventory();
        }

        [ServerRpc]
        public void RpcInventoryClose()
        {
            RpcInventoryCloseObserver();
        }

        [ObserversRpc(ExcludeOwner = true)]
        public void RpcInventoryCloseObserver()
        {
            _entityMediator.Inventory.OnPlayerClosedInventory();
        }

        [ServerRpc]
        public void RpcPlayerDie(int itemIdIterator, List<InventoryItem> itemsToDrop, string deathReason)
        {
            _rpcJournal.AddMessage(new RpcJournalData()
            {
                Time = Time.time,
                Source = "rpc:" + _entityId,
                Data = "RpcPlayerDie: death "
            });
            RpcPlayerDieObserver(itemIdIterator, itemsToDrop, deathReason);
        }

        [ObserversRpc]
        public void RpcPlayerDieObserver(int itemIdIterator, List<InventoryItem> itemsToDrop, string deathReason)
        {
            _rpcJournal.AddMessage(new RpcJournalData()
            {
                Time = Time.time,
                Source = "obs:" + _entityId,
                Data = "RpcPlayerDie: death "
            });
            _entityMediator.GetEntityEffectsController().OnDeathClear();
            _entityMediator.HealthController.OnPlayerDeath();
            _entityMediator.FirstPersonMovement.OnDeathLogic();
            _entityMediator.Inventory.DropItems(itemIdIterator, itemsToDrop);
            UnityContainer.Resolve<IGameController>().OnPlayerDied(_entityId, deathReason);
        }

        [ServerRpc(RequireOwnership = false)]
        public void RpcPlayerResurrect(string playerId, AnalyticsResurrectionReason reason)
        {
            RpcPlayerResurrectObserver(playerId, reason);
        }

        [ObserversRpc]
        public void RpcPlayerResurrectObserver(string playerId, AnalyticsResurrectionReason reason)
        {
            _rpcJournal.AddMessage(new RpcJournalData()
            {
                Time = Time.time,
                Source = "obs:" + _entityId,
                Data = "RpcPlayerResurrect: resurrected"
            });
            EntityMediator mediator = UnityContainer.Resolve<IPlayersManager>().GetPlayer(playerId);
            if(mediator != null)
            {
                mediator.HealthController.OnResurrect();
                mediator.OnResurrectLogic();
            }

            // its local heh
            if(mediator == _entityMediator || mediator.GetIsLocal())
            {
                UnityContainer.Resolve<AnalyticsManager>().LogPlayerResurrected(reason);
            }
        }
        #endregion

        #region MOVING_SYSTEM
        [ServerRpc]
        public void RpcStartCrouch()
        {
            RpcStartCrouchObserver();
        }

        [ObserversRpc(ExcludeOwner = true)]
        public void RpcStartCrouchObserver()
        {
            _fpsMovement.OnStartedCrouching();
        }

        [ServerRpc(RequireOwnership = false)]   
        public void RpcEndCrouch()
        {
            RpcEndCrouchObserver();
        }

        [ObserversRpc(ExcludeOwner = true)]
        public void RpcEndCrouchObserver()
        {
            _fpsMovement.OnEndedCrouching();
        }
        #endregion

        #region ITEMS_SYSTEM

        [ServerRpc(RequireOwnership = false)]
        public void RpcSetupItems(List<SceneItemData> sceneItems)
        {
            RpcSetupItemsObserver(sceneItems);
        }

        [ObserversRpc]
        public void RpcSetupItemsObserver(List<SceneItemData> sceneItems)
        {
            if (_isHost)
                return;

            UnityContainer.Resolve<ItemsManager>().SetSceneItemsList(sceneItems);
        }

        [ServerRpc]
        public void RpcPickItem(string itemKey)
        {
            _rpcJournal.AddMessage(new RpcJournalData()
            {
                Time = Time.time,
                Source = "rpc:" + _entityId,
                Data = "RpcPickItem " + itemKey
            });
            RpcPickItemObserver(itemKey);
        }

        [ObserversRpc(ExcludeOwner = true)]
        public void RpcPickItemObserver(string itemKey)
        {
            _rpcJournal.AddMessage(new RpcJournalData()
            {
                Time = Time.time,
                Source = "obs:" + _entityId,
                Data = "RpcPickItem " + itemKey
            });
            UnityContainer.Resolve<ItemsManager>().RemoveItem(itemKey);
            _entityMediator.Inventory.PickedUpItem();
        }

        [ServerRpc]
        public void RpcEquipItem(EquipmentStates state, string itemKey, InventoryItem itemData)
        {
            _rpcJournal.AddMessage(new RpcJournalData()
            {
                Time = Time.time,
                Source = "rpc:" + _entityId,
                Data = "RpcEquipItem " + state + " key:" + itemKey 
            });
            RpcEquipItemObserver(state, itemKey, itemData);
        }

        [ObserversRpc]
        public void RpcEquipItemObserver(EquipmentStates state, string itemKey, InventoryItem itemData)
        {
            _rpcJournal.AddMessage(new RpcJournalData()
            {
                Time = Time.time,
                Source = "obs:" + _entityId,
                Data = "RpcPickItem " + state + " key:" + itemKey
            });
            _entityMediator.Inventory.OnEquippedItem(state, itemKey, itemData);
        }

        [ServerRpc]
        public void RpcUpdateArms(EquipmentStates state)
        {
            _rpcJournal.AddMessage(new RpcJournalData()
            {
                Time = Time.time,
                Source = "rpc:" + _entityId,
                Data = "RpcUpdateArms " + state
            });
            RpcUpdateArmsObserver(state);
        }

        [ObserversRpc]
        public void RpcUpdateArmsObserver(EquipmentStates state)
        {
            _rpcJournal.AddMessage(new RpcJournalData()
            {
                Time = Time.time,
                Source = "obs:" + _entityId,
                Data = "RpcUpdateArms " + state
            });
            _entityMediator.Inventory.OnUpdateArms(state);
        }

        [ServerRpc(RequireOwnership = false)]
        public void RpcGetWorldItemsState(NetworkConnection conn)
        {
            string[] allItems = UnityContainer.Resolve<ItemsManager>().GetActiveItemsArray();
            Debug.Log("Items count: " + allItems.Length);
            RpcGetWorldItemsStateObserver(conn, allItems);
        }

        [TargetRpc]
        public void RpcGetWorldItemsStateObserver(NetworkConnection conn, string[] keys)
        {
            UnityContainer.Resolve<ItemsManager>().UpdateActiveItemsState(keys);
        }

        [ServerRpc]
        public void RpcUseItem()
        {
            _rpcJournal.AddMessage(new RpcJournalData()
            {
                Time = Time.time,
                Source = "rpc:" + _entityId,
                Data = "RpcUseItem " 
            });
            RpcUseItemObserver();
        }

        [ObserversRpc(ExcludeOwner = true)]
        public void RpcUseItemObserver()
        {
            _rpcJournal.AddMessage(new RpcJournalData()
            {
                Time = Time.time,
                Source = "obs:" + _entityId,
                Data = "RpcUseItem "
            });
            _entityMediator.Inventory.OnUseActiveItem();
        }

        [ServerRpc]
        public void RpcUseItemEnded()
        {
            RpcUseItemEndedObserver();
        }

        [ServerRpc(RequireOwnership = false)]
        public void RpcReloadItem()
        {
            RpcReloadItemObserver();
        }

        [ObserversRpc]
        public void RpcReloadItemObserver()
        {
            _entityMediator.Inventory.OnReloadItem();
        }

        [ObserversRpc(ExcludeOwner = true)]
        public void RpcUseItemEndedObserver()
        {
            _entityMediator.Inventory.OnUseItemEnded();
        }

        [ServerRpc]
        public void RpcAimItemStarted()
        {
            RpcAimItemStartedObserver();
        }

        [ObserversRpc]
        public void RpcAimItemStartedObserver()
        {
            _entityMediator.Inventory.OnAimItemStarted();
        }

        [ServerRpc]
        public void RpcAimItemEnded()
        {
            RpcAimItemEndedObserver();
        }

        [ObserversRpc]
        public void RpcAimItemEndedObserver()
        {
            _entityMediator.Inventory.OnAimItemEnded();
        }

        [ServerRpc]
        public void RpcUseItem(Vector3 from, List<Vector3> to)
        {
            _rpcJournal.AddMessage(new RpcJournalData()
            {
                Time = Time.time,
                Source = "rpc:" + _entityId,
                Data = "RpcUseItem " + from + " " + to
            });
            RpcUseItemObserver(from, to);
        }

        [ObserversRpc(ExcludeOwner = true)]
        public void RpcUseItemObserver(Vector3 from, List<Vector3> to)
        {
            _rpcJournal.AddMessage(new RpcJournalData()
            {
                Time = Time.time,
                Source = "obs:" + _entityId,
                Data = "RpcUseItem " + from + " " + to
            });
            _entityMediator.Inventory.OnUseActiveItem(from, to);
        }

        [ServerRpc(RequireOwnership = false)]
        public void RpcStealItem(string entityId, string itemId)
        {
            RpcStealItemObserver(entityId, itemId);
        }

        [ObserversRpc]
        public void RpcStealItemObserver(string entityId, string itemId)
        {
            Debug.LogError("Stealing item from : " + entityId + " item: " + itemId);
            EntityMediator entity = UnityContainer.Resolve<IPlayersManager>().GetPlayer(entityId);
            if (entity != null)
            {
                entity.Inventory.OnStealItem(itemId);
            }
        }

        [ServerRpc]
        public void RpcAttackResult(AttackResultType attackResultType)
        {
            RpcAttackResultObserver(attackResultType);
        }

        [ObserversRpc]
        public void RpcAttackResultObserver(AttackResultType attackResultType)
        {
            _entityMediator.Inventory.OnAttackResult(attackResultType);
        }

        [ServerRpc(RequireOwnership = true)]
        public void RpcFailedLighter()
        {
            RpcFailedLighterObserver();
        }

        [ObserversRpc]
        public void RpcFailedLighterObserver()
        {
            _entityMediator.Inventory.OnLighterFailed();
        }
        #endregion

        #region NPC_SYSTEM
        [ServerRpc(RequireOwnership = false)]
        public void RpcHitNPC(string id, AttackData attackData)
        {
            RpcHitNPCObserver(id, attackData);
        }

        [ObserversRpc]
        public void RpcHitNPCObserver(string id, AttackData attackData)
        {
            UnityContainer.Resolve<NPCManager>().HitNPC(id, attackData);
        }

        [ServerRpc(RequireOwnership = false)]
        public void RpcAddHealthForce(string id, float value)
        {
            RpcAddHealthForceObserver(id, value);
        }

        [ObserversRpc]
        public void RpcAddHealthForceObserver(string id, float value)
        {
            UnityContainer.Resolve<NPCManager>().AddHealthForce(id, value);
        }

        [ServerRpc(RequireOwnership = false)]
        public void RpcRegenNPC(string id, float regen)
        {
            RpcRegenNPCObserver(id, regen);
        }

        [ObserversRpc]
        public void RpcRegenNPCObserver(string id, float regen)
        {
            UnityContainer.Resolve<NPCManager>().RegenNPC(id, regen);
        }

        [ServerRpc(RequireOwnership = false)]
        public void RpcNPCAttack(string id)
        {
            RpcNPCAttackObserver(id);
        }

        [ObserversRpc]
        public void RpcNPCAttackObserver(string id)
        {
            UnityContainer.Resolve<NPCManager>().AttackNPC(id);
        }

        [ServerRpc(RequireOwnership = false)]
        public void RpcNPCPreDeath(string id)
        {
            RpcNPCPreDeathObserver(id);
        }

        [ObserversRpc]
        public void RpcNPCPreDeathObserver(string id)
        {
            UnityContainer.Resolve<NPCManager>().PreDeathNPC(id);
        }

        //[ServerRpc(RequireOwnership = false)]
        //public void RpcNPCDeath(string id)
        //{
        //    RpcNPCDeathObserver(id);
        //}

        //[ObserversRpc]
        //public void RpcNPCDeathObserver(string id)
        //{
        //    UnityContainer.Resolve<NPCManager>().NPCDeath(id);
        //}

        [ServerRpc] 
        public void RPCNPCMadeSound(string id, AudioSoundKey soundKey)
        {
            RPCNPCMadeSoundObserver(id, soundKey);
        }

        [ObserversRpc] 
        public void RPCNPCMadeSoundObserver(string id, AudioSoundKey soundKey)
        {
            UnityContainer.Resolve<NPCManager>().NPCMadeSound(id, soundKey);
        }

        [ServerRpc]
        public void RPCNPCStartLongSound(string id, AudioSoundKey soundKey, bool value)
        {
            RPCNPCStartLongSoundObserver(id, soundKey, value);
        }

        [ObserversRpc]
        public void RPCNPCStartLongSoundObserver(string id, AudioSoundKey soundKey, bool value)
        {
            UnityContainer.Resolve<NPCManager>().NPCStartLongSoundRequest(id, soundKey, value);
        }

        [ServerRpc]
        public void RpcNPCTakeItem(string npcId, string itemId)
        {
            RpcNPCTakeItemObserver(npcId, itemId);
        }

        [ObserversRpc]
        public void RpcNPCTakeItemObserver(string npcId, string itemId)
        {
            NPCMediator npcMediator = UnityContainer.Resolve<NPCManager>().GetNPC(npcId) as NPCMediator;
            npcMediator.Controller.TakeItem(itemId);
        }

        [ServerRpc(RequireOwnership = false)]
        public void RpcNPCSpawnCustomVFX(string npcId)
        {
            RpcNPCSpawnCustomVFXObserver(npcId);
        }

        [ObserversRpc]
        public void RpcNPCSpawnCustomVFXObserver(string npcId)
        {
            NPCMediator npcMediator = UnityContainer.Resolve<NPCManager>().GetNPC(npcId) as NPCMediator;
            npcMediator.Controller.OnSpawnCustomVFX();
        }

        [ServerRpc(RequireOwnership = false)]
        public void RpcNPCHitBlock(string npcId)
        {
            RpcNPCHitBlockObserver(npcId);
        }

        [ObserversRpc]
        public void RpcNPCHitBlockObserver(string npcId)
        {
            NPCMediator npcMediator = UnityContainer.Resolve<NPCManager>().GetNPC(npcId) as NPCMediator;
            if(npcMediator != null)
            {
                npcMediator.Controller.OnHitBlock();
            }
        }
        #endregion

        #region EFFECTS_SYSTEM
        [ServerRpc(RequireOwnership = false)]
        public void RpcAddEffect(string id, EffectTypes effectType)
        {
            RpcAddEffectObserver(id, effectType);
        }

        [ObserversRpc]
        public void RpcAddEffectObserver(string id, EffectTypes effectType)
        {
            EntityMediator entity = UnityContainer.Resolve<IPlayersManager>().GetPlayer(id);
            if(entity != null)
            {
                Debug.Log("PlayerMultiplayerController::: RpcAddEffectObserver to player " + id + " " + effectType);
                entity.GetEntityEffectsController().AddEffect(effectType);
            }
            else
            {
                BaseEntityMediator npcEntity = UnityContainer.Resolve<NPCManager>().GetNPC(id);
                if(npcEntity != null)
                {
                    Debug.Log("PlayerMultiplayerController::: RpcAddEffectObserver to enemy " + id + " " + effectType);
                    Debug.Log("PlayerMultiplayerController::: logged ability to add effect for NPC cause of should not be added to NPC");

                    if (effectType == EffectTypes.Liquided || effectType == EffectTypes.Firing)
                        (npcEntity as NPCMediator).GetEntityEffectsController().AddEffect(effectType);
                }
            }
        }
        #endregion

        #region FIREABLE_SYSTEM
        /// <summary>
        /// Called by SERVER. Here we send commands to multiplayer to destroy some fireable object
        /// </summary>
        /// <param name="id"></param>
        [ServerRpc(RequireOwnership = false)]
        public void RpcDestroyFireable(string id)
        {
            RpcDestroyFireableObserver(id);
        }

        [ObserversRpc]
        public void RpcDestroyFireableObserver(string id)
        {
            UnityContainer.Resolve<IFireableManager>().OnFireableDestroyed(id);
        }

        /// <summary>
        /// Called by clients when they start or end filling liquid. Its calculating on server by itself
        /// </summary>
        /// <param name="liquidId"></param>
        /// <param name="fillingSpeed"></param>
        /// <param name="isFilling"></param>
        [ServerRpc]
        public void RpcSpawnLiquid(Vector3 pos, Vector3 normal, string mainLiquidId, string liquidId, string fireableId)
        {
            Debug.Log("PlayerMultiplayerController::: RpcSpawnLiquid " + pos + " " + normal + " mainId " + mainLiquidId + " newId " + liquidId + " " + fireableId);  

            RpcStartLiquidObserver(pos, normal, mainLiquidId, liquidId, fireableId);
        }

        [ObserversRpc]
        public void RpcStartLiquidObserver(Vector3 pos, Vector3 normal, string mainLiquidId, string liquidId, string fireableId)
        {
            UnityContainer.Resolve<ILiquidManager>().SpawnLiquidLogic(pos, normal, mainLiquidId, liquidId, fireableId);

            //Debug.LogError("calculate here fireables");
            //if (!string.IsNullOrEmpty(fireableId))
            //    UnityContainer.Resolve<FireableManager>().AddLiquidToFireable(fireableId, liquid);
        }

        [ServerRpc(RequireOwnership = false)]
        public void RpcRemoveLiquid(string mainId, string id)
        {
            RpcRemoveLiquidObserver(mainId,id);
        }

        [ObserversRpc]
        public void RpcRemoveLiquidObserver(string mainId, string id)
        {
            UnityContainer.Resolve<ILiquidManager>().OnRemoveLiquid(mainId, id);
        }

        [ServerRpc(RequireOwnership = false)]
        public void RpcStartFire(string id, string activatorPlayerId)
        {
            RpcStartFireObserver(id, activatorPlayerId);
        }

        [ObserversRpc]
        public void RpcStartFireObserver(string id, string activatorPlayerId)
        {
            UnityContainer.Resolve<IFireableManager>().StartFiring(id, activatorPlayerId);
        }

        [ServerRpc(RequireOwnership = false)]
        public void RpcStartFlame(string mainId, string id, string activatorPlayerId)
        {
            RpcStartFlameObserver(mainId, id, activatorPlayerId);
        }

        [ObserversRpc]
        public void RpcStartFlameObserver(string mainId, string id, string activatorPlayerId)
        {
            UnityContainer.Resolve<ILiquidManager>().StartFlame(mainId, id, activatorPlayerId);
        }
        #endregion
    }
}