using UnityEngine;
using Cinematics;
using Core;
using Core.Lifecycle;
using Data.CardSystem;
using Input;
using PuzzleS;

namespace AppleHills.Core
{
    /// <summary>
    /// Provides quick access to frequently used game objects, components, and manager instances.
    /// References are cached for performance and automatically invalidated on scene changes.
    /// </summary>
    public class QuickAccess : ManagedBehaviour
    {
        #region Singleton Setup
		private static QuickAccess _instance;
        
        /// <summary>
        /// Singleton instance of QuickAccess. No longer creates an instance if one doesn't exist.
        /// </summary>
        public static QuickAccess Instance => _instance;

		#endregion Singleton Setup
        
        #region Manager Instances

        // Core Managers
        public GameManager GameManager => GameManager.Instance;
        public ItemManager ItemManager => ItemManager.Instance;
        public SceneManagerService SceneManager => SceneManagerService.Instance;
        
        // Other Managers
        public InputManager InputManager => InputManager.Instance;
        public PuzzleManager PuzzleManager => PuzzleManager.Instance;
        public CinematicsManager CinematicsManager => CinematicsManager.Instance;
        public CardSystemManager CardSystemManager => CardSystemManager.Instance;

        #endregion

        #region Player and Follower References

        private GameObject _playerGameObject;
        private GameObject _followerGameObject;
        private PlayerTouchController _playerController;
        private FollowerController _followerController;
        private Camera _mainCamera;

        /// <summary>
        /// Returns the player GameObject. Finds it if not already cached.
        /// </summary>
        public GameObject PlayerGameObject
        {
            get
            {
                if (_playerGameObject == null)
                {
                    _playerGameObject = GameObject.FindGameObjectWithTag("Player");
                }
                return _playerGameObject;
            }
        }

        /// <summary>
        /// Returns the follower (Pulver) GameObject. Finds it if not already cached.
        /// </summary>
        public GameObject FollowerGameObject
        {
            get
            {
                if (_followerGameObject == null)
                {
                    _followerGameObject = GameObject.FindGameObjectWithTag("Pulver");
                }
                return _followerGameObject;
            }
        }

        /// <summary>
        /// Returns the player controller component. Finds it if not already cached.
        /// </summary>
        public PlayerTouchController PlayerController
        {
            get
            {
                if (_playerController == null && PlayerGameObject != null)
                {
                    _playerController = PlayerGameObject.GetComponent<PlayerTouchController>();
                }
                return _playerController;
            }
        }

        /// <summary>
        /// Returns the follower controller component. Finds it if not already cached.
        /// </summary>
        public FollowerController FollowerController
        {
            get
            {
                if (_followerController == null && FollowerGameObject != null)
                {
                    _followerController = FollowerGameObject.GetComponent<FollowerController>();
                }
                return _followerController;
            }
        }

        /// <summary>
        /// Returns the main camera. Caches for performance.
        /// </summary>
        public Camera MainCamera
        {
            get
            {
                if (_mainCamera == null)
                {
                    _mainCamera = Camera.main;
                }
                return _mainCamera;
            }
        }

        #endregion

        #region Lifecycle Methods

        internal override void OnManagedAwake()
        {
            // Set instance immediately (early initialization)
            _instance = this;
        }

        internal override void OnManagedStart()
        {
            // QuickAccess has minimal initialization
        }

        internal override void OnSceneUnloading()
        {
            // Clear references BEFORE scene unloads for better cleanup timing
            ClearReferences();
        }

        #endregion

        #region Reference Management

        /// <summary>
        /// Clear all cached references.
        /// </summary>
        public void ClearReferences()
        {
            _playerGameObject = null;
            _followerGameObject = null;
            _playerController = null;
            _followerController = null;
            _mainCamera = null;
        }

        #endregion
    }
}