using XCEngine;

namespace XCEngine.Rendering
{
    // SRP v1 managed recording surface. Scene recording still delegates to the
    // native SceneDrawBackend, and raster-pass recording is limited to the
    // fullscreen PostProcess / FinalOutput stages.
    public sealed class ScriptableRenderContext
    {
        private readonly ulong m_nativeHandle;

        internal ScriptableRenderContext(ulong nativeHandle)
        {
            m_nativeHandle = nativeHandle;
        }

        public CameraFrameStage stage =>
            (CameraFrameStage)InternalCalls.Rendering_ScriptableRenderContext_GetStage(
                m_nativeHandle);

        public int rendererIndex =>
            InternalCalls
                .Rendering_ScriptableRenderContext_GetRendererIndex(
                    m_nativeHandle);

        public RenderGraphTextureHandle sourceColorTexture =>
            RenderGraphTextureHandle.FromNativeIndex(
                InternalCalls
                    .Rendering_ScriptableRenderContext_GetSourceColorTextureHandle(
                        m_nativeHandle));

        public RenderGraphTextureHandle primaryColorTarget =>
            RenderGraphTextureHandle.FromNativeIndex(
                InternalCalls
                    .Rendering_ScriptableRenderContext_GetPrimaryColorTargetHandle(
                        m_nativeHandle));

        public RenderGraphTextureHandle depthTarget =>
            RenderGraphTextureHandle.FromNativeIndex(
                InternalCalls
                    .Rendering_ScriptableRenderContext_GetDepthTargetHandle(
                        m_nativeHandle));

        // Records the default native scene sequence for MainScene or explicit
        // scene-pass-request stages. This does not replace the native scene
        // extraction / culling / draw backend.
        public bool RecordScene()
        {
            return RecordBeforeOpaqueInjection() &&
                   DrawOpaqueRenderers() &&
                   RecordAfterOpaqueInjection() &&
                   RecordBeforeSkyboxInjection() &&
                   DrawSkybox() &&
                   RecordAfterSkyboxInjection() &&
                   RecordBeforeTransparentInjection() &&
                   DrawTransparentRenderers() &&
                   RecordAfterTransparentInjection();
        }

        public bool RecordScenePhase(
            SceneRenderPhase scenePhase)
        {
            return InternalCalls
                .Rendering_ScriptableRenderContext_RecordScenePhase(
                    m_nativeHandle,
                    (int)scenePhase);
        }

        public bool RecordSceneInjectionPoint(
            SceneRenderInjectionPoint injectionPoint)
        {
            return InternalCalls
                .Rendering_ScriptableRenderContext_RecordSceneInjectionPoint(
                    m_nativeHandle,
                    (int)injectionPoint);
        }

        public bool RecordNativeSceneFeaturePass(
            NativeSceneFeaturePassId featurePassId)
        {
            return featurePassId !=
                       NativeSceneFeaturePassId.Invalid &&
                   InternalCalls
                       .Rendering_ScriptableRenderContext_RecordNativeSceneFeaturePass(
                           m_nativeHandle,
                           (int)featurePassId);
        }

        public bool DrawRenderers(
            SceneRenderPhase scenePhase,
            RendererListType rendererListType)
        {
            return DrawRenderers(
                scenePhase,
                rendererListType,
                DrawingSettings.CreateDefault());
        }

        public bool DrawRenderers(
            SceneRenderPhase scenePhase,
            RendererListType rendererListType,
            DrawingSettings drawingSettings)
        {
            return DrawRenderers(
                scenePhase,
                RendererListDesc.CreateDefault(
                    rendererListType),
                drawingSettings);
        }

        public bool DrawRenderers(
            SceneRenderPhase scenePhase,
            RendererListDesc rendererListDesc)
        {
            return DrawRenderers(
                scenePhase,
                rendererListDesc,
                DrawingSettings.CreateDefault());
        }

        public bool DrawRenderers(
            SceneRenderPhase scenePhase,
            RendererListDesc rendererListDesc,
            DrawingSettings drawingSettings)
        {
            RenderStateBlock renderStateBlock =
                drawingSettings.renderStateBlock;
            return InternalCalls
                .Rendering_ScriptableRenderContext_DrawRenderersByDesc(
                    m_nativeHandle,
                    (int)scenePhase,
                    ref rendererListDesc,
                    drawingSettings.overrideMaterialPath ??
                        string.Empty,
                    drawingSettings.shaderPassName ??
                        string.Empty,
                    ref renderStateBlock);
        }

        public bool RecordOpaqueScenePhase()
        {
            return RecordScenePhase(
                SceneRenderPhase.Opaque);
        }

        public bool RecordSkyboxScenePhase()
        {
            return RecordScenePhase(
                SceneRenderPhase.Skybox);
        }

        public bool DrawSkybox()
        {
            return RecordScenePhase(
                SceneRenderPhase.Skybox);
        }

        public bool RecordTransparentScenePhase()
        {
            return RecordScenePhase(
                SceneRenderPhase.Transparent);
        }

        public bool RecordBeforeOpaqueInjection()
        {
            return RecordSceneInjectionPoint(
                SceneRenderInjectionPoint.BeforeOpaque);
        }

        public bool RecordAfterOpaqueInjection()
        {
            return RecordSceneInjectionPoint(
                SceneRenderInjectionPoint.AfterOpaque);
        }

        public bool RecordBeforeSkyboxInjection()
        {
            return RecordSceneInjectionPoint(
                SceneRenderInjectionPoint.BeforeSkybox);
        }

        public bool RecordAfterSkyboxInjection()
        {
            return RecordSceneInjectionPoint(
                SceneRenderInjectionPoint.AfterSkybox);
        }

        public bool RecordBeforeTransparentInjection()
        {
            return RecordSceneInjectionPoint(
                SceneRenderInjectionPoint.BeforeTransparent);
        }

        public bool RecordAfterTransparentInjection()
        {
            return RecordSceneInjectionPoint(
                SceneRenderInjectionPoint.AfterTransparent);
        }

        public bool DrawOpaqueRenderers()
        {
            return DrawRenderers(
                SceneRenderPhase.Opaque,
                RendererListDesc.CreateDefault(
                    RendererListType.Opaque));
        }

        public bool DrawTransparentRenderers()
        {
            return DrawRenderers(
                SceneRenderPhase.Transparent,
                RendererListDesc.CreateDefault(
                    RendererListType.Transparent));
        }

        public RenderGraphTextureHandle CreateTransientTexture(
            string name,
            RenderGraphTextureDesc desc)
        {
            return RenderGraphTextureHandle.FromNativeIndex(
                InternalCalls
                    .Rendering_ScriptableRenderContext_CreateTransientTexture(
                        m_nativeHandle,
                        name,
                        ref desc));
        }

        public RenderGraphTextureHandle
        CreateFullscreenTransientColorTexture(
            string name)
        {
            return RenderGraphTextureHandle.FromNativeIndex(
                InternalCalls
                    .Rendering_ScriptableRenderContext_CreateFullscreenTransientColorTexture(
                        m_nativeHandle,
                        name));
        }

        public RenderGraphTextureHandle
        CreateFullscreenTransientDepthTexture(
            string name)
        {
            return RenderGraphTextureHandle.FromNativeIndex(
                InternalCalls
                    .Rendering_ScriptableRenderContext_CreateFullscreenTransientDepthTexture(
                        m_nativeHandle,
                        name));
        }

        // SRP v1 wrapper over managed fullscreen raster requests. Commit only
        // succeeds on fullscreen sequence stages and the execution kinds remain
        // limited to the built-in fullscreen pass family.
        public RenderGraphRasterPassBuilder AddRasterPass(
            string passName)
        {
            return new RenderGraphRasterPassBuilder(
                this,
                passName);
        }

        internal ulong nativeHandle =>
            m_nativeHandle;
    }
}