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

namespace UnityEngine.Experimental.Rendering
{
    public partial class RTHandleSystem
    {
        public class RTHandle
        {
            internal RTHandleSystem             m_Owner;
            internal RenderTexture[]            m_RTs = new RenderTexture[2];
            internal RenderTargetIdentifier[]   m_NameIDs = new RenderTargetIdentifier[2];
            internal bool                       m_EnableMSAA = false;
            internal bool                       m_EnableRandomWrite = false;
            internal string                     m_Name;

            internal Vector2 scaleFactor        = Vector2.one;
            internal ScaleFunc scaleFunc;

            public bool                         useScaling { get; internal set; }
            public Vector2Int                   referenceSize {get; internal set; }

            public RenderTexture rt
            {
                get
                {
                    if (!useScaling)
                    {
                        return m_EnableMSAA ? m_RTs[(int)RTCategory.MSAA] : m_RTs[(int)RTCategory.Regular];
                    }
                    else
                    {
                        var category = (m_EnableMSAA && m_Owner.m_ScaledRTCurrentCategory == RTCategory.MSAA) ? RTCategory.MSAA : RTCategory.Regular;
                        CreateIfNeeded(category);
                        return m_RTs[(int)category];
                    }
                }
            }

            public RenderTargetIdentifier nameID
            {
                get
                {
                    if (!useScaling)
                    {
                        return m_EnableMSAA ? m_NameIDs[(int)RTCategory.MSAA] : m_RTs[(int)RTCategory.Regular];
                    }
                    else
                    {
                        var category = (m_EnableMSAA && m_Owner.m_ScaledRTCurrentCategory == RTCategory.MSAA) ? RTCategory.MSAA : RTCategory.Regular;
                        CreateIfNeeded(category);
                        return m_NameIDs[(int)category];
                    }
                }
            }

            // Keep constructor private
            internal RTHandle(RTHandleSystem owner)
            {
                m_Owner = owner;
            }

            public static implicit operator RenderTexture(RTHandle handle)
            {
                return handle.rt;
            }

            public static implicit operator RenderTargetIdentifier(RTHandle handle)
            {
                return handle.nameID;
            }

            internal void SetRenderTexture(RenderTexture rt, RTCategory category)
            {
                m_RTs[(int)category] = rt;
                m_NameIDs[(int)category] = new RenderTargetIdentifier(rt);
            }

            void CreateIfNeeded(RTCategory category)
            {
                // If a RT was first created for MSAA then the regular one might be null, in this case we create it.
                // That's why we never test the MSAA version: It should always be there if RT was declared correctly.
                if(category == RTCategory.Regular && m_RTs[(int)RTCategory.Regular] == null)
                {
                    var refRT = m_RTs[(int)RTCategory.MSAA];
                    Debug.Assert(refRT != null);
                    referenceSize = new Vector2Int(m_Owner.maxWidthRegular, m_Owner.maxHeightRegular);
                    var scaledSize = GetScaledSize(referenceSize);

                    var newRT = new RenderTexture(scaledSize.x, scaledSize.y, refRT.depth, refRT.format, refRT.sRGB ? RenderTextureReadWrite.sRGB : RenderTextureReadWrite.Linear)
                    {
                        hideFlags = HideFlags.HideAndDontSave,
                        volumeDepth = refRT.volumeDepth,
                        filterMode = refRT.filterMode,
                        wrapMode = refRT.wrapMode,
                        dimension = refRT.dimension,
                        enableRandomWrite = m_EnableRandomWrite, // We cannot take the info from the msaa rt since we force it to 1
                        useMipMap = refRT.useMipMap,
                        autoGenerateMips = refRT.autoGenerateMips,
                        anisoLevel = refRT.anisoLevel,
                        mipMapBias = refRT.mipMapBias,
                        antiAliasing = 1, // No MSAA for the regular version of the texture.
                        bindTextureMS = false, // Somehow, this can be true even if antiAliasing == 1. Leads to Unity-internal binding errors.
                        useDynamicScale = refRT.useDynamicScale,
                        vrUsage = refRT.vrUsage,
                        memorylessMode = refRT.memorylessMode,
                        name = CoreUtils.GetRenderTargetAutoName(refRT.width, refRT.height, refRT.volumeDepth, refRT.format, m_Name, mips : refRT.useMipMap)
                    };
                    newRT.Create();

                    m_RTs[(int)RTCategory.Regular] = newRT;
                    m_NameIDs[(int)RTCategory.Regular] = new RenderTargetIdentifier(newRT);
                }
            }

            public void Release()
            {
                m_Owner.m_AutoSizedRTs.Remove(this);
                for (int i = 0; i < (int)RTCategory.Count; ++i)
                {
                    CoreUtils.Destroy(m_RTs[i]);
                    m_NameIDs[i] = BuiltinRenderTextureType.None;
                    m_RTs[i] = null;
                }
            }

            public Vector2Int GetScaledSize(Vector2Int refSize)
            {
                if (scaleFunc != null)
                {
                    return scaleFunc(refSize);
                }
                else
                {
                    return new Vector2Int(
                        x: Mathf.RoundToInt(scaleFactor.x * refSize.x),
                        y: Mathf.RoundToInt(scaleFactor.y * refSize.y)
                    );
                }
            }
        }
    }
}