using System;
using System.Collections.Generic;
using System.Reflection;
using UnityEngine.Rendering.RenderGraphModule;

namespace UnityEngine.Rendering
{
    /// <summary>
    /// The UI implementation for a debug settings panel
    /// </summary>
    public class DebugDisplaySettingsUI : IDebugData
    {
        private IEnumerable<IDebugDisplaySettingsPanelDisposable> m_DisposablePanels;
        private IDebugDisplaySettings m_Settings;

        private void Reset()
        {
            if (m_Settings != null)
            {
                m_Settings.Reset();
                ReregisterDebugPanels();
            }
        }

        /// <summary>
        /// Unregisters and re-registers all DebugUI panels associated with the current <see cref="ISerializedDebugDisplaySettings"/>.
        /// This effectively rebuilds the debug panel hierarchy without touching the Rendering Debugger window state itself.
        /// </summary>
        void ReregisterDebugPanels()
        {
            // TODO: Tear the UI down and re-create it for now - this is horrible, so reset it instead.
            UnregisterDebug();
            RegisterDebug(m_Settings);
        }

        /// <summary>
        /// Register a display for the UI
        /// </summary>
        /// <param name="settings"><see cref="IDebugDisplaySettings"/> to be registered</param>
        public void RegisterDebug(IDebugDisplaySettings settings)
        {
            DebugManager.instance.RegisterData(this);
            DebugManager.instance.onRecreateDebugUI += ReregisterDebugPanels;
            m_Settings = settings;
            m_Settings.Add(new DebugDisplaySettingsRenderGraph());

            // Don't initialize the UI immediately to avoid unnecessary work at pipeline init time. Instaed,
            // initialize UI when any debug UI is opened (or if the editor window is already open)
            DebugManager.windowStateChanged += DebugUIOpened;
            if (DebugManager.instance.isAnyDebugUIActive)
                InitializeDebugUI();
        }

        void DebugUIOpened(DebugManager.UIMode uiMode, bool isOpen)
        {
            InitializeDebugUI();
        }

        internal void InitializeDebugUI()
        {
            if (m_DisposablePanels == null)
            {
                var panels = new List<IDebugDisplaySettingsPanelDisposable>();

                Action<IDebugDisplaySettingsData> onExecute = (data) =>
                {
                    IDebugDisplaySettingsPanelDisposable disposableSettingsPanel = data.CreatePanel();

                    DebugUI.Widget[] panelWidgets = disposableSettingsPanel.Widgets;

                    DebugUI.Panel panel = DebugManager.instance.GetPanel(
                        displayName: disposableSettingsPanel.PanelName,
                        createIfNull: true,
                        groupIndex: (disposableSettingsPanel is DebugDisplaySettingsPanel debugDisplaySettingsPanel) ? debugDisplaySettingsPanel.Order : 0);

#if UNITY_EDITOR
                    if (DocumentationUtils.TryGetHelpURL(disposableSettingsPanel.GetType(), out var documentationUrl))
                        panel.documentationUrl = documentationUrl;
#endif

                    ObservableList<DebugUI.Widget> panelChildren = panel.children;

                    panel.flags = disposableSettingsPanel.Flags;
                    panels.Add(disposableSettingsPanel);

                    panelChildren.Add(panelWidgets);
                };

                m_Settings.ForEach(onExecute);
                m_DisposablePanels = panels;

                DebugDisplaySerializer.LoadFoldoutStates();
            }
        }

        /// <summary>
        /// Unregister the debug panels
        /// </summary>
        public void UnregisterDebug()
        {
            DebugDisplaySerializer.SaveFoldoutStates();

            DebugManager debugManager = DebugManager.instance;

            if (m_DisposablePanels != null)
            {
                foreach (IDebugDisplaySettingsPanelDisposable disposableSettingsPanel in m_DisposablePanels)
                {
                    DebugUI.Widget[] panelWidgets = disposableSettingsPanel.Widgets;
                    string panelId = disposableSettingsPanel.PanelName;
                    DebugUI.Panel panel = debugManager.GetPanel(panelId, true);

                    ObservableList<DebugUI.Widget> panelChildren = panel.children;

                    disposableSettingsPanel.Dispose();
                    panelChildren.Remove(panelWidgets);
                }

                m_DisposablePanels = null;
            }

            debugManager.UnregisterData(this);
            debugManager.onRecreateDebugUI -= ReregisterDebugPanels;

            DebugManager.windowStateChanged -= DebugUIOpened;
        }

        #region IDebugData

        /// <summary>
        /// The reset action to be executed when a Reset of the rendering debugger is need
        /// </summary>
        /// <returns>A <see cref="Action"/> with the restet callback</returns>
        public Action GetReset()
        {
            return Reset;
        }

        #endregion
    }
}