using XCEngine;

namespace XCEngine.Rendering
{
    // SRP v1 managed recording surface. Scene draws still delegate 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));

        internal bool RecordScene()
        {
            return DrawOpaqueRenderers() &&
                   DrawSkybox() &&
                   DrawTransparentRenderers();
        }

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

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

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

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

        public bool DrawRenderers(
            RendererListDesc rendererListDesc,
            DrawingSettings drawingSettings)
        {
            return DrawRenderers(
                ResolveSceneRenderPhase(rendererListDesc),
                rendererListDesc,
                drawingSettings);
        }

        internal 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 DrawSkybox()
        {
            return RecordScenePhase(
                SceneRenderPhase.Skybox);
        }

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

        public bool DrawTransparentRenderers()
        {
            return DrawRenderers(
                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));
        }

        // Public RenderGraph raster authoring entry point. Built-in fullscreen
        // kernels are internal URP implementation details, not public context
        // shortcuts.
        public RenderGraphRasterPassBuilder AddRasterPass(
            string passName)
        {
            return new RenderGraphRasterPassBuilder(
                this,
                passName);
        }

        internal ulong nativeHandle =>
            m_nativeHandle;

        private static SceneRenderPhase ResolveSceneRenderPhase(
            RendererListDesc rendererListDesc)
        {
            switch (rendererListDesc.type)
            {
                case RendererListType.Transparent:
                    return SceneRenderPhase.Transparent;
                case RendererListType.Opaque:
                case RendererListType.ShadowCaster:
                case RendererListType.AllVisible:
                default:
                    return SceneRenderPhase.Opaque;
            }
        }
    }
}