using System;
using System.Collections.Generic;
using Sirenix.OdinInspector;
using UnityEngine;

namespace Core
{
    public abstract class EntryPoint : BaseMonoBehaviour
    {
        [SerializeField] [Required] private Transform panelsHolder;
        [SerializeField] [Required] private Transform systemsHolder;
        
        private Dictionary<Type, PanelBase> _panels;
        private Dictionary<Type, SystemBase> _systems;

        private HashSet<ITick> _tickSystems;

        protected override void ReleaseReferences()
        {
            panelsHolder = null;
            systemsHolder = null;
        }

        public void Initialize()
        {
            _systems = new Dictionary<Type, SystemBase>();
            _panels = new Dictionary<Type, PanelBase>();
            _tickSystems = new HashSet<ITick>();
            
            PermanentController.Initialize();
            
            foreach (Transform trSystem in systemsHolder)
            {
                var system = trSystem.gameObject.GetComponent<SystemBase>();
                if (system == null)
                {
                    Debug.LogWarning($"{trSystem.gameObject.name} must inherit from SystemBase");
                    continue;
                }
                
                _systems.Add(system.GetType(), system);
                
                system.Initialize();

                if (system is ITick tick) 
                    _tickSystems.Add(tick);
            }
            
            foreach (Transform trPanel in panelsHolder)
            {
                var panel = trPanel.gameObject.GetComponent<PanelBase>();
                if (panel == null)
                {
                    Debug.LogWarning($"{trPanel.gameObject.name} must inherit from PanelBase");
                    continue;
                }
                _panels.Add(panel.GetType(), panel);
                panel.Initialize();

                // Should be moved along with starting systems?
                // Or switch system initialization prior to panels?
                
                if (panel.AutoEnable)
                {
                    panel.OpenPanelImmediately();
                    continue;
                }
                
                panel.ClosePanelImmediately();
            }
        }

        public void Tick()
        {
            PermanentController.Tick();
            foreach (var system in _tickSystems) 
                system?.Tick();
        }

        public void StartControllers()
        {
            PermanentController.StartControllers();
            foreach (var system in _systems.Values) 
                if (system.AutoStart) system.StartSystem();
        }

        public void OpenDefaultPanels()
        {
            foreach (var panel in _panels.Values) 
                if (panel.AutoEnable) panel.OpenPanelImmediately();
        }
        
        public virtual void Execute() {}
        
        private bool HasSystem<T>() where T : SystemBase => _systems.ContainsKey(typeof(T));
        private bool HasPanel<T>() where T : PanelBase => _panels.ContainsKey(typeof(T));
        
        public T GetSystem<T>() where T : SystemBase
        {
            if (HasSystem<T>()) return (T) _systems[typeof(T)];
            return PermanentController.GetSystem<T>();
        }
        
        public T GetPanel<T>() where T : PanelBase
        {
            if (!HasPanel<T>()) return null;
            return (T) _panels[typeof(T)];
        }
    }
}