using System;

namespace UnityEngine.Rendering.HighDefinition.AMD.FSR2Wrapper
{
    /// <summary>
    /// Wrapper plugin that simply forwards calls to the original Unity native plugin implementation of FSR2.
    /// Use this to verify other plugins against Unity's reference implementation.
    /// </summary>
    public class FSR2WrapperUpscaler: UpscalerPlugin
    {
        public override string name => "FSR 2.1";

        public override bool isSupported => IsLoaded();

        public override bool Load() => UnityEngine.AMD.AMDUnityPlugin.Load();

        public override bool IsLoaded() => UnityEngine.AMD.AMDUnityPlugin.IsLoaded();

        public override GraphicsDevice CreateGraphicsDevice() => new FSR2WrappedGraphicsDevice(UnityEngine.AMD.GraphicsDevice.CreateGraphicsDevice());

        public override void DestroyGraphicsDevice() { }    // Noop, native plugin does not allow clearing the graphics device

        public override GraphicsDevice device => new FSR2WrappedGraphicsDevice(UnityEngine.AMD.GraphicsDevice.device);
        
        public override uint version => UnityEngine.AMD.GraphicsDevice.version;
    }
    
    public class FSR2WrappedGraphicsDevice: GraphicsDevice
    {
        private readonly UnityEngine.AMD.GraphicsDevice _wrappedDevice;
        
        internal FSR2WrappedGraphicsDevice(UnityEngine.AMD.GraphicsDevice wrappedDevice)
        {
            _wrappedDevice = wrappedDevice;
        }
        
        public override FSR2Context CreateFeature(CommandBuffer cmd, in FSR2CommandInitializationData initSettings)
        {
            var wrappedInitSettings = initSettings.ToWrapped();
            return new FSR2WrappedContext(_wrappedDevice.CreateFeature(cmd, in wrappedInitSettings), in initSettings);
        }

        public override void DestroyFeature(CommandBuffer cmd, FSR2Context fsrContext)
        {
            _wrappedDevice.DestroyFeature(cmd, ((FSR2WrappedContext)fsrContext).WrappedContext);
        }

        public override void ExecuteFSR2(CommandBuffer cmd, FSR2Context fsr2Context, in FSR2TextureTable textures)
        {
            ((FSR2WrappedContext)fsr2Context).SyncExecuteData();
            var wrappedTextures = textures.ToWrapped();
            _wrappedDevice.ExecuteFSR2(cmd, ((FSR2WrappedContext)fsr2Context).WrappedContext, in wrappedTextures);
        }

        public override bool GetRenderResolutionFromQualityMode(FSR2Quality qualityMode, uint displayWidth, uint displayHeight, out uint renderWidth, out uint renderHeight)
        {
            return _wrappedDevice.GetRenderResolutionFromQualityMode((UnityEngine.AMD.FSR2Quality)qualityMode, displayWidth, displayHeight, out renderWidth, out renderHeight);
        }

        public override float GetUpscaleRatioFromQualityMode(FSR2Quality qualityMode)
        {
            return _wrappedDevice.GetUpscaleRatioFromQualityMode((UnityEngine.AMD.FSR2Quality)qualityMode);
        }
    }

    public class FSR2WrappedContext : FSR2Context
    {
        internal readonly UnityEngine.AMD.FSR2Context WrappedContext;

        private FSR2CommandInitializationData _initData;
        public override ref FSR2CommandInitializationData initData => ref _initData;

        private FSR2CommandExecutionData _executeData;
        public override ref FSR2CommandExecutionData executeData => ref _executeData;
        
        internal FSR2WrappedContext(UnityEngine.AMD.FSR2Context wrappedContext, in FSR2CommandInitializationData initData)
        {
            WrappedContext = wrappedContext;
            _initData = initData;
        }

        internal void SyncExecuteData()
        {
            WrappedContext.executeData.jitterOffsetX = _executeData.jitterOffsetX;
            WrappedContext.executeData.jitterOffsetY = _executeData.jitterOffsetY;
            WrappedContext.executeData.MVScaleX = _executeData.MVScaleX;
            WrappedContext.executeData.MVScaleY = _executeData.MVScaleY;
            WrappedContext.executeData.renderSizeWidth = _executeData.renderSizeWidth;
            WrappedContext.executeData.renderSizeHeight = _executeData.renderSizeHeight;
            WrappedContext.executeData.enableSharpening = _executeData.enableSharpening;
            WrappedContext.executeData.sharpness = _executeData.sharpness;
            WrappedContext.executeData.frameTimeDelta = _executeData.frameTimeDelta;
            WrappedContext.executeData.preExposure = _executeData.preExposure;
            WrappedContext.executeData.reset = _executeData.reset;
            WrappedContext.executeData.cameraNear = _executeData.cameraNear;
            WrappedContext.executeData.cameraFar = _executeData.cameraFar;
            WrappedContext.executeData.cameraFovAngleVertical = _executeData.cameraFovAngleVertical;
        }
    }

    internal static class FSR2WrapperExtensions
    {
        public static UnityEngine.AMD.FSR2CommandInitializationData ToWrapped(this FSR2CommandInitializationData data)
        {
            return new UnityEngine.AMD.FSR2CommandInitializationData
            {
                displaySizeHeight = data.displaySizeHeight,
                displaySizeWidth = data.displaySizeWidth,
                ffxFsrFlags = (UnityEngine.AMD.FfxFsr2InitializationFlags)data.ffxFsrFlags,
                maxRenderSizeHeight = data.maxRenderSizeHeight,
                maxRenderSizeWidth = data.maxRenderSizeWidth,
            };
        }
        
        public static UnityEngine.AMD.FSR2TextureTable ToWrapped(this FSR2TextureTable table)
        {
            return new UnityEngine.AMD.FSR2TextureTable
            {
                biasColorMask = table.biasColorMask,
                colorInput = table.colorInput,
                colorOutput = table.colorOutput,
                depth = table.depth,
                exposureTexture = table.exposureTexture,
                motionVectors = table.motionVectors,
                reactiveMask = table.reactiveMask,
                transparencyMask = table.transparencyMask,
            };
        }
    }
}