// SPDX-FileCopyrightText: 2023 Unity Technologies and the KTX for Unity authors
// SPDX-License-Identifier: Apache-2.0


using System;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Experimental.Rendering;
#if KTX_VERBOSE
using System.Text;
using Enum = System.Enum;
#endif

namespace KtxUnity
{

    /// <summary>
    /// Mask of texture features
    /// </summary>
    [Flags]
    enum TextureFeatures
    {
        None = 0x0,

        /// <summary>
        /// Format with 4 channels (RGB+Alpha)
        /// </summary>
        AlphaChannel = 0x1,

        /// <summary>
        /// Format supports arbitrary resolutions
        /// </summary>
        NonPowerOfTwo = 0x2,

        /// <summary>
        /// Format supports arbitrary resolutions
        /// </summary>
        NonMultipleOfFour = 0x4,

        /// <summary>
        /// Non square resolution
        /// </summary>
        NonSquare = 0x8,

        /// <summary>
        /// Linear value encoding (not sRGB)
        /// </summary>
        Linear = 0x10
    }

    struct TranscodeFormatTuple
    {
        public GraphicsFormat format;
        public TranscodeFormat transcodeFormat;

        public TranscodeFormatTuple(GraphicsFormat format, TranscodeFormat transcodeFormat)
        {
            this.format = format;
            this.transcodeFormat = transcodeFormat;
        }
    }

    struct FormatInfo
    {
        public TextureFeatures features;
        public TranscodeFormatTuple formats;

        public FormatInfo(TextureFeatures features, GraphicsFormat format, TranscodeFormat transcodeFormat)
        {
            this.features = features;
            this.formats = new TranscodeFormatTuple(format, transcodeFormat);
        }
    }

    static class TranscodeFormatHelper
    {
        static bool s_Initialized;
        static Dictionary<TextureFeatures, TranscodeFormatTuple> s_FormatCache;
        static List<FormatInfo> s_AllFormats;

        static void InitInternal()
        {
            s_Initialized = true;
            s_FormatCache = new Dictionary<TextureFeatures, TranscodeFormatTuple>();

            if (s_AllFormats == null)
            {

                s_AllFormats = new List<FormatInfo>();

                // Add all formats into the List ordered. First supported match will be used.
                // This particular order is based on memory size (1st degree)
                // and a combination of quality and transcode speed (2nd degree)
                // source <http://richg42.blogspot.com/2018/05/basis-universal-gpu-texture-format.html>

                // Compressed
                s_AllFormats.Add(new FormatInfo(
                    TextureFeatures.NonPowerOfTwo | TextureFeatures.NonSquare,
                    GraphicsFormat.RGB_ETC2_SRGB,
                    TranscodeFormat.ETC1_RGB));

                s_AllFormats.Add(new FormatInfo(
                    TextureFeatures.NonPowerOfTwo | TextureFeatures.NonSquare | TextureFeatures.Linear,
                    GraphicsFormat.RGB_ETC_UNorm,
                    TranscodeFormat.ETC1_RGB));

                s_AllFormats.Add(new FormatInfo(
                    TextureFeatures.NonPowerOfTwo | TextureFeatures.NonSquare,
#if UNITY_2018_3_OR_NEWER
                    GraphicsFormat.RGBA_DXT1_SRGB,
#else
                    GraphicsFormat.RGB_DXT1_SRGB,
#endif
                    TranscodeFormat.BC1_RGB));

                s_AllFormats.Add(new FormatInfo(
                    TextureFeatures.NonPowerOfTwo | TextureFeatures.NonSquare | TextureFeatures.Linear,
#if UNITY_2018_3_OR_NEWER
                    GraphicsFormat.RGBA_DXT1_UNorm,
#else
                    GraphicsFormat.RGB_DXT1_UNorm,
#endif
                    TranscodeFormat.BC1_RGB));

                s_AllFormats.Add(new FormatInfo(
                    TextureFeatures.NonMultipleOfFour,
                    GraphicsFormat.RGB_PVRTC_4Bpp_SRGB,
                    TranscodeFormat.PVRTC1_4_RGB));

                s_AllFormats.Add(new FormatInfo(
                    TextureFeatures.NonMultipleOfFour,
                    GraphicsFormat.RGB_PVRTC_4Bpp_UNorm,
                    TranscodeFormat.PVRTC1_4_RGB));

                // Compressed with alpha channel
                s_AllFormats.Add(new FormatInfo(
                    TextureFeatures.AlphaChannel | TextureFeatures.NonPowerOfTwo | TextureFeatures.NonMultipleOfFour | TextureFeatures.NonSquare,
                    GraphicsFormat.RGBA_ASTC4X4_SRGB,
                    TranscodeFormat.ASTC_4x4_RGBA));

                s_AllFormats.Add(new FormatInfo(
                    TextureFeatures.AlphaChannel | TextureFeatures.NonPowerOfTwo | TextureFeatures.NonMultipleOfFour | TextureFeatures.NonSquare | TextureFeatures.Linear,
                    GraphicsFormat.RGBA_ASTC4X4_UNorm,
                    TranscodeFormat.ASTC_4x4_RGBA));

                s_AllFormats.Add(new FormatInfo(
                    TextureFeatures.AlphaChannel | TextureFeatures.NonPowerOfTwo | TextureFeatures.NonSquare,
                    GraphicsFormat.RGBA_ETC2_SRGB,
                    TranscodeFormat.ETC2_RGBA));

                s_AllFormats.Add(new FormatInfo(
                    TextureFeatures.AlphaChannel | TextureFeatures.NonPowerOfTwo | TextureFeatures.NonSquare | TextureFeatures.Linear,
                    GraphicsFormat.RGBA_ETC2_UNorm,
                    TranscodeFormat.ETC2_RGBA));

                s_AllFormats.Add(new FormatInfo(
                    TextureFeatures.AlphaChannel | TextureFeatures.NonPowerOfTwo | TextureFeatures.NonSquare,
                    GraphicsFormat.RGBA_BC7_SRGB,
                    TranscodeFormat.BC7_RGBA));

                s_AllFormats.Add(new FormatInfo(
                    TextureFeatures.AlphaChannel | TextureFeatures.NonPowerOfTwo | TextureFeatures.NonSquare | TextureFeatures.Linear,
                    GraphicsFormat.RGBA_BC7_UNorm,
                    TranscodeFormat.BC7_RGBA));

                s_AllFormats.Add(new FormatInfo(
                    TextureFeatures.AlphaChannel | TextureFeatures.NonPowerOfTwo | TextureFeatures.NonSquare,
                    GraphicsFormat.RGBA_DXT5_SRGB,
                    TranscodeFormat.BC3_RGBA));

                s_AllFormats.Add(new FormatInfo(
                    TextureFeatures.AlphaChannel | TextureFeatures.NonPowerOfTwo | TextureFeatures.NonSquare | TextureFeatures.Linear,
                    GraphicsFormat.RGBA_DXT5_UNorm,
                    TranscodeFormat.BC3_RGBA));

                s_AllFormats.Add(new FormatInfo(
                    TextureFeatures.AlphaChannel | TextureFeatures.NonMultipleOfFour,
                    GraphicsFormat.RGBA_PVRTC_4Bpp_SRGB,
                    TranscodeFormat.PVRTC1_4_RGBA));

                s_AllFormats.Add(new FormatInfo(
                    TextureFeatures.AlphaChannel | TextureFeatures.Linear | TextureFeatures.NonMultipleOfFour,
                    GraphicsFormat.RGBA_PVRTC_4Bpp_UNorm,
                    TranscodeFormat.PVRTC1_4_RGBA));

                // Uncompressed
                s_AllFormats.Add(new FormatInfo(
                    TextureFeatures.NonPowerOfTwo | TextureFeatures.NonMultipleOfFour | TextureFeatures.NonSquare | TextureFeatures.Linear,
                    GraphicsFormat.R5G6B5_UNormPack16,
                    TranscodeFormat.RGB565));

                // Uncompressed with alpha channel
                s_AllFormats.Add(new FormatInfo(
                    TextureFeatures.AlphaChannel | TextureFeatures.NonPowerOfTwo | TextureFeatures.NonMultipleOfFour | TextureFeatures.NonSquare,
                    GraphicsFormat.R8G8B8A8_SRGB, // Also supports SNorm, UInt, SInt
                    TranscodeFormat.RGBA32));

                s_AllFormats.Add(new FormatInfo(
                    TextureFeatures.AlphaChannel | TextureFeatures.NonPowerOfTwo | TextureFeatures.NonMultipleOfFour | TextureFeatures.NonSquare | TextureFeatures.Linear,
                    GraphicsFormat.R8G8B8A8_UNorm, // Also supports SNorm, UInt, SInt
                    TranscodeFormat.RGBA32));

                s_AllFormats.Add(new FormatInfo(
                    TextureFeatures.AlphaChannel | TextureFeatures.NonPowerOfTwo | TextureFeatures.NonMultipleOfFour | TextureFeatures.NonSquare | TextureFeatures.Linear,
                    GraphicsFormat.R4G4B4A4_UNormPack16,
                    TranscodeFormat.RGBA4444));

                // Need to extend TextureFeatures to request single/dual channel texture formats.
                // Until then, those formats are at the end of the list
                s_AllFormats.Add(new FormatInfo(
                    TextureFeatures.NonPowerOfTwo | TextureFeatures.NonMultipleOfFour | TextureFeatures.NonSquare | TextureFeatures.Linear,
                    GraphicsFormat.B5G6R5_UNormPack16,
                    TranscodeFormat.BGR565));

                s_AllFormats.Add(new FormatInfo(
                    TextureFeatures.AlphaChannel | TextureFeatures.NonPowerOfTwo | TextureFeatures.NonSquare | TextureFeatures.Linear,
                    GraphicsFormat.R_EAC_UNorm, // Also supports SNorm
                    TranscodeFormat.ETC2_EAC_R11));

                s_AllFormats.Add(new FormatInfo(
                    TextureFeatures.AlphaChannel | TextureFeatures.NonPowerOfTwo | TextureFeatures.NonSquare | TextureFeatures.Linear,
                    GraphicsFormat.RG_EAC_UNorm, // Also supports SNorm
                    TranscodeFormat.ETC2_EAC_RG11));

                // GraphicsFormat.RGB_A1_ETC2_SRGB,TranscodeFormat.ETC2_RGBA // Does not work; always transcodes 8-bit alpha
                // GraphicsFormat.RGBA_ETC2_SRGB,TranscodeFormat.ATC_RGBA // Not sure if this works (maybe compatible) - untested
                // GraphicsFormat.RGB_ETC_UNorm,ATC_RGB // Not sure if this works (maybe compatible) - untested

                // Not supported via KTX atm
                // GraphicsFormat.R_BC4_UNorm,TranscodeFormat.BC4_R
                // GraphicsFormat.RG_BC5_UNorm,TranscodeFormat.BC5_RG

                // Supported by BasisU, but no matching Unity GraphicsFormat
                // GraphicsFormat.?,TranscodeFormat.ATC_RGB
                // GraphicsFormat.?,TranscodeFormat.ATC_RGBA
                // GraphicsFormat.?,TranscodeFormat.FXT1_RGB
                // GraphicsFormat.?,TranscodeFormat.PVRTC2_4_RGB
                // GraphicsFormat.?,TranscodeFormat.PVRTC2_4_RGBA
            }
        }

        public static void Init()
        {
            if (!s_Initialized)
            {
                InitInternal();
#if KTX_VERBOSE
                CheckTextureSupport();
#endif
            }
        }

        internal static TranscodeFormatTuple? GetFormatsForImage(
            IMetaData meta,
            ILevelInfo li,
            bool linear = false
            )
        {
            var formats = TranscodeFormatHelper.GetPreferredFormat(
                meta.hasAlpha,
                li.isPowerOfTwo,
                li.isMultipleOfFour,
                li.isSquare,
                linear
            );

            if (!formats.HasValue && meta.hasAlpha)
            {
                // Fall back to transcode RGB-only to RGBA texture
                formats = TranscodeFormatHelper.GetPreferredFormat(
                    false,
                    li.isPowerOfTwo,
                    li.isMultipleOfFour,
                    li.isSquare,
                    linear
                    );
            }
            return formats;
        }

        public static TranscodeFormatTuple? GetPreferredFormat(
            bool hasAlpha,
            bool isPowerOfTwo,
            bool isMultipleOfFour,
            bool isSquare,
            bool isLinear = false
        )
        {
            TextureFeatures features = TextureFeatures.None;
            if (hasAlpha)
            {
                features |= TextureFeatures.AlphaChannel;
            }
            if (!isPowerOfTwo)
            {
                features |= TextureFeatures.NonPowerOfTwo;
            }
            if (!isMultipleOfFour)
            {
                features |= TextureFeatures.NonMultipleOfFour;
            }
            if (!isSquare)
            {
                features |= TextureFeatures.NonSquare;
            }
            if (isLinear)
            {
                features |= TextureFeatures.Linear;
            }

            if (s_FormatCache.TryGetValue(features, out var formatTuple))
            {
                return formatTuple;
            }
            else
            {
                foreach (var formatInfo in s_AllFormats)
                {
                    if (!FormatIsMatch(features, formatInfo.features))
                    {
                        continue;
                    }
                    var supported = IsFormatSupported(formatInfo.formats.format, isLinear);
                    if (supported)
                    {
                        s_FormatCache[features] = formatInfo.formats;
                        return formatInfo.formats;
                    }
                }
#if DEBUG
                Debug.LogErrorFormat("Could not find transcode texture format! (alpha:{0} Po2:{1} sqr:{2})",hasAlpha,isPowerOfTwo,isSquare);
#endif
                return null;
            }
        }

        /// <summary>
        /// Takes a desired target format and returns a fitting <see cref="TranscodeFormatTuple"/>, if one was found.
        /// </summary>
        /// <param name="graphicsFormat">Desired target texture format</param>
        /// <returns>A fitting <see cref="TranscodeFormatTuple"/>, if one was found. False otherwise.</returns>
        internal static TranscodeFormatTuple? GetTranscodeFormats(GraphicsFormat graphicsFormat)
        {
            TranscodeFormat? tf;
            switch (graphicsFormat)
            {
                case GraphicsFormat.RGB_ETC_UNorm:
                case GraphicsFormat.RGB_ETC2_SRGB:
                case GraphicsFormat.RGB_ETC2_UNorm:
                    tf = TranscodeFormat.ETC1_RGB;
                    break;
                case GraphicsFormat.RGBA_DXT1_SRGB:
                case GraphicsFormat.RGBA_DXT1_UNorm:
                    tf = TranscodeFormat.BC1_RGB;
                    break;
                case GraphicsFormat.RGBA_DXT5_SRGB:
                case GraphicsFormat.RGBA_DXT5_UNorm:
                    tf = TranscodeFormat.BC3_RGBA;
                    break;
                case GraphicsFormat.RG_BC5_UNorm:
                case GraphicsFormat.RG_BC5_SNorm:
                    tf = TranscodeFormat.BC5_RG;
                    break;
                case GraphicsFormat.R_BC4_UNorm:
                case GraphicsFormat.R_BC4_SNorm:
                    tf = TranscodeFormat.BC4_R;
                    break;
                case GraphicsFormat.RGBA_BC7_SRGB:
                case GraphicsFormat.RGBA_BC7_UNorm:
                    tf = TranscodeFormat.BC7_RGBA;
                    break;

                // // RGB formats are untested.
                // case GraphicsFormat.B8G8R8_SInt:
                // case GraphicsFormat.B8G8R8_SNorm:
                // case GraphicsFormat.B8G8R8_SRGB:
                // case GraphicsFormat.B8G8R8_UInt:
                // case GraphicsFormat.B8G8R8_UNorm:
                // case GraphicsFormat.R8G8B8_SInt:
                // case GraphicsFormat.R8G8B8_SNorm:
                // case GraphicsFormat.R8G8B8_SRGB:
                // case GraphicsFormat.R8G8B8_UInt:
                // case GraphicsFormat.R8G8B8_UNorm:
                //     tf = TranscodeFormat.RGBA32;
                //     break;

                case GraphicsFormat.B8G8R8A8_SInt:
                case GraphicsFormat.B8G8R8A8_SNorm:
                case GraphicsFormat.B8G8R8A8_SRGB:
                case GraphicsFormat.B8G8R8A8_UInt:
                case GraphicsFormat.B8G8R8A8_UNorm:
                case GraphicsFormat.R8G8B8A8_SInt:
                case GraphicsFormat.R8G8B8A8_SNorm:
                case GraphicsFormat.R8G8B8A8_SRGB:
                case GraphicsFormat.R8G8B8A8_UInt:
                case GraphicsFormat.R8G8B8A8_UNorm:
                    tf = TranscodeFormat.RGBA32;
                    break;
                case GraphicsFormat.B5G6R5_UNormPack16:
                case GraphicsFormat.R5G6B5_UNormPack16:
                    tf = TranscodeFormat.BGR565;
                    break;
                case GraphicsFormat.B4G4R4A4_UNormPack16:
                case GraphicsFormat.R4G4B4A4_UNormPack16:
                    tf = TranscodeFormat.RGBA4444;
                    break;
                case GraphicsFormat.RGBA_ASTC4X4_SRGB:
#if UNITY_2020_2_OR_NEWER
                case GraphicsFormat.RGBA_ASTC4X4_UFloat:
#endif
                case GraphicsFormat.RGBA_ASTC4X4_UNorm:
                    tf = TranscodeFormat.ASTC_4x4_RGBA;
                    break;
                case GraphicsFormat.RGBA_ETC2_SRGB:
                case GraphicsFormat.RGBA_ETC2_UNorm:
                    tf = TranscodeFormat.ETC2_RGBA;
                    break;
                case GraphicsFormat.RGBA_PVRTC_4Bpp_SRGB:
                case GraphicsFormat.RGBA_PVRTC_4Bpp_UNorm:
                    tf = TranscodeFormat.PVRTC1_4_RGBA;
                    break;
                case GraphicsFormat.RGB_PVRTC_4Bpp_SRGB:
                case GraphicsFormat.RGB_PVRTC_4Bpp_UNorm:
                    tf = TranscodeFormat.PVRTC1_4_RGB;
                    break;
                case GraphicsFormat.R_EAC_SNorm:
                case GraphicsFormat.R_EAC_UNorm:
                    tf = TranscodeFormat.ETC2_EAC_R11;
                    break;
                case GraphicsFormat.RG_EAC_SNorm:
                case GraphicsFormat.RG_EAC_UNorm:
                    tf = TranscodeFormat.ETC2_EAC_RG11;
                    break;
                default:
                    return null;
            }

            return new TranscodeFormatTuple(graphicsFormat, tf.Value);
        }

        static bool FormatIsMatch(TextureFeatures required, TextureFeatures provided)
        {
            return (required & provided) == required;
        }

        internal static bool IsFormatSupported(GraphicsFormat graphicsFormat, bool linear = false)
        {
            return SystemInfo.IsFormatSupported(
                graphicsFormat,
#if UNITY_2023_2_OR_NEWER
                linear ? GraphicsFormatUsage.Linear : GraphicsFormatUsage.Sample
#else
                linear ? FormatUsage.Linear : FormatUsage.Sample
#endif
            );
        }

#if KTX_VERBOSE
        // ReSharper disable Unity.PerformanceAnalysis
        static void CheckTextureSupport () {
            // Dummy call to force logging all supported formats to console
            GetSupportedTextureFormats(out _);
        }

        static void GetSupportedTextureFormats (
            out List<TranscodeFormatTuple> graphicsFormats
        )
        {
            graphicsFormats = new List<TranscodeFormatTuple>();

            var sb = new StringBuilder();
            foreach(var formatInfo in s_AllFormats) {
                var supported = IsFormatSupported(formatInfo.formats.format);
                if(supported) {
                    graphicsFormats.Add(formatInfo.formats);
                }
                sb.AppendFormat("{0} support: {1}\n",formatInfo.formats.format,supported);
            }

            Debug.Log(sb.ToString());

            sb.Clear();

            var allGfxFormats = (GraphicsFormat[]) Enum.GetValues(typeof(GraphicsFormat));
            foreach(var format in allGfxFormats) {
                sb.Append(format).Append(' ');
                var usages = new[]
                {
#if UNITY_2023_2_OR_NEWER
                    GraphicsFormatUsage.Sample,
                    GraphicsFormatUsage.Blend,
                    GraphicsFormatUsage.GetPixels,
                    GraphicsFormatUsage.Linear,
                    GraphicsFormatUsage.LoadStore,
                    GraphicsFormatUsage.MSAA2x,
                    GraphicsFormatUsage.MSAA4x,
                    GraphicsFormatUsage.MSAA8x,
                    GraphicsFormatUsage.ReadPixels,
                    GraphicsFormatUsage.Render,
                    GraphicsFormatUsage.SetPixels,
                    GraphicsFormatUsage.SetPixels32,
                    GraphicsFormatUsage.Sparse,
                    GraphicsFormatUsage.StencilSampling,
#else
                    FormatUsage.Sample,
                    FormatUsage.Blend,
                    FormatUsage.GetPixels,
                    FormatUsage.Linear,
                    FormatUsage.LoadStore,
                    FormatUsage.MSAA2x,
                    FormatUsage.MSAA4x,
                    FormatUsage.MSAA8x,
                    FormatUsage.ReadPixels,
                    FormatUsage.Render,
                    FormatUsage.SetPixels,
                    FormatUsage.SetPixels32,
                    FormatUsage.Sparse,
                    FormatUsage.StencilSampling,
#endif
                };
                foreach (var usage in usages)
                {
                    sb
                        .Append(usage)
                        .Append(':')
                        .Append(SystemInfo.IsFormatSupported(format, usage) ? "1" : "0")
                        .Append(' ');
                }

                sb.Append('\n');
            }

            Debug.Log(sb.ToString());
        }
#endif
    }
}