using XCEngine;
using XCEngine.Rendering;

namespace XCEngine.Rendering.Universal
{
    public sealed class RenderObjectsRendererFeature
        : ScriptableRendererFeature
    {
        private DrawObjectsPass m_pass;

        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();
            hash =
                RuntimeStateHashUtility.Combine(
                    hash,
                    (int)passEvent);
            hash =
                RuntimeStateHashUtility.Combine(
                    hash,
                    (int)scenePhase);
            hash =
                RuntimeStateHashUtility.Combine(
                    hash,
                    (int)rendererListType);
            hash =
                RuntimeStateHashUtility.Combine(
                    hash,
                    overrideRenderQueueRange);
            hash =
                RuntimeStateHashUtility.Combine(
                    hash,
                    renderQueueRange);
            hash =
                RuntimeStateHashUtility.Combine(
                    hash,
                    overrideRenderLayerMask);
            hash =
                RuntimeStateHashUtility.Combine(
                    hash,
                    renderLayerMask);
            hash =
                RuntimeStateHashUtility.Combine(
                    hash,
                    overrideMaterialPath);
            hash =
                RuntimeStateHashUtility.Combine(
                    hash,
                    shaderPassName);
            hash =
                RuntimeStateHashUtility.Combine(
                    hash,
                    overrideRenderStateBlock);
            hash =
                RuntimeStateHashUtility.Combine(
                    hash,
                    renderStateBlock);
            hash =
                RuntimeStateHashUtility.Combine(
                    hash,
                    overrideFilteringSettings);
            hash =
                RuntimeStateHashUtility.Combine(
                    hash,
                    filteringSettings);
            hash =
                RuntimeStateHashUtility.Combine(
                    hash,
                    overrideSortingSettings);
            hash =
                RuntimeStateHashUtility.Combine(
                    hash,
                    sortingSettings);
            return hash;
        }

        public override void Create()
        {
            RendererListDesc rendererListDesc =
                BuildRendererListDesc();
            DrawingSettings drawingSettings =
                BuildDrawingSettings();
            if (m_pass == null)
            {
                m_pass =
                    new DrawObjectsPass(
                        passEvent,
                        scenePhase,
                        rendererListDesc,
                        drawingSettings);
                return;
            }

            m_pass.Configure(
                passEvent,
                scenePhase,
                rendererListDesc,
                drawingSettings);
        }

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

            CreateInstance();

            m_pass.Configure(
                passEvent,
                scenePhase,
                BuildRendererListDesc(),
                BuildDrawingSettings());
            UniversalMainSceneFeatureUtility.EnqueuePass(
                renderer,
                renderingData,
                m_pass);
        }

        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;
        }
    }
}