using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Rendering;
using UnityEngine.Rendering.Universal;

public class UIRenderPass : ScriptableRenderPass
{
    // プロファイリング用サンプラー
    private readonly ProfilingSampler _uiBlurBelowSampler = new ProfilingSampler("UIBlurBelow");
    private readonly ProfilingSampler _uiDefaultSampler = new ProfilingSampler("UIDefault");
    private readonly ProfilingSampler _uiBlurAboveSampler = new ProfilingSampler("UIBlurAbove");
    private readonly ProfilingSampler _captureAndBlurSampler = new ProfilingSampler("CaptureAndBlur");
    private readonly ProfilingSampler _blurSampler = new ProfilingSampler("Blur");

    // シェーダー用定数（プロパティIDやRT名）
    public static class ShaderID
    {
        public static readonly int SimpleBlurParams = Shader.PropertyToID("_SimpleBlurParams");
        public static readonly int SourceTex = Shader.PropertyToID("_SourceTex");
        public static readonly int BlurCaptureTex = Shader.PropertyToID("_BlurCaptureTex");

        public static readonly string BlurCaptureRTName = "BlurCaptureRT";
        public static readonly string TemporaryBlurRT1Name = "TemporaryBlurRT1";
        public static readonly string TemporaryBlurRT2Name = "TemporaryBlurRT2";
        public static readonly string TemporaryBlurRT3Name = "TemporaryBlurRT3";
    }

    private Material _blurMaterial;
    private RenderStateBlock _stateBlock;
    private FilteringSettings _belowFilteringSettings;
    private FilteringSettings _defaultFilteringSettings;
    private FilteringSettings _aboveFilteringSettings;
    private List<ShaderTagId> _shaderTagIds;

    // 一時レンダーターゲット
    private RTHandle _blurCaptureRT;
    private RTHandle _blurTemporaryRT1;
    private RTHandle _blurTemporaryRT2;
    private RTHandle _blurTemporaryRT3;

    // ブラーに関するパラメータ
    private float _blurBlendRate;
    private float _blurSize;
    private float _blurRenderScale;
    private bool _isExecBlur;
    private bool _isExecGlassMorphism;

    public UIRenderPass(Material blurMaterial, LayerMask layerMask)
    {
        renderPassEvent = RenderPassEvent.AfterRenderingPostProcessing;
        _blurMaterial = blurMaterial;

        // 各UI層に対応するフィルタリング設定の生成
        _belowFilteringSettings = new FilteringSettings(RenderQueueRange.transparent, layerMask);
        short belowSortingLayer = (short)SortingLayer.GetLayerValueFromName("UIBlurBelow");
        _belowFilteringSettings.sortingLayerRange = new SortingLayerRange(belowSortingLayer, belowSortingLayer);

        _defaultFilteringSettings = new FilteringSettings(RenderQueueRange.transparent, layerMask);
        short defaultSortingLayer = (short)SortingLayer.GetLayerValueFromName("Default");
        _defaultFilteringSettings.sortingLayerRange = new SortingLayerRange(defaultSortingLayer, defaultSortingLayer);

        _aboveFilteringSettings = new FilteringSettings(RenderQueueRange.transparent, layerMask);
        short aboveSortingLayer = (short)SortingLayer.GetLayerValueFromName("UIBlurAbove");
        _aboveFilteringSettings.sortingLayerRange = new SortingLayerRange(aboveSortingLayer, aboveSortingLayer);

        _stateBlock = new RenderStateBlock();

        _shaderTagIds = new List<ShaderTagId>()
        {
            new ShaderTagId("UniversalForward"),
            new ShaderTagId("SRPDefaultUnlit"),
        };
    }

    /// <summary>
    /// ブラーおよびグラスモーフィズム効果の実行フラグとパラメータの設定
    /// </summary>
    public void Setup(bool isExecBlur, bool isExecGlassMorphism, float blurBlendRate, float blurSize, float blurRenderScale)
    {
        _isExecBlur = isExecBlur;
        _isExecGlassMorphism = isExecGlassMorphism;
        _blurBlendRate = blurBlendRate;
        _blurSize = blurSize;
        _blurRenderScale = blurRenderScale;
    }

    public override void OnCameraSetup(CommandBuffer cmd, ref RenderingData renderingData)
    {
        base.OnCameraSetup(cmd, ref renderingData);

        // ブラー用一時RTの確保
        RenderTextureDescriptor rtDescriptor = renderingData.cameraData.cameraTargetDescriptor;
        rtDescriptor.depthBufferBits = 0;
        RenderingUtils.ReAllocateIfNeeded(ref _blurTemporaryRT3, rtDescriptor, FilterMode.Bilinear, TextureWrapMode.Clamp, name: ShaderID.TemporaryBlurRT3Name);

        rtDescriptor.width = (int)(rtDescriptor.width * _blurRenderScale);
        rtDescriptor.height = (int)(rtDescriptor.height * _blurRenderScale);
        RenderingUtils.ReAllocateIfNeeded(ref _blurTemporaryRT1, rtDescriptor, FilterMode.Bilinear, TextureWrapMode.Clamp, name: ShaderID.TemporaryBlurRT1Name);
        RenderingUtils.ReAllocateIfNeeded(ref _blurTemporaryRT2, rtDescriptor, FilterMode.Bilinear, TextureWrapMode.Clamp, name: ShaderID.TemporaryBlurRT2Name);
        RenderingUtils.ReAllocateIfNeeded(ref _blurCaptureRT, rtDescriptor, FilterMode.Bilinear, TextureWrapMode.Clamp, name: ShaderID.BlurCaptureRTName);
    }

    public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
    {
        RTHandle cameraColorRT = renderingData.cameraData.renderer.cameraColorTargetHandle;
        if (cameraColorRT == null || cameraColorRT.rt == null)
        {
            return;
        }

        // UI描画用のDrawingSettings作成（共通設定）
        const SortingCriteria sortFlags = SortingCriteria.CommonTransparent;
        DrawingSettings drawingSettings = CreateDrawingSettings(_shaderTagIds, ref renderingData, sortFlags);
        CommandBuffer cmd = CommandBufferPool.Get();

        // ■ UIBlurBelowパス: ブラー下に描画するUI
        ExecutePass(context, cmd, _uiBlurBelowSampler, () =>
        {
            context.DrawRenderers(renderingData.cullResults, ref drawingSettings, ref _belowFilteringSettings, ref _stateBlock);
        });

        // ■ グラスモーフィズム（すりガラス）パス:
        // カメラカラーバッファをキャプチャしてブラー処理を行う
        if (_isExecGlassMorphism)
        {
            ExecutePass(context, cmd, _captureAndBlurSampler, () =>
            {
                ApplyBlur(cmd, ref renderingData, cameraColorRT, _blurCaptureRT, _blurRenderScale, _blurSize, _blurBlendRate);
            });
            // ブラー結果をグローバルテクスチャとして設定
            CoreUtils.SetRenderTarget(cmd, cameraColorRT);
            cmd.SetGlobalTexture(ShaderID.BlurCaptureTex, _blurCaptureRT);
            FlushCommandBuffer(cmd, context);
        }

        // ■ Default UIパス: メインUIの描画
        ExecutePass(context, cmd, _uiDefaultSampler, () =>
        {
            context.DrawRenderers(renderingData.cullResults, ref drawingSettings, ref _defaultFilteringSettings, ref _stateBlock);
        });

        // ■ 全体ブラー（後処理）パス: ブラー処理が有効な場合、カメラカラーバッファ全体にブラーを適用
        if (_isExecBlur)
        {
            ExecutePass(context, cmd, _blurSampler, () =>
            {
                ApplyBlur(cmd, ref renderingData, cameraColorRT, cameraColorRT, _blurRenderScale, _blurSize, _blurBlendRate);
            });
        }

        // ■ UIBlurAboveパス: ブラー上に描画するUI
        ExecutePass(context, cmd, _uiBlurAboveSampler, () =>
        {
            context.DrawRenderers(renderingData.cullResults, ref drawingSettings, ref _aboveFilteringSettings, ref _stateBlock);
        });

        CommandBufferPool.Release(cmd);
    }

    /// <summary>
    /// 共通の処理として、指定のプロファイリングスコープ内でアクションを実行し、
    /// コマンドバッファの実行とクリアを行います。
    /// </summary>
    private void ExecutePass(ScriptableRenderContext context, CommandBuffer cmd, ProfilingSampler sampler, System.Action passAction)
    {
        using (new ProfilingScope(cmd, sampler))
        {
            FlushCommandBuffer(cmd, context);
            passAction();
        }
        FlushCommandBuffer(cmd, context);
    }

    /// <summary>
    /// コマンドバッファを実行してクリアするユーティリティメソッド
    /// </summary>
    private void FlushCommandBuffer(CommandBuffer cmd, ScriptableRenderContext context)
    {
        context.ExecuteCommandBuffer(cmd);
        cmd.Clear();
    }

    /// <summary>
    /// ブラー効果を適用するための処理。
    /// 指定されたRTに対して、2段階のブラー処理を行います。
    /// </summary>
    private void ApplyBlur(
        CommandBuffer cmd,
        ref RenderingData renderingData,
        RTHandle source,
        RTHandle destination,
        float renderScale,
        float blurSize,
        float blendRate)
    {
        if (_blurMaterial == null)
        {
            return;
        }

        // ブラーのパラメータ設定（x：ブラーサイズ、y：ブレンド率）
        Vector4 blurParams = new Vector4(blurSize, blendRate, 0f, 0f);
        const int blurPass = 0;
        const int blurFinalPass = 1;

        // 第1段階: ソースから一時RT1へ、ブラー適用（水平・垂直などのパスを切り替え）
        _blurMaterial.SetVector(ShaderID.SimpleBlurParams, blurParams);
        Blitter.BlitCameraTexture(cmd, source, _blurTemporaryRT1, _blurMaterial, blurPass);
        Blitter.BlitCameraTexture(cmd, _blurTemporaryRT1, _blurTemporaryRT2, _blurMaterial, blurFinalPass);

        // 描画元と描画先が同一の場合、競合を避けるため中間バッファを使用
        if (source == destination)
        {
            Blitter.BlitCameraTexture(cmd, source, _blurTemporaryRT3);
            cmd.SetGlobalTexture(ShaderID.SourceTex, _blurTemporaryRT3);
        }
        else
        {
            cmd.SetGlobalTexture(ShaderID.SourceTex, source);
        }

        // 第2段階: 一時RT2から最終出力先へ反映
        Blitter.BlitCameraTexture(cmd, _blurTemporaryRT2, destination, _blurMaterial, blurFinalPass);
    }

    public void Dispose()
    {
        ReleaseTemporaryRT();
    }

    /// <summary>
    /// 確保した一時レンダーターゲットの解放
    /// </summary>
    private void ReleaseTemporaryRT()
    {
        _blurCaptureRT?.Release();
        _blurTemporaryRT1?.Release();
        _blurTemporaryRT2?.Release();
        _blurTemporaryRT3?.Release();
    }
}