using UnityEngine;
using Eflatun.SceneReference;
using System.Collections.Generic;
using UnityEngine.SceneManagement;
using UnityEngine.InputSystem;
using System;
public class TimelineSceneSequencer : MonoBehaviour
{
    public enum SequenceState { Loading, Ready, Playing, Stopped, Complete, NOT_AVAILABLE}
    [SerializeField]
    private SequenceStateGlobalVariable _localSequenceState;
    [SerializeField]
    private List<SceneReference> _scenesInOrder;
    [SerializeField]
    private bool _debug_start_delayed = false;
    [SerializeField]
    private float _debug_delay_seconds = 3.0f;
    private float _delayStartTimer = 0.0f;
#if UNITY_EDITOR
    [SerializeField]
    private InputAction _debugStartInput;
#endif
    private MysticLibraryModeLoader _modeLoader;
    private int _sceneLoadedCount = 0;
    private int _sceneUnLoadedCount = 0;
    private int _expectedSceneCount = -1;
    private bool _allTimelinesLoaded = false;
    private List<RemoteTimeline> _remoteTimelinesInOrder;
    private int _nextTimelineIndex = 0;
    private RemoteTimeline _currentTimeline;
    public Action OnRemoteTimelinesReady;
    private void Awake()
    {
#if UNITY_EDITOR
        _debugStartInput.Enable();
#endif
        _modeLoader = FindFirstObjectByType<MysticLibraryModeLoader>();
        _expectedSceneCount = _scenesInOrder.Count;
        _remoteTimelinesInOrder = new List<RemoteTimeline>(_expectedSceneCount);
    }
    private void Start()
    {
        bool isOperationsMode = _modeLoader.ActiveMode == MysticLibraryModeLoader.MysticLibraryMode.Operations;
        if (isOperationsMode)
            return; //in operations mode, we only need the UI in that scene and networking to communicate with headsets, not the Mystic VR experience itself
        else if (_modeLoader.ActiveModeIsLoaded)
            LoadTimelineScenesAsync();
        else
            _modeLoader.OnActiveModeSceneLoaded += LoadTimelineScenesAsync;
    }
    private void Update()
    {
        //DEBUG
        if (_debug_start_delayed == true)
        {
            _delayStartTimer += Time.deltaTime;
            if (_delayStartTimer >= _debug_delay_seconds && _localSequenceState.GlobalValue == SequenceState.Ready)
            {
                _debug_start_delayed = false;
                PlayNextTimeline();
            }
        }
#if UNITY_EDITOR
        if (_debugStartInput.IsPressed() && _allTimelinesLoaded && _localSequenceState.GlobalValue == SequenceState.Ready)
        {
            Debug.Log("Debug start: beginning sequence.");
            PlayNextTimeline();
        }
#endif
        //if all scenes have been loaded, get all remote timelines & let listeners know when they are ready
        if (_allTimelinesLoaded == false && _sceneLoadedCount == _expectedSceneCount)
        {
            _allTimelinesLoaded = true;
            foreach (var sceneRef in _scenesInOrder)
            {
                RemoteTimeline remoteTimeline = GetRemoteTimeline(sceneRef.LoadedScene);
                remoteTimeline.Prewarm();
                _remoteTimelinesInOrder.Add(remoteTimeline);
            }
            _localSequenceState.GlobalValue = SequenceState.Ready;
            OnRemoteTimelinesReady?.Invoke();
        }
    }
    public void PlayNextTimeline()
    {
        if (_currentTimeline != null)
        {
            _currentTimeline.OnEnableNextTimeline -= EnableNextTimeline;
            _currentTimeline.OnRemoteTimelineComplete -= CurrentTimelineCompleted;
        }
        if (_nextTimelineIndex < _remoteTimelinesInOrder.Count)
        {
            if (_localSequenceState.GlobalValue != SequenceState.Playing)
                _localSequenceState.GlobalValue = SequenceState.Playing;
            _currentTimeline = _remoteTimelinesInOrder[_nextTimelineIndex];
            _nextTimelineIndex++;
            _currentTimeline.OnEnableNextTimeline += EnableNextTimeline;
            _currentTimeline.OnRemoteTimelineComplete += CurrentTimelineCompleted;
            _currentTimeline.PlayTimeline();
            Debug.Log("playing: " + _currentTimeline.gameObject.name);
        }
        else
        {
            Debug.Log("experience complete");
            _localSequenceState.GlobalValue = SequenceState.Complete;
            _nextTimelineIndex = 0;
            UnloadAllTimelineScenesAsync();
        }
        void EnableNextTimeline()
        {
            if (_nextTimelineIndex < _remoteTimelinesInOrder.Count)
            {
                _remoteTimelinesInOrder[_nextTimelineIndex].EnableTimeline();
            }
        }
        void CurrentTimelineCompleted()
        {
            PlayNextTimeline();
        }
    }
    private void LoadTimelineScenesAsync()
    {
        //If this was called from the mode loader event invocation, unsubscribe (safe to do this if it was not called from the event)
        _modeLoader.OnActiveModeSceneLoaded -= LoadTimelineScenesAsync;
        foreach (SceneReference sceneRef in _scenesInOrder)
        {
#if UNITY_EDITOR
            if (sceneRef.LoadedScene.isLoaded)
            {
                Debug.Log(sceneRef.Name + " was detected in editor. Skipping loading phase.");
                _sceneLoadedCount++;
                continue;
            }
#endif
            var asyncOperationHandle = SceneManager.LoadSceneAsync(sceneRef.BuildIndex, LoadSceneMode.Additive);
            asyncOperationHandle.completed += AsyncLoadComplete;
        }
        void AsyncLoadComplete(AsyncOperation operationHandle)
        {
            operationHandle.completed -= AsyncLoadComplete;
            _sceneLoadedCount++;
        }
    }
    private void UnloadAllTimelineScenesAsync()
    {
        _remoteTimelinesInOrder.Clear();
        _allTimelinesLoaded = false;
        _sceneUnLoadedCount = 0;
        _sceneLoadedCount = 0;
        foreach (SceneReference sceneRef in _scenesInOrder)
        {
            var asyncOperationHandle = SceneManager.UnloadSceneAsync(sceneRef.BuildIndex);
            asyncOperationHandle.completed += AsyncUnLoadComplete;
        }
        void AsyncUnLoadComplete(AsyncOperation operationHandle)
        {
            operationHandle.completed -= AsyncUnLoadComplete;
            _sceneUnLoadedCount++;
            if (_sceneUnLoadedCount == _expectedSceneCount)
            {
                Debug.Log("unload complete. loading fresh scenes.");
                LoadTimelineScenesAsync();
            }
        }
    }
    private RemoteTimeline GetRemoteTimeline(Scene loadedScene)
    {
        RemoteTimeline remoteTimelineInstance = null;
        GameObject[] rootGameObjects = loadedScene.GetRootGameObjects();
        for (int i = 0; i < rootGameObjects.Length; i++)
        {
            GameObject rootGameObj = rootGameObjects[i];
            remoteTimelineInstance = rootGameObj.GetComponent<RemoteTimeline>();
            if (remoteTimelineInstance != null)
                return remoteTimelineInstance;
        }
        throw new System.Exception("unable to locate a remote timeline on a root gameobject in scene: " + loadedScene.name);
    }
}