using XCEngine;

namespace XCEngine.Rendering
{
    // SRP v1 managed recording surface. Scene draws still delegate to the
    // native SceneDrawBackend; RenderGraph raster authoring can record scene
    // and fullscreen stages through the Unity-style managed surface.
    public sealed class ScriptableRenderContext
    {
        private readonly ulong m_nativeHandle;

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

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

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

        internal ulong framePlanId =>
            InternalCalls
                .Rendering_ScriptableRenderContext_GetFramePlanId(
                    m_nativeHandle);

        internal string passName =>
            InternalCalls
                .Rendering_ScriptableRenderContext_GetPassName(
                    m_nativeHandle) ?? string.Empty;

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

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

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

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

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

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

        internal RendererListHandle CreateRendererList(
            RendererListDesc rendererListDesc,
            DrawingSettings drawingSettings)
        {
            RenderStateBlock renderStateBlock =
                drawingSettings.renderStateBlock;
            return RendererListHandle.FromNativeIndex(
                InternalCalls
                    .Rendering_ScriptableRenderContext_CreateRendererList(
                        m_nativeHandle,
                        ref rendererListDesc,
                        drawingSettings.overrideMaterialPath ??
                            string.Empty,
                        drawingSettings.shaderPassName ?? string.Empty,
                        ref renderStateBlock));
        }

        // Internal backing entry point for public RenderGraph raster authoring.
        // Built-in fullscreen kernels are URP implementation details, not
        // public context shortcuts.
        internal 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;
            }
        }
    }
}