using XCEngine;
using XCEngine.Rendering;

namespace XCEngine.Rendering.Universal
{
    public sealed class RenderObjectsRendererFeature
        : ScriptableRendererFeature
    {
        private readonly UniversalRenderObjectsFeatureController
            m_controller =
                new UniversalRenderObjectsFeatureController();

        public RenderPassEvent passEvent =
            RenderPassEvent.AfterRenderingOpaques;
        public SceneRenderPhase scenePhase =
            SceneRenderPhase.Opaque;
        public RendererListType rendererListType =
            RendererListType.Opaque;
        public bool overrideRenderQueueRange;
        public RenderQueueRange renderQueueRange =
            RenderQueueRange.Opaque;
        public bool overrideRenderLayerMask;
        public uint renderLayerMask = uint.MaxValue;
        public string overrideMaterialPath = string.Empty;
        public string shaderPassName = string.Empty;
        public bool overrideRenderStateBlock;
        public RenderStateBlock renderStateBlock;
        public bool overrideFilteringSettings;
        public FilteringSettings filteringSettings;
        public bool overrideSortingSettings;
        public SortingSettings sortingSettings;

        protected override int ComputeRuntimeStateHash()
        {
            int hash =
                base.ComputeRuntimeStateHash();
            return m_controller.AppendRuntimeStateHash(
                hash,
                BuildSettings());
        }

        public override void Create()
        {
            m_controller.Create(
                BuildSettings());
        }

        public override void AddRenderPasses(
            ScriptableRenderer renderer,
            RenderingData renderingData)
        {
            if (renderer == null ||
                renderingData == null)
            {
                return;
            }

            CreateInstance();
            m_controller.EnqueuePass(
                renderer,
                renderingData,
                BuildSettings());
        }

        private RenderObjectsFeatureSettings BuildSettings()
        {
            return new RenderObjectsFeatureSettings
            {
                passEvent = passEvent,
                scenePhase = scenePhase,
                rendererListDesc = BuildRendererListDesc(),
                drawingSettings = BuildDrawingSettings()
            };
        }

        private RendererListDesc BuildRendererListDesc()
        {
            RendererListDesc rendererListDesc =
                RendererListDesc.CreateDefault(
                    rendererListType);
            if (overrideFilteringSettings)
            {
                rendererListDesc.filtering =
                    filteringSettings;
            }

            if (overrideRenderQueueRange)
            {
                rendererListDesc.filtering.renderQueueRange =
                    renderQueueRange;
            }

            if (overrideRenderLayerMask)
            {
                rendererListDesc.filtering.renderLayerMask =
                    renderLayerMask;
            }

            if (overrideSortingSettings)
            {
                rendererListDesc.sorting =
                    sortingSettings;
            }

            return rendererListDesc;
        }

        private DrawingSettings BuildDrawingSettings()
        {
            DrawingSettings drawingSettings =
                DrawingSettings.CreateDefault();
            drawingSettings.overrideMaterialPath =
                overrideMaterialPath ?? string.Empty;
            drawingSettings.shaderPassName =
                shaderPassName ?? string.Empty;
            if (overrideRenderStateBlock)
            {
                drawingSettings.renderStateBlock =
                    renderStateBlock;
            }
            return drawingSettings;
        }
    }
}