namespace XCEngine
{
    internal sealed class ForwardSceneInjectionPass : ScriptableRenderPass
    {
        private readonly SceneRenderInjectionPoint m_injectionPoint;

        public ForwardSceneInjectionPass(
            RenderPassEvent passEvent,
            SceneRenderInjectionPoint injectionPoint)
        {
            renderPassEvent = passEvent;
            m_injectionPoint = injectionPoint;
        }

        protected override bool RecordRenderGraph(
            ScriptableRenderContext context,
            RenderingData renderingData)
        {
            return context != null &&
                   renderingData != null &&
                   renderingData.isMainSceneStage &&
                   context.RecordSceneInjectionPoint(m_injectionPoint);
        }
    }

    internal sealed class ForwardScenePhasePass : ScriptableRenderPass
    {
        private readonly ScenePhase m_scenePhase;

        public ForwardScenePhasePass(
            RenderPassEvent passEvent,
            ScenePhase scenePhase)
        {
            renderPassEvent = passEvent;
            m_scenePhase = scenePhase;
        }

        protected override bool RecordRenderGraph(
            ScriptableRenderContext context,
            RenderingData renderingData)
        {
            return context != null &&
                   renderingData != null &&
                   renderingData.isMainSceneStage &&
                   context.RecordScenePhase(m_scenePhase);
        }
    }

    internal sealed class ForwardSceneFeature : ScriptableRendererFeature
    {
        private readonly ForwardRendererData m_rendererData;
        private readonly ForwardSceneInjectionPass m_beforeOpaquePass =
            new ForwardSceneInjectionPass(
                RenderPassEvent.BeforeRenderingOpaques,
                SceneRenderInjectionPoint.BeforeOpaque);
        private readonly ForwardScenePhasePass m_opaquePass =
            new ForwardScenePhasePass(
                RenderPassEvent.RenderOpaques,
                ScenePhase.Opaque);
        private readonly ForwardSceneInjectionPass m_afterOpaquePass =
            new ForwardSceneInjectionPass(
                RenderPassEvent.AfterRenderingOpaques,
                SceneRenderInjectionPoint.AfterOpaque);
        private readonly ForwardSceneInjectionPass m_beforeSkyboxPass =
            new ForwardSceneInjectionPass(
                RenderPassEvent.BeforeRenderingSkybox,
                SceneRenderInjectionPoint.BeforeSkybox);
        private readonly ForwardScenePhasePass m_skyboxPass =
            new ForwardScenePhasePass(
                RenderPassEvent.RenderSkybox,
                ScenePhase.Skybox);
        private readonly ForwardSceneInjectionPass m_afterSkyboxPass =
            new ForwardSceneInjectionPass(
                RenderPassEvent.AfterRenderingSkybox,
                SceneRenderInjectionPoint.AfterSkybox);
        private readonly ForwardSceneInjectionPass m_beforeTransparentPass =
            new ForwardSceneInjectionPass(
                RenderPassEvent.BeforeRenderingTransparents,
                SceneRenderInjectionPoint.BeforeTransparent);
        private readonly ForwardScenePhasePass m_transparentPass =
            new ForwardScenePhasePass(
                RenderPassEvent.RenderTransparents,
                ScenePhase.Transparent);
        private readonly ForwardSceneInjectionPass m_afterTransparentPass =
            new ForwardSceneInjectionPass(
                RenderPassEvent.AfterRenderingTransparents,
                SceneRenderInjectionPoint.AfterTransparent);

        public ForwardSceneFeature(
            ForwardRendererData rendererData)
        {
            m_rendererData = rendererData;
        }

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

            if (m_rendererData.renderOpaque)
            {
                renderer.EnqueuePass(m_beforeOpaquePass);
                renderer.EnqueuePass(m_opaquePass);
                renderer.EnqueuePass(m_afterOpaquePass);
            }

            if (m_rendererData.renderSkybox)
            {
                renderer.EnqueuePass(m_beforeSkyboxPass);
                renderer.EnqueuePass(m_skyboxPass);
                renderer.EnqueuePass(m_afterSkyboxPass);
            }

            if (m_rendererData.renderTransparent)
            {
                renderer.EnqueuePass(m_beforeTransparentPass);
                renderer.EnqueuePass(m_transparentPass);
                renderer.EnqueuePass(m_afterTransparentPass);
            }
        }
    }

    public sealed class ForwardRenderer : ScriptableRenderer
    {
        public ForwardRenderer(
            ForwardRendererData rendererData)
        {
            ForwardRendererData resolvedData =
                rendererData ?? new ForwardRendererData();
            AddFeature(new ForwardSceneFeature(resolvedData));

            ScriptableRendererFeature[] rendererFeatures =
                resolvedData.CreateRendererFeaturesInstance();
            for (int i = 0; i < rendererFeatures.Length; ++i)
            {
                AddFeature(rendererFeatures[i]);
            }
        }
    }
}