using Ryujinx.Graphics.GAL;

namespace Ryujinx.Graphics.Gpu.Engine.Threed.Blender
{
    /// <summary>
    /// Fixed function alpha state used for a advanced blend function.
    /// </summary>
    struct FixedFunctionAlpha
    {
        /// <summary>
        /// Fixed function alpha state with alpha blending disabled.
        /// </summary>
        public static FixedFunctionAlpha Disabled => new FixedFunctionAlpha(BlendUcodeEnable.EnableRGBA, default, default, default);

        /// <summary>
        /// Individual enable bits for the RGB and alpha components.
        /// </summary>
        public BlendUcodeEnable Enable { get; }

        /// <summary>
        /// Alpha blend operation.
        /// </summary>
        public BlendOp AlphaOp { get; }

        /// <summary>
        /// Value multiplied with the blend source operand.
        /// </summary>
        public BlendFactor AlphaSrcFactor { get; }

        /// <summary>
        /// Value multiplied with the blend destination operand.
        /// </summary>
        public BlendFactor AlphaDstFactor { get; }

        /// <summary>
        /// Creates a new blend fixed function alpha state.
        /// </summary>
        /// <param name="enable">Individual enable bits for the RGB and alpha components</param>
        /// <param name="alphaOp">Alpha blend operation</param>
        /// <param name="alphaSrc">Value multiplied with the blend source operand</param>
        /// <param name="alphaDst">Value multiplied with the blend destination operand</param>
        public FixedFunctionAlpha(BlendUcodeEnable enable, BlendOp alphaOp, BlendFactor alphaSrc, BlendFactor alphaDst)
        {
            Enable = enable;
            AlphaOp = alphaOp;
            AlphaSrcFactor = alphaSrc;
            AlphaDstFactor = alphaDst;
        }

        /// <summary>
        /// Creates a new blend fixed function alpha state.
        /// </summary>
        /// <param name="alphaOp">Alpha blend operation</param>
        /// <param name="alphaSrc">Value multiplied with the blend source operand</param>
        /// <param name="alphaDst">Value multiplied with the blend destination operand</param>
        public FixedFunctionAlpha(BlendOp alphaOp, BlendFactor alphaSrc, BlendFactor alphaDst) : this(BlendUcodeEnable.EnableRGB, alphaOp, alphaSrc, alphaDst)
        {
        }
    }

    /// <summary>
    /// Blend microcode assembly function delegate.
    /// </summary>
    /// <param name="asm">Assembler</param>
    /// <returns>Fixed function alpha state for the microcode</returns>
    delegate FixedFunctionAlpha GenUcodeFunc(ref UcodeAssembler asm);

    /// <summary>
    /// Advanced blend microcode state.
    /// </summary>
    struct AdvancedBlendUcode
    {
        /// <summary>
        /// Advanced blend operation.
        /// </summary>
        public AdvancedBlendOp Op { get; }

        /// <summary>
        /// Advanced blend overlap mode.
        /// </summary>
        public AdvancedBlendOverlap Overlap { get; }

        /// <summary>
        /// Whenever the source input is pre-multiplied.
        /// </summary>
        public bool SrcPreMultiplied { get; }

        /// <summary>
        /// Fixed function alpha state.
        /// </summary>
        public FixedFunctionAlpha Alpha { get; }

        /// <summary>
        /// Microcode.
        /// </summary>
        public uint[] Code { get; }

        /// <summary>
        /// Constants used by the microcode.
        /// </summary>
        public RgbFloat[] Constants { get; }

        /// <summary>
        /// Creates a new advanced blend state.
        /// </summary>
        /// <param name="op">Advanced blend operation</param>
        /// <param name="overlap">Advanced blend overlap mode</param>
        /// <param name="srcPreMultiplied">Whenever the source input is pre-multiplied</param>
        /// <param name="genFunc">Function that will generate the advanced blend microcode</param>
        public AdvancedBlendUcode(
            AdvancedBlendOp op,
            AdvancedBlendOverlap overlap,
            bool srcPreMultiplied,
            GenUcodeFunc genFunc)
        {
            Op = op;
            Overlap = overlap;
            SrcPreMultiplied = srcPreMultiplied;

            UcodeAssembler asm = new UcodeAssembler();
            Alpha = genFunc(ref asm);
            Code = asm.GetCode();
            Constants = asm.GetConstants();
        }
    }
}