StepManager.cs

Go to the documentation of this file.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http;
using PixoVR.Apex;
using PixoVR.Apex.XAPI;
using PixoVR.Audio;
using PixoVR.Core;
using TMPro;
using UnityEngine;
 
namespace PixoVR.Event
{
    public class StepManager : MonoBehaviour
    {
        public static bool isListen = false;
        [SerializeField] private StepsDataSO _stepsData;
        [SerializeField] private string _currentStepID;
        [SerializeField] private int _currentFunctionID;
 
        [SerializeField] private TMP_Text _currentStepText;
        [SerializeField] private TMP_Text _currentFunctionText;
        [SerializeField] private BreakdownDebug _breakdownDebug;
        private QuizData _quizData;
 
        private bool _isLastFunctionInStep;
        private bool isWaitForUserChoice;
 
        private readonly Dictionary<ItemsEnum, InteractableClass> dictionaryOfItems =
            new Dictionary<ItemsEnum, InteractableClass>();
 
        private readonly List<ItemsEnum> listOfTrigeredItems = new List<ItemsEnum>();
 
        private AudioService _audioService;
 
        private VoiceOverData _voData;
        public event Action<string, int> StepInformationUpdated;
 
        static private int stepId = 0;
 
        private ErrorMessagePopup _errorMessagePopup;
        private ScenarioState _scenarioState;
        private Extension _contextExtension;
 
        private bool _apexJoinTryRepeated;
 
        private void Awake()
        {
            _errorMessagePopup = ServiceLocator.Resolve<ErrorMessagePopup>();
 
            EventBetter.Listen(this, (ItemInformation msg) => RegisterItems(msg.Item, msg.InteractableClass));
 
            isListen = true;
            _isLastFunctionInStep = false;
 
            EventBetter.Raise(
                new WaitStepManager()
                {
                    IsStart = true,
                }
            );
 
            if (ApexSystem.Instance)
            {
                ApexSystem.Instance.OnJoinSessionSuccess.AddListener(OnJoinSessionSuccess);
                ApexSystem.Instance.OnJoinSessionFailed.AddListener(OnJoinSessionFailed);
            }
 
            var apexSessionState = StatesService.GetState<ApexSessionState>(true);
            _scenarioState = StatesService.GetState<ScenarioState>();
            _quizData = StatesService.GetState<QuizData>();
            if (_breakdownDebug != null)
            {
                _breakdownDebug.SetQuizData(_quizData);
            }
 
            if (apexSessionState.IsLoggedIn)
            {
                _contextExtension = new Extension();
                _contextExtension.AddSimple("Session Start Time", $"{DateTime.UtcNow}");
                _contextExtension.AddSimple("UserName", $"{apexSessionState.UserName}");
                _contextExtension.AddSimple("UserEmail", $"{apexSessionState.Email}");
                _contextExtension.AddSimple("Mode", $"{_scenarioState.CurrentScenario}");
                _contextExtension.AddSimple("Truck model", $"Freightliner Cascadia (2016-2020))");
                _contextExtension.AddSimple("Software version number", $"{Application.version}");
 
                //TODO:hack for transmission definition
                _contextExtension.AddSimple(
                    "Transmission",
                    _scenarioState.CurrentScenario.ToString().Contains("MANUAL")
                        ? "Manual"
                        : "Automatic"
                );
 
                apexSessionState.StartTime = DateTime.UtcNow;
 
                ApexSystem.JoinSession($"{_scenarioState.CurrentScenario}", _contextExtension);
            }
        }
 
        private void OnJoinSessionFailed(FailureResponse failureResponse)
        {
            Debug.Log("Apex OnJoinSessionFailed");
 
            if (_apexJoinTryRepeated) return;
 
            _apexJoinTryRepeated = true;
 
            _errorMessagePopup.ShowErrorMessage("APEX. Join session failed.Try to connect again");
            _errorMessagePopup.CloseButtonClicked += () =>
            {
                ApexSystem.JoinSession($"{_scenarioState.CurrentScenario}", _contextExtension);
            };
        }
 
        private void OnJoinSessionSuccess(HttpResponseMessage httpResponseMessage)
        {
            Debug.Log("Apex OnJoinSessionSuccess");
 
            _apexJoinTryRepeated = false;
        }
 
        private void OnEnable()
        {
            var stepsData = StatesService.GetState<StepsDataSO>();
 
            if (stepsData != null)
            {
                _stepsData = stepsData;
            }
        }
 
        private void Start()
        {
            StartCoroutine(PreparingForStart());
        }
 
        private IEnumerator PreparingForStart()
        {
            yield return new WaitForSeconds(1);
            _audioService = ServiceLocator.Resolve<AudioService>();
 
            _audioService.InitCurrentVoiceOverdata(StatesService.GetState<VoiceOverData>());
 
            StartScenario();
        }
 
        public InteractableClass GetGameObjectByID(ItemsEnum itemId)
        {
            return dictionaryOfItems.GetValueOrDefault(itemId);
        }
 
        public void GoToStep(string stepId)
        {
            //TODO
        }
 
        public Dictionary<ItemsEnum, InteractableClass> GetDictionary()
        {
            return dictionaryOfItems;
        }
 
        private void StartScenario()
        {
            StartStep_Function(_stepsData.GetStepItem());
        }
 
        private void StartStep_Function(StepItem stepItem) //StartStep
        {
            StartCoroutine(StartStep_FunctionEnumerator(stepItem)); //StartStepEnumerator
        }
 
        private IEnumerator StartStep_FunctionEnumerator(StepItem stepItem)
        {
            yield return new WaitForSeconds(0.5f);
 
            if (stepItem.waitForUserAction)
            {
                EventBetter.Unlisten<TriggeredItemEvent>(this);
            }
 
            _audioService.StopRepeatable();
            _audioService.StopOnceTimeTemporarily();
 
            _currentStepID = stepItem.stepID;
            isWaitForUserChoice = false;
            _isLastFunctionInStep = false;
 
            _currentFunctionID = 0;
            UpdateDebugUI();
            StartFunction(stepItem);
        }
        
        private void StartFunction(StepItem stepItem)
        {
            StepFunction stepFunction = stepItem.functionsStep[_currentFunctionID];
 
            _isLastFunctionInStep = (stepItem.functionsStep.Count - _currentFunctionID) == 1;
            isWaitForUserChoice = false;
 
            switch (stepFunction.function)
            {
                case Function.ACTIVATE_OBJECT:
                    Debug.Log($"case Function.ActivateObject {stepItem.stepID}");
                    ExecuteFunction(new ActivateObject(), stepItem, stepFunction);
 
                    break;
                case Function.DEACTIVATE_OBJECT:
                    Debug.Log($"case Function.DeactivateObject {stepItem.stepID}");
                    ExecuteFunction(new DeactivateObject(), stepItem, stepFunction);
 
                    break;
                case Function.HIGHLIGHT_OBJECTS:
                    Debug.Log($"case Function.HighlightObjects {stepItem.stepID}");
 
                    if (StatesService.GetState<ScenarioState>().IsEvaluation)
                    {
                        ExecuteFunction(new HighlightOnSelection(), stepItem, stepFunction);
                    }
                    else
                    {
                        ExecuteFunction(new HighlightObject(), stepItem, stepFunction);
                    }
 
                    break;
                case Function.TURN_OFF_HIGHLIGHT_OBJECT:
                    Debug.Log($"case Function.TurnOffHighlightObject {stepItem.stepID}");
                    ExecuteFunction(new TurnOffHighlightObject(), stepItem, stepFunction);
                    break;
                case Function.ACTIVATE_AND_HIGHLIGHT:
                    Debug.Log($"case Function.ActivateAndHighlight {stepItem.stepID}");
 
                    if (StatesService.GetState<ScenarioState>().IsEvaluation)
                    {
                        ExecuteFunction(new ActivateAndHighlightOnSelection(), stepItem, stepFunction);
                    }
                    else
                    {
                        ExecuteFunction(new ActivateAndHighlight(), stepItem, stepFunction);
                    }
 
                    break;
                case Function.DEACTIVATE_AND_HIGHLIGHT_OFF:
                    Debug.Log($"case Function.DeactivateAndHighlightOff {stepItem.stepID}");
                    ExecuteFunction(new DeactivateAndHighlightOff(), stepItem, stepFunction);
                    break;
                case Function.PLAY_VOICE_OVER:
                    Debug.Log($"case Function.PlayVoiceOver {stepItem.stepID}");
                    ExecuteFunction(new PlayVoiceOver(), stepItem, stepFunction);
 
                    break;
                case Function.GRABLE_OR_INTERACT_OBJECT:
                    Debug.Log($"case Function.GrableOrInteractObject {stepItem.stepID}");
                    ExecuteFunction(new GrableOrInteractObject(), stepItem, stepFunction);
 
                    break;
                case Function.TELEPORT_TO_POSITION:
                    Debug.Log($"case Function.TeleportToPosition {stepItem.stepID}");
                    ExecuteFunction(new TeleportToPosition(), stepItem, stepFunction);
 
                    break;
                case Function.TRANSIT_TO_SCENE:
                    Debug.Log($"case Function.TransitToScene {stepItem.stepID}");
                    ExecuteFunction(new TransitToScene(), stepItem, stepFunction);
 
                    break;
                case Function.START_PLAY_ANIMATION:
                    Debug.Log($"case Function:StartPlayAnimation {stepItem.stepID}");
                    ExecuteFunction(new StartPlayAnimation(), stepItem, stepFunction);
 
                    break;
                case Function.START_REVERSE_ANIMATION:
                    Debug.Log($"case Function:StartReverseAnimation {stepItem.stepID}");
                    ExecuteFunction(new StartReverseAnimation(), stepItem, stepFunction);
 
                    break;
                case Function.OPEN_INSPECTION_MENU_FOR_ITEM:
                    Debug.Log($"case Function:OpenInspectionMenuForItem {stepItem.stepID}");
                    ExecuteFunction(new OpenInspectionMenuForItem(), stepItem, stepFunction);
 
                    break;                
                case Function.SET_ADDITIONAL_PARAMS_FOR_ITEM:
                    Debug.Log($"case Function:SetAdditionalParamsForItem {stepItem.stepID}");
                    ExecuteFunction(new SetAdditionalParamsForItem(), stepItem, stepFunction);
 
                    break;
                case Function.PREPARE_INSPECTION_REPORT:
                    Debug.Log($"case Function:PrepareInspectionReport {stepItem.stepID}");
                    ExecuteFunction(new PrepareInspectionReport(), stepItem, stepFunction);
 
                    break;
                case Function.SHOW_MODEL:
                    Debug.Log($"case Function.SHOW_MODEL {stepItem.stepID}");
                    ExecuteFunction(new ShowModel(), stepItem, stepFunction);
 
                    break;
                case Function.HIDE_MODEL:
                    Debug.Log($"case Function.HIDE_MODEL {stepItem.stepID}");
                    ExecuteFunction(new HideModel(), stepItem, stepFunction);
 
                    break;
                case Function.GENERATE_BREAKDOWN:
                    Debug.Log($"case Function:GenerateBreakdown {stepItem.stepID}");
                    ExecuteFunction(new GenerateBreakdown(), stepItem, stepFunction);
                    if (_breakdownDebug != null)
                    {
                        _breakdownDebug.AddBreakdownsInfo(stepFunction);
                    }
 
                    break;
                case Function.SET_DEFAULT_STATE:
                    Debug.Log($"case Function:SetDefaultStateForItem {stepItem.stepID}");
                    ExecuteFunction(new SetDefaultStateForItem(), stepItem, stepFunction);
 
                    break;
                case Function.TURN_ON_OBJECTS:
                    Debug.Log($"case Function.ActivateObject {stepItem.stepID}");
                    ExecuteFunction(new TurnOnObjects(), stepItem, stepFunction);
 
                    break;
                case Function.TURN_OFF_OBJECTS:
                    Debug.Log($"case Function.DeactivateObject {stepItem.stepID}");
                    ExecuteFunction(new TurnOffObjects(), stepItem, stepFunction);
 
                    break;
                case Function.WAITING_FOR_CHOICE:
                    Debug.Log($"case Function.WaitingForChoice {stepItem.stepID}");
                    isWaitForUserChoice = true;
                    ExecuteFunction(new TurnOffObjects(), stepItem, stepFunction);
 
                    break;
                case Function.HIGHLIGHT_ON_SELECTION:
                    Debug.Log($"case Function.HighlightOnSelection {stepItem.stepID}");
                    ExecuteFunction(new HighlightOnSelection(), stepItem, stepFunction);
 
                    break;
                case Function.DELAY:
                    Debug.Log($"case Function.Delay {stepItem.stepID}");
                    ExecuteFunction(new Delay(), stepItem, stepFunction);
                    break;
 
                case Function.SET_VOICE_OVER_VOLUME:
                    Debug.Log($"case Function.SetVoiceOverVolume {stepItem.stepID}");
                    ExecuteFunction(new SetVoiceOverVolume(), stepItem, stepFunction);
                    break;
 
                case Function.SET_FX_VOLUME:
                    Debug.Log($"case Function.Delay {stepItem.stepID}");
                    ExecuteFunction(new SetFxVolume(), stepItem, stepFunction);
                    break;
 
                case Function.CHECK_ALREADY_INSPECTION:
                    Debug.Log($"case Function.CheckAlreadyInspection {stepItem.stepID}");
                    ExecuteFunction(new CheckAlreadyInspection(), stepItem, stepFunction);
                    break;
                
                case Function.SET_TIMER:
                    Debug.Log($"case Function.SET_TIMER {stepItem.stepID}");
                    ExecuteFunction(new SetTimer(), stepItem, stepFunction);
                    break;
                
                case Function.STOP_TIMER:
                    Debug.Log($"case Function.STOP_TIMER {stepItem.stepID}");
                    ExecuteFunction(new StopTimer(), stepItem, stepFunction);
                    break;
                default:
                    break;
            }
        }
 
        private void ExecuteFunction(IStep step, StepItem stepItem, StepFunction function)
        {
            List<InteractableClass> listGameObjects = new List<InteractableClass>();
 
            bool isWaitForDone = function.waitForDone;
 
            foreach (var item in function.itemsForAction)
            {
                listGameObjects.Add(dictionaryOfItems[item]);
            }
 
            EventBetter.Unlisten<TriggeredItemEvent>(this);
 
            if (isWaitForUserChoice)
            {
                EventBetter.Listen(this, (TriggeredItemEvent msg) => RegisterTriggeredItems(msg.item));
            }
 
            else if (isWaitForDone && !_isLastFunctionInStep)
            {
                ++stepId;
                int temp = stepId;
                string tempStepID = _currentStepID;
                Debug.LogError("BEFORE SUBSRIBE STEP_ID " + stepId + " _currentFunctionID:  " + _currentFunctionID);
 
                step.OnFunctionFinished += () =>
                {
                    Debug.LogError(
                        "incremented temp " + temp + " tempStepID:  " + tempStepID
                    );
 
                    if (!_isLastFunctionInStep)
                    {
                        _currentFunctionID += 1;
                        UpdateDebugUI();
                        StartFunction(stepItem);
                    }
                };
            }
 
            else if (stepItem.waitForUserAction && stepItem.nextSteps.Count != 0)
            {
                EventBetter.Listen(this, (TriggeredItemEvent msg) => RegisterTriggeredItems(msg.item));
            }
 
            step.StartStep(stepItem, function, listGameObjects, () => { isWaitForDone = false; });
 
            //TODO
            //CRITICAL step.OnFunctionFinished after startStep
 
            if (_isLastFunctionInStep && stepItem.nextSteps.Count != 0 && !isWaitForUserChoice)
            {
                if (isWaitForDone && !stepItem.waitForUserAction)
                {
                    step.OnFunctionFinished += () =>
                    {
                        StartStep_Function(_stepsData.GetStepItem(stepItem.nextSteps[0]));
                    };
                }
 
                else if (!stepItem.waitForUserAction)
                {
                    StartStep_Function(_stepsData.GetStepItem(stepItem.nextSteps[0]));
                }
            }
 
            else if (!_isLastFunctionInStep && !isWaitForDone && !isWaitForUserChoice)
            {
                _currentFunctionID += 1;
                UpdateDebugUI();
                StartFunction(stepItem);
            }
        }
 
        private void RegisterItems(ItemsEnum item, InteractableClass interactableClass)
        {
            Debug.Log("Registered item : X" + (int)item + "  " + item.ToString(), interactableClass.gameObject);
 
            dictionaryOfItems.Add(item, interactableClass);
        }
 
        private void RegisterTriggeredItems(ItemsEnum item)
        {
            Debug.Log("RegisterClickOnItems  item : " + item);
 
            if (listOfTrigeredItems.Any(x => x == item))
            {
                Debug.LogWarning("Register items is exist");
            }
 
            var stepItem = _stepsData.GetStepItem(_currentStepID);
            var function = stepItem.functionsStep.Last();
            var items = function.itemsForAction;
            var isItemCorrect = items.Any(s => s == item);
            var isFirstItem = items[0] == item;
            listOfTrigeredItems.Add(item);
 
            var itemsID = function.additionalValues;
 
            var isActionAssessment = function.value != String.Empty;
 
            if (!isWaitForUserChoice)
            {
                if (isItemCorrect)
                {
                    var stepId = stepItem.nextSteps[items.IndexOf(item)];
                    var nextStep = _stepsData.GetStepItem(stepId);
                    StartStep_Function(nextStep);
                }
                else if (item == ItemsEnum.SKIP_STEP)
                {
                    var stepId = stepItem.nextSteps[0];
                    var nextStep = _stepsData.GetStepItem(stepId);
                    StartStep_Function(nextStep);
                }
                else
                {
                    if (stepItem.voiceOverIDWrongAction != string.Empty 
                        && !(itemsID.Any(s => s == item.ToString())))
                    {
                        PlayVoiceOverOnceTime(stepItem.voiceOverIDWrongAction);
                    }
                }
 
                if (isItemCorrect && isActionAssessment && _isLastFunctionInStep)
                {
                    SetActionResultInQuiz(function.value, isFirstItem);
                }
            }
            else
            {
                var presentedItem = items.SingleOrDefault(x => x == listOfTrigeredItems.Last());
                bool isChoiceGood = false;
 
                if (presentedItem != null)
                {
                    if (items[0] == listOfTrigeredItems.Last() && listOfTrigeredItems.Count >= 2)
                    {
                        for (int i = 1; i < items.Count; i++)
                        {
                            if (items[i] == listOfTrigeredItems[^2])
                            {
                                isChoiceGood = true;
                                var stepId = stepItem.nextSteps[i - 1];
                                var nextStep = _stepsData.GetStepItem(stepId);
                                StartStep_Function(nextStep);
                            }
                        }
                    }
                }
 
                if (!isChoiceGood && items[0] == listOfTrigeredItems.Last())
                {
                    if (stepItem.voiceOverIDWrongAction != string.Empty)
                    {
                        PlayVoiceOver(stepItem.voiceOverIDWrongAction);
                    }
                }
                else if (!isChoiceGood && presentedItem != null && function.value != String.Empty)
                {
                    var voiceOvers = function.value.Split(new char[] { '#' });
 
                    if (voiceOvers.Length < items.Count)
                    {
                        Debug.Log("You don't have enough parameters, the first one will be used for all!");
                    }
 
                    for (int i = 0; i < items.Count; i++)
                    {
                        if (items[i] == listOfTrigeredItems.Last())
                        {
                            PlayVoiceOver(voiceOvers[i]);
                        }
                    }
                }
 
                if (item == ItemsEnum.SKIP_STEP)
                {
                    var stepId = stepItem.nextSteps[0];
                    var nextStep = _stepsData.GetStepItem(stepId);
                    StartStep_Function(nextStep);
                }
            }
        }
 
        private void PlayVoiceOver(string idVo)
        {
            var voiceOverData = _audioService.GetOverOverData(idVo);
            var guideModeState = StatesService.GetState<GuideModeState>();
 
            if (!guideModeState.IsModeActive)
            {
                if (!voiceOverData.isGuided)
                {
                    _audioService.PlayRepeatable(idVo);
                }
            }
            else
            {
                EventBetter.Raise(
                    new GuideVoiceOverPlayEvent()
                    {
                        VoiceOverName = idVo
                    }
                );
 
                _audioService.PlayRepeatable(idVo);
            }
        }
 
        private void PlayVoiceOverOnceTime(string idVo)
        {
            var voiceOverData = _audioService.GetOverOverData(idVo);
            var guideModeState = StatesService.GetState<GuideModeState>();
 
            if (!guideModeState.IsModeActive)
            {
                if (!voiceOverData.isGuided)
                {
                    _audioService.PauseRepeatable();
                    _audioService.PlayOnceTime(idVo);
                    _audioService.OnceTimeAudioStopped += AudioServiceOnOnceTimeAudioStopped;
                }
            }
            else
            {
                EventBetter.Raise(
                    new GuideVoiceOverPlayEvent()
                    {
                        VoiceOverName = idVo
                    }
                );
                _audioService.PauseRepeatable();
                _audioService.PlayOnceTime(idVo);
                if (!guideModeState.IsSoundEnabled)
                {
                    _audioService.MuteRepeatableSound();
                }
 
                _audioService.OnceTimeAudioStopped += AudioServiceOnOnceTimeAudioStopped;
            }
        }
 
        private void AudioServiceOnOnceTimeAudioStopped(string voID)
        {
            var guideModeState = StatesService.GetState<GuideModeState>();
            
            PlayVoiceOver(voID);
            if (!guideModeState.IsSoundEnabled)
            {
                _audioService.MuteRepeatableSound();
            }
            _audioService.OnceTimeAudioStopped -= AudioServiceOnOnceTimeAudioStopped;
            _audioService.CleanOnceTimeVO();
        }
 
        public void SetActionResultInQuiz(string quizID, bool isActionCorrect)
        {
            var currentQuiz = _quizData.GetQuizItem(quizID);
 
            if (currentQuiz != null)
            {
                var question = currentQuiz.Questions[0];
 
                if (question.GetSelectedAnswer() != String.Empty) return;
 
                var correctAns = question.OptionsAnswers[question.CorrectAnswerID_IfNotBroken[0]];
                question.SetCorrectAnswer(correctAns);
 
                if (isActionCorrect)
                {
                    question.SetSelectedAnswer(correctAns);
                }
                else
                {
                    var inCorrectAns = question.OptionsAnswers[question.CorrectAnswerID_Broken[0]];
                    question.SetSelectedAnswer(inCorrectAns);
                }
            }
        }
 
        public void UpdateDebugUI()
        {
            StepInformationUpdated?.Invoke(_currentStepID, _currentFunctionID);
            _currentStepText.SetText(_currentStepID);
            _currentFunctionText.SetText(_currentFunctionID.ToString());
        }
 
        [ContextMenu("CheckAvailabilityItemsFromScenario")]
        public void CheckAvailability()
        {
            foreach (var step in _stepsData.listOfSteps)
            {
                foreach (var function in step.item.functionsStep)
                {
                    foreach (var item in function.itemsForAction)
                    {
                        if (!dictionaryOfItems.ContainsKey(item))
                        {
                            Debug.Log("Item: " + (int)item + "    " + item.ToString() + " - not registered!");
                        }
                    }
                }
            }
        }
    }
}