using System;
using System.IO;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using Lz4;

namespace AssetStudio
{
    public static class ShaderConverter
    {
        public static string Convert(this Shader shader)
        {
            if (shader.m_SubProgramBlob != null) //5.3 - 5.4
            {
                var decompressedBytes = new byte[shader.decompressedSize];
                using (var decoder = new Lz4DecoderStream(new MemoryStream(shader.m_SubProgramBlob)))
                {
                    decoder.Read(decompressedBytes, 0, (int)shader.decompressedSize);
                }
                using (var blobReader = new BinaryReader(new MemoryStream(decompressedBytes)))
                {
                    var program = new ShaderProgram(blobReader, shader.version);
                    return header + program.Export(Encoding.UTF8.GetString(shader.m_Script));
                }
            }

            if (shader.compressedBlob != null) //5.5 and up
            {
                return header + ConvertSerializedShader(shader);
            }

            return header + Encoding.UTF8.GetString(shader.m_Script);
        }

        private static string ConvertSerializedShader(Shader shader)
        {
            var shaderPrograms = new ShaderProgram[shader.platforms.Length];
            for (var i = 0; i < shader.platforms.Length; i++)
            {
                var compressedBytes = new byte[shader.compressedLengths[i]];
                Buffer.BlockCopy(shader.compressedBlob, (int)shader.offsets[i], compressedBytes, 0, (int)shader.compressedLengths[i]);
                var decompressedBytes = new byte[shader.decompressedLengths[i]];
                using (var decoder = new Lz4DecoderStream(new MemoryStream(compressedBytes)))
                {
                    decoder.Read(decompressedBytes, 0, (int)shader.decompressedLengths[i]);
                }
                using (var blobReader = new BinaryReader(new MemoryStream(decompressedBytes)))
                {
                    shaderPrograms[i] = new ShaderProgram(blobReader, shader.version);
                }
            }

            return ConvertSerializedShader(shader.m_ParsedForm, shader.platforms, shaderPrograms);
        }

        private static string ConvertSerializedShader(SerializedShader m_ParsedForm, ShaderCompilerPlatform[] platforms, ShaderProgram[] shaderPrograms)
        {
            var sb = new StringBuilder();
            sb.Append($"Shader \"{m_ParsedForm.m_Name}\" {{\n");

            sb.Append(ConvertSerializedProperties(m_ParsedForm.m_PropInfo));

            foreach (var m_SubShader in m_ParsedForm.m_SubShaders)
            {
                sb.Append(ConvertSerializedSubShader(m_SubShader, platforms, shaderPrograms));
            }

            if (!string.IsNullOrEmpty(m_ParsedForm.m_FallbackName))
            {
                sb.Append($"Fallback \"{m_ParsedForm.m_FallbackName}\"\n");
            }

            if (!string.IsNullOrEmpty(m_ParsedForm.m_CustomEditorName))
            {
                sb.Append($"CustomEditor \"{m_ParsedForm.m_CustomEditorName}\"\n");
            }

            sb.Append("}");
            return sb.ToString();
        }

        private static string ConvertSerializedSubShader(SerializedSubShader m_SubShader, ShaderCompilerPlatform[] platforms, ShaderProgram[] shaderPrograms)
        {
            var sb = new StringBuilder();
            sb.Append("SubShader {\n");
            if (m_SubShader.m_LOD != 0)
            {
                sb.Append($" LOD {m_SubShader.m_LOD}\n");
            }

            sb.Append(ConvertSerializedTagMap(m_SubShader.m_Tags, 1));

            foreach (var m_Passe in m_SubShader.m_Passes)
            {
                sb.Append(ConvertSerializedPass(m_Passe, platforms, shaderPrograms));
            }
            sb.Append("}\n");
            return sb.ToString();
        }

        private static string ConvertSerializedPass(SerializedPass m_Passe, ShaderCompilerPlatform[] platforms, ShaderProgram[] shaderPrograms)
        {
            var sb = new StringBuilder();
            switch (m_Passe.m_Type)
            {
                case PassType.kPassTypeNormal:
                    sb.Append(" Pass ");
                    break;
                case PassType.kPassTypeUse:
                    sb.Append(" UsePass ");
                    break;
                case PassType.kPassTypeGrab:
                    sb.Append(" GrabPass ");
                    break;
            }
            if (m_Passe.m_Type == PassType.kPassTypeUse)
            {
                sb.Append($"\"{m_Passe.m_UseName}\"\n");
            }
            else
            {
                sb.Append("{\n");

                if (m_Passe.m_Type == PassType.kPassTypeGrab)
                {
                    if (!string.IsNullOrEmpty(m_Passe.m_TextureName))
                    {
                        sb.Append($"  \"{m_Passe.m_TextureName}\"\n");
                    }
                }
                else
                {
                    sb.Append(ConvertSerializedShaderState(m_Passe.m_State));

                    if (m_Passe.progVertex.m_SubPrograms.Length > 0)
                    {
                        sb.Append("Program \"vp\" {\n");
                        sb.Append(ConvertSerializedSubPrograms(m_Passe.progVertex.m_SubPrograms, platforms, shaderPrograms));
                        sb.Append("}\n");
                    }

                    if (m_Passe.progFragment.m_SubPrograms.Length > 0)
                    {
                        sb.Append("Program \"fp\" {\n");
                        sb.Append(ConvertSerializedSubPrograms(m_Passe.progFragment.m_SubPrograms, platforms, shaderPrograms));
                        sb.Append("}\n");
                    }

                    if (m_Passe.progGeometry.m_SubPrograms.Length > 0)
                    {
                        sb.Append("Program \"gp\" {\n");
                        sb.Append(ConvertSerializedSubPrograms(m_Passe.progGeometry.m_SubPrograms, platforms, shaderPrograms));
                        sb.Append("}\n");
                    }

                    if (m_Passe.progHull.m_SubPrograms.Length > 0)
                    {
                        sb.Append("Program \"hp\" {\n");
                        sb.Append(ConvertSerializedSubPrograms(m_Passe.progHull.m_SubPrograms, platforms, shaderPrograms));
                        sb.Append("}\n");
                    }

                    if (m_Passe.progDomain.m_SubPrograms.Length > 0)
                    {
                        sb.Append("Program \"dp\" {\n");
                        sb.Append(ConvertSerializedSubPrograms(m_Passe.progDomain.m_SubPrograms, platforms, shaderPrograms));
                        sb.Append("}\n");
                    }
                }
                sb.Append("}\n");
            }
            return sb.ToString();
        }

        private static string ConvertSerializedSubPrograms(SerializedSubProgram[] m_SubPrograms, ShaderCompilerPlatform[] platforms, ShaderProgram[] shaderPrograms)
        {
            var sb = new StringBuilder();
            var groups = m_SubPrograms.GroupBy(x => x.m_BlobIndex);
            foreach (var group in groups)
            {
                var programs = group.GroupBy(x => x.m_GpuProgramType);
                foreach (var program in programs)
                {
                    for (int i = 0; i < platforms.Length; i++)
                    {
                        var platform = platforms[i];
                        if (CheckGpuProgramUsable(platform, program.Key))
                        {
                            var subPrograms = program.ToList();
                            var isTier = subPrograms.Count > 1;
                            foreach (var subProgram in subPrograms)
                            {
                                sb.Append($"SubProgram \"{GetPlatformString(platform)} ");
                                if (isTier)
                                {
                                    sb.Append($"hw_tier{subProgram.m_ShaderHardwareTier:00} ");
                                }
                                sb.Append("\" {\n");
                                sb.Append(shaderPrograms[i].m_SubPrograms[subProgram.m_BlobIndex].Export());
                                sb.Append("\n}\n");
                            }
                            break;
                        }
                    }
                }
            }
            return sb.ToString();
        }

        private static string ConvertSerializedShaderState(SerializedShaderState m_State)
        {
            var sb = new StringBuilder();
            if (!string.IsNullOrEmpty(m_State.m_Name))
            {
                sb.Append($"  Name \"{m_State.m_Name}\"\n");
            }
            if (m_State.m_LOD != 0)
            {
                sb.Append($"  LOD {m_State.m_LOD}\n");
            }

            sb.Append(ConvertSerializedTagMap(m_State.m_Tags, 2));

            sb.Append(ConvertSerializedShaderRTBlendState(m_State.rtBlend));

            if (m_State.alphaToMask.val > 0f)
            {
                sb.Append("  AlphaToMask On\n");
            }

            if (m_State.zClip?.val != 1f) //ZClip On
            {
                sb.Append("  ZClip Off\n");
            }

            if (m_State.zTest.val != 4f) //ZTest LEqual
            {
                sb.Append("  ZTest ");
                switch (m_State.zTest.val) //enum CompareFunction
                {
                    case 0f: //kFuncDisabled
                        sb.Append("Off");
                        break;
                    case 1f: //kFuncNever
                        sb.Append("Never");
                        break;
                    case 2f: //kFuncLess
                        sb.Append("Less");
                        break;
                    case 3f: //kFuncEqual
                        sb.Append("Equal");
                        break;
                    case 5f: //kFuncGreater
                        sb.Append("Greater");
                        break;
                    case 6f: //kFuncNotEqual
                        sb.Append("NotEqual");
                        break;
                    case 7f: //kFuncGEqual
                        sb.Append("GEqual");
                        break;
                    case 8f: //kFuncAlways
                        sb.Append("Always");
                        break;
                }

                sb.Append("\n");
            }

            if (m_State.zWrite.val != 1f) //ZWrite On
            {
                sb.Append("  ZWrite Off\n");
            }

            if (m_State.culling.val != 2f) //Cull Back
            {
                sb.Append("  Cull ");
                switch (m_State.culling.val) //enum CullMode
                {
                    case 0f: //kCullOff
                        sb.Append("Off");
                        break;
                    case 1f: //kCullFront
                        sb.Append("Front");
                        break;
                }
                sb.Append("\n");
            }

            if (m_State.offsetFactor.val != 0f || m_State.offsetUnits.val != 0f)
            {
                sb.Append($"  Offset {m_State.offsetFactor.val}, {m_State.offsetUnits.val}\n");
            }

            //TODO Stencil

            //TODO Fog

            if (m_State.lighting)
            {
                sb.Append($"  Lighting {(m_State.lighting ? "On" : "Off")}\n");
            }

            sb.Append($"  GpuProgramID {m_State.gpuProgramID}\n");

            return sb.ToString();
        }

        private static string ConvertSerializedShaderRTBlendState(SerializedShaderRTBlendState[] rtBlend)
        {
            //TODO Blend
            var sb = new StringBuilder();
            /*for (var i = 0; i < rtBlend.Length; i++)
            {
                var blend = rtBlend[i];
                if (!blend.srcBlend.val.Equals(1f) ||
                    !blend.destBlend.val.Equals(0f) ||
                    !blend.srcBlendAlpha.val.Equals(1f) ||
                    !blend.destBlendAlpha.val.Equals(0f))
                {
                    sb.Append("  Blend ");
                    sb.Append($"{i} ");
                    sb.Append('\n');
                }
            }*/

            return sb.ToString();
        }

        private static string ConvertSerializedTagMap(SerializedTagMap m_Tags, int intent)
        {
            var sb = new StringBuilder();
            if (m_Tags.tags.Length > 0)
            {
                sb.Append(new string(' ', intent));
                sb.Append("Tags { ");
                foreach (var pair in m_Tags.tags)
                {
                    sb.Append($"\"{pair.Key}\" = \"{pair.Value}\" ");
                }
                sb.Append("}\n");
            }
            return sb.ToString();
        }

        private static string ConvertSerializedProperties(SerializedProperties m_PropInfo)
        {
            var sb = new StringBuilder();
            sb.Append("Properties {\n");
            foreach (var m_Prop in m_PropInfo.m_Props)
            {
                sb.Append(ConvertSerializedProperty(m_Prop));
            }
            sb.Append("}\n");
            return sb.ToString();
        }

        private static string ConvertSerializedProperty(SerializedProperty m_Prop)
        {
            var sb = new StringBuilder();
            foreach (var m_Attribute in m_Prop.m_Attributes)
            {
                sb.Append($"[{m_Attribute}] ");
            }
            //TODO Flag
            sb.Append($"{m_Prop.m_Name} (\"{m_Prop.m_Description}\", ");
            switch (m_Prop.m_Type)
            {
                case SerializedPropertyType.kColor:
                    sb.Append("Color");
                    break;
                case SerializedPropertyType.kVector:
                    sb.Append("Vector");
                    break;
                case SerializedPropertyType.kFloat:
                    sb.Append("Float");
                    break;
                case SerializedPropertyType.kRange:
                    sb.Append($"Range({m_Prop.m_DefValue[1]}, {m_Prop.m_DefValue[2]})");
                    break;
                case SerializedPropertyType.kTexture:
                    switch (m_Prop.m_DefTexture.m_TexDim)
                    {
                        case TextureDimension.kTexDimAny:
                            sb.Append("any");
                            break;
                        case TextureDimension.kTexDim2D:
                            sb.Append("2D");
                            break;
                        case TextureDimension.kTexDim3D:
                            sb.Append("3D");
                            break;
                        case TextureDimension.kTexDimCUBE:
                            sb.Append("Cube");
                            break;
                        case TextureDimension.kTexDim2DArray:
                            sb.Append("2DArray");
                            break;
                        case TextureDimension.kTexDimCubeArray:
                            sb.Append("CubeArray");
                            break;
                    }
                    break;
            }
            sb.Append(") = ");
            switch (m_Prop.m_Type)
            {
                case SerializedPropertyType.kColor:
                case SerializedPropertyType.kVector:
                    sb.Append($"({m_Prop.m_DefValue[0]},{m_Prop.m_DefValue[1]},{m_Prop.m_DefValue[2]},{m_Prop.m_DefValue[3]})");
                    break;
                case SerializedPropertyType.kFloat:
                case SerializedPropertyType.kRange:
                    sb.Append(m_Prop.m_DefValue[0]);
                    break;
                case SerializedPropertyType.kTexture:
                    sb.Append($"\"{m_Prop.m_DefTexture.m_DefaultName}\" {{ }}");
                    break;
                default:
                    throw new ArgumentOutOfRangeException();
            }
            sb.Append("\n");
            return sb.ToString();
        }

        private static bool CheckGpuProgramUsable(ShaderCompilerPlatform platform, ShaderGpuProgramType programType)
        {
            switch (platform)
            {
                case ShaderCompilerPlatform.kShaderCompPlatformGL:
                    return programType == ShaderGpuProgramType.kShaderGpuProgramGLLegacy;
                case ShaderCompilerPlatform.kShaderCompPlatformD3D9:
                    return programType == ShaderGpuProgramType.kShaderGpuProgramDX9VertexSM20
                        || programType == ShaderGpuProgramType.kShaderGpuProgramDX9VertexSM30
                        || programType == ShaderGpuProgramType.kShaderGpuProgramDX9PixelSM20
                        || programType == ShaderGpuProgramType.kShaderGpuProgramDX9PixelSM30;
                case ShaderCompilerPlatform.kShaderCompPlatformXbox360:
                    return programType == ShaderGpuProgramType.kShaderGpuProgramConsoleVS
                        || programType == ShaderGpuProgramType.kShaderGpuProgramConsoleFS
                        || programType == ShaderGpuProgramType.kShaderGpuProgramConsoleHS
                        || programType == ShaderGpuProgramType.kShaderGpuProgramConsoleDS
                        || programType == ShaderGpuProgramType.kShaderGpuProgramConsoleGS;
                case ShaderCompilerPlatform.kShaderCompPlatformPS3:
                    return programType == ShaderGpuProgramType.kShaderGpuProgramConsoleVS
                        || programType == ShaderGpuProgramType.kShaderGpuProgramConsoleFS
                        || programType == ShaderGpuProgramType.kShaderGpuProgramConsoleHS
                        || programType == ShaderGpuProgramType.kShaderGpuProgramConsoleDS
                        || programType == ShaderGpuProgramType.kShaderGpuProgramConsoleGS;
                case ShaderCompilerPlatform.kShaderCompPlatformD3D11:
                    return programType == ShaderGpuProgramType.kShaderGpuProgramDX11VertexSM40
                        || programType == ShaderGpuProgramType.kShaderGpuProgramDX11VertexSM50
                        || programType == ShaderGpuProgramType.kShaderGpuProgramDX11PixelSM40
                        || programType == ShaderGpuProgramType.kShaderGpuProgramDX11PixelSM50
                        || programType == ShaderGpuProgramType.kShaderGpuProgramDX11GeometrySM40
                        || programType == ShaderGpuProgramType.kShaderGpuProgramDX11GeometrySM50
                        || programType == ShaderGpuProgramType.kShaderGpuProgramDX11HullSM50
                        || programType == ShaderGpuProgramType.kShaderGpuProgramDX11DomainSM50;
                case ShaderCompilerPlatform.kShaderCompPlatformGLES20:
                    return programType == ShaderGpuProgramType.kShaderGpuProgramGLES;
                case ShaderCompilerPlatform.kShaderCompPlatformNaCl: //Obsolete
                    throw new NotSupportedException();
                case ShaderCompilerPlatform.kShaderCompPlatformFlash: //Obsolete
                    throw new NotSupportedException();
                case ShaderCompilerPlatform.kShaderCompPlatformD3D11_9x:
                    return programType == ShaderGpuProgramType.kShaderGpuProgramDX10Level9Vertex
                        || programType == ShaderGpuProgramType.kShaderGpuProgramDX10Level9Pixel;
                case ShaderCompilerPlatform.kShaderCompPlatformGLES3Plus:
                    return programType == ShaderGpuProgramType.kShaderGpuProgramGLES31AEP
                        || programType == ShaderGpuProgramType.kShaderGpuProgramGLES31
                        || programType == ShaderGpuProgramType.kShaderGpuProgramGLES3;
                case ShaderCompilerPlatform.kShaderCompPlatformPSP2:
                    return programType == ShaderGpuProgramType.kShaderGpuProgramConsoleVS
                        || programType == ShaderGpuProgramType.kShaderGpuProgramConsoleFS
                        || programType == ShaderGpuProgramType.kShaderGpuProgramConsoleHS
                        || programType == ShaderGpuProgramType.kShaderGpuProgramConsoleDS
                        || programType == ShaderGpuProgramType.kShaderGpuProgramConsoleGS;
                case ShaderCompilerPlatform.kShaderCompPlatformPS4:
                    return programType == ShaderGpuProgramType.kShaderGpuProgramConsoleVS
                        || programType == ShaderGpuProgramType.kShaderGpuProgramConsoleFS
                        || programType == ShaderGpuProgramType.kShaderGpuProgramConsoleHS
                        || programType == ShaderGpuProgramType.kShaderGpuProgramConsoleDS
                        || programType == ShaderGpuProgramType.kShaderGpuProgramConsoleGS;
                case ShaderCompilerPlatform.kShaderCompPlatformXboxOne:
                    return programType == ShaderGpuProgramType.kShaderGpuProgramConsoleVS
                        || programType == ShaderGpuProgramType.kShaderGpuProgramConsoleFS
                        || programType == ShaderGpuProgramType.kShaderGpuProgramConsoleHS
                        || programType == ShaderGpuProgramType.kShaderGpuProgramConsoleDS
                        || programType == ShaderGpuProgramType.kShaderGpuProgramConsoleGS;
                case ShaderCompilerPlatform.kShaderCompPlatformPSM: //Unknown
                    throw new NotSupportedException();
                case ShaderCompilerPlatform.kShaderCompPlatformMetal:
                    return programType == ShaderGpuProgramType.kShaderGpuProgramMetalVS
                        || programType == ShaderGpuProgramType.kShaderGpuProgramMetalFS;
                case ShaderCompilerPlatform.kShaderCompPlatformOpenGLCore:
                    return programType == ShaderGpuProgramType.kShaderGpuProgramGLCore32
                        || programType == ShaderGpuProgramType.kShaderGpuProgramGLCore41
                        || programType == ShaderGpuProgramType.kShaderGpuProgramGLCore43;
                case ShaderCompilerPlatform.kShaderCompPlatformN3DS:
                    return programType == ShaderGpuProgramType.kShaderGpuProgramConsoleVS
                        || programType == ShaderGpuProgramType.kShaderGpuProgramConsoleFS
                        || programType == ShaderGpuProgramType.kShaderGpuProgramConsoleHS
                        || programType == ShaderGpuProgramType.kShaderGpuProgramConsoleDS
                        || programType == ShaderGpuProgramType.kShaderGpuProgramConsoleGS;
                case ShaderCompilerPlatform.kShaderCompPlatformWiiU:
                    return programType == ShaderGpuProgramType.kShaderGpuProgramConsoleVS
                        || programType == ShaderGpuProgramType.kShaderGpuProgramConsoleFS
                        || programType == ShaderGpuProgramType.kShaderGpuProgramConsoleHS
                        || programType == ShaderGpuProgramType.kShaderGpuProgramConsoleDS
                        || programType == ShaderGpuProgramType.kShaderGpuProgramConsoleGS;
                case ShaderCompilerPlatform.kShaderCompPlatformVulkan:
                    return programType == ShaderGpuProgramType.kShaderGpuProgramSPIRV;
                case ShaderCompilerPlatform.kShaderCompPlatformSwitch:
                    return programType == ShaderGpuProgramType.kShaderGpuProgramConsoleVS
                        || programType == ShaderGpuProgramType.kShaderGpuProgramConsoleFS
                        || programType == ShaderGpuProgramType.kShaderGpuProgramConsoleHS
                        || programType == ShaderGpuProgramType.kShaderGpuProgramConsoleDS
                        || programType == ShaderGpuProgramType.kShaderGpuProgramConsoleGS;
                case ShaderCompilerPlatform.kShaderCompPlatformXboxOneD3D12:
                    return programType == ShaderGpuProgramType.kShaderGpuProgramConsoleVS
                        || programType == ShaderGpuProgramType.kShaderGpuProgramConsoleFS
                        || programType == ShaderGpuProgramType.kShaderGpuProgramConsoleHS
                        || programType == ShaderGpuProgramType.kShaderGpuProgramConsoleDS
                        || programType == ShaderGpuProgramType.kShaderGpuProgramConsoleGS;
                default:
                    throw new NotSupportedException();
            }
        }

        public static string GetPlatformString(ShaderCompilerPlatform platform)
        {
            switch (platform)
            {
                case ShaderCompilerPlatform.kShaderCompPlatformGL:
                    return "openGL";
                case ShaderCompilerPlatform.kShaderCompPlatformD3D9:
                    return "d3d9";
                case ShaderCompilerPlatform.kShaderCompPlatformXbox360:
                    return "xbox360";
                case ShaderCompilerPlatform.kShaderCompPlatformPS3:
                    return "ps3";
                case ShaderCompilerPlatform.kShaderCompPlatformD3D11:
                    return "d3d11";
                case ShaderCompilerPlatform.kShaderCompPlatformGLES20:
                    return "gles";
                case ShaderCompilerPlatform.kShaderCompPlatformNaCl:
                    return "glesdesktop";
                case ShaderCompilerPlatform.kShaderCompPlatformFlash:
                    return "flash";
                case ShaderCompilerPlatform.kShaderCompPlatformD3D11_9x:
                    return "d3d11_9x";
                case ShaderCompilerPlatform.kShaderCompPlatformGLES3Plus:
                    return "gles3";
                case ShaderCompilerPlatform.kShaderCompPlatformPSP2:
                    return "psp2";
                case ShaderCompilerPlatform.kShaderCompPlatformPS4:
                    return "ps4";
                case ShaderCompilerPlatform.kShaderCompPlatformXboxOne:
                    return "xboxone";
                case ShaderCompilerPlatform.kShaderCompPlatformPSM:
                    return "psm";
                case ShaderCompilerPlatform.kShaderCompPlatformMetal:
                    return "metal";
                case ShaderCompilerPlatform.kShaderCompPlatformOpenGLCore:
                    return "glcore";
                case ShaderCompilerPlatform.kShaderCompPlatformN3DS:
                    return "n3ds";
                case ShaderCompilerPlatform.kShaderCompPlatformWiiU:
                    return "wiiu";
                case ShaderCompilerPlatform.kShaderCompPlatformVulkan:
                    return "vulkan";
                case ShaderCompilerPlatform.kShaderCompPlatformSwitch:
                    return "switch";
                case ShaderCompilerPlatform.kShaderCompPlatformXboxOneD3D12:
                    return "xboxone_d3d12";
                default:
                    return "unknown";
            }
        }

        private static string header = "//////////////////////////////////////////\n" +
                                      "//\n" +
                                      "// NOTE: This is *not* a valid shader file\n" +
                                      "//\n" +
                                      "///////////////////////////////////////////\n";
    }

    public class ShaderProgram
    {
        public ShaderSubProgram[] m_SubPrograms;

        public ShaderProgram(BinaryReader reader, int[] version)
        {
            var subProgramsCapacity = reader.ReadInt32();
            m_SubPrograms = new ShaderSubProgram[subProgramsCapacity];
            int entrySize;
            if (version[0] > 2019 || (version[0] == 2019 && version[1] >= 3)) //2019.3 and up
            {
                entrySize = 12;
            }
            else
            {
                entrySize = 8;
            }
            for (int i = 0; i < subProgramsCapacity; i++)
            {
                reader.BaseStream.Position = 4 + i * entrySize;
                var offset = reader.ReadInt32();
                reader.BaseStream.Position = offset;
                m_SubPrograms[i] = new ShaderSubProgram(reader);
            }
        }

        public string Export(string shader)
        {
            var evaluator = new MatchEvaluator(match =>
            {
                var index = int.Parse(match.Groups[1].Value);
                return m_SubPrograms[index].Export();
            });
            shader = Regex.Replace(shader, "GpuProgramIndex (.+)", evaluator);
            return shader;
        }
    }

    public class ShaderSubProgram
    {
        private int m_Version;
        public ShaderGpuProgramType m_ProgramType;
        public string[] m_Keywords;
        public string[] m_LocalKeywords;
        public byte[] m_ProgramCode;

        public ShaderSubProgram(BinaryReader reader)
        {
            //LoadGpuProgramFromData
            //201509030 - Unity 5.3
            //201510240 - Unity 5.4
            //201608170 - Unity 5.5
            //201609010 - Unity 5.6, 2017.1 & 2017.2
            //201708220 - Unity 2017.3, Unity 2017.4 & Unity 2018.1
            //201802150 - Unity 2018.2 & Unity 2018.3
            //201806140 - Unity 2019.1~2020.1
            m_Version = reader.ReadInt32();
            m_ProgramType = (ShaderGpuProgramType)reader.ReadInt32();
            reader.BaseStream.Position += 12;
            if (m_Version >= 201608170)
            {
                reader.BaseStream.Position += 4;
            }
            var m_KeywordsSize = reader.ReadInt32();
            m_Keywords = new string[m_KeywordsSize];
            for (int i = 0; i < m_KeywordsSize; i++)
            {
                m_Keywords[i] = reader.ReadAlignedString();
            }
            if (m_Version >= 201806140)
            {
                var m_LocalKeywordsSize = reader.ReadInt32();
                m_LocalKeywords = new string[m_LocalKeywordsSize];
                for (int i = 0; i < m_LocalKeywordsSize; i++)
                {
                    m_LocalKeywords[i] = reader.ReadAlignedString();
                }
            }
            m_ProgramCode = reader.ReadBytes(reader.ReadInt32());
            reader.AlignStream();

            //TODO
        }

        public string Export()
        {
            var sb = new StringBuilder();
            if (m_Keywords.Length > 0)
            {
                sb.Append("Keywords { ");
                foreach (string keyword in m_Keywords)
                {
                    sb.Append($"\"{keyword}\" ");
                }
                sb.Append("}\n");
            }
            if (m_LocalKeywords != null && m_LocalKeywords.Length > 0)
            {
                sb.Append("Local Keywords { ");
                foreach (string keyword in m_LocalKeywords)
                {
                    sb.Append($"\"{keyword}\" ");
                }
                sb.Append("}\n");
            }

            sb.Append("\"");
            if (m_ProgramCode.Length > 0)
            {
                switch (m_ProgramType)
                {
                    case ShaderGpuProgramType.kShaderGpuProgramGLLegacy:
                    case ShaderGpuProgramType.kShaderGpuProgramGLES31AEP:
                    case ShaderGpuProgramType.kShaderGpuProgramGLES31:
                    case ShaderGpuProgramType.kShaderGpuProgramGLES3:
                    case ShaderGpuProgramType.kShaderGpuProgramGLES:
                    case ShaderGpuProgramType.kShaderGpuProgramGLCore32:
                    case ShaderGpuProgramType.kShaderGpuProgramGLCore41:
                    case ShaderGpuProgramType.kShaderGpuProgramGLCore43:
                        sb.Append(Encoding.UTF8.GetString(m_ProgramCode));
                        break;
                    case ShaderGpuProgramType.kShaderGpuProgramDX9VertexSM20:
                    case ShaderGpuProgramType.kShaderGpuProgramDX9VertexSM30:
                    case ShaderGpuProgramType.kShaderGpuProgramDX9PixelSM20:
                    case ShaderGpuProgramType.kShaderGpuProgramDX9PixelSM30:
                        {
                            /*var shaderBytecode = new ShaderBytecode(m_ProgramCode);
                            sb.Append(shaderBytecode.Disassemble());*/
                            sb.Append("// shader disassembly not supported on DXBC");
                            break;
                        }
                    case ShaderGpuProgramType.kShaderGpuProgramDX10Level9Vertex:
                    case ShaderGpuProgramType.kShaderGpuProgramDX10Level9Pixel:
                    case ShaderGpuProgramType.kShaderGpuProgramDX11VertexSM40:
                    case ShaderGpuProgramType.kShaderGpuProgramDX11VertexSM50:
                    case ShaderGpuProgramType.kShaderGpuProgramDX11PixelSM40:
                    case ShaderGpuProgramType.kShaderGpuProgramDX11PixelSM50:
                    case ShaderGpuProgramType.kShaderGpuProgramDX11GeometrySM40:
                    case ShaderGpuProgramType.kShaderGpuProgramDX11GeometrySM50:
                    case ShaderGpuProgramType.kShaderGpuProgramDX11HullSM50:
                    case ShaderGpuProgramType.kShaderGpuProgramDX11DomainSM50:
                        {
                            /*int start = 6;
                            if (m_Version == 201509030) // 5.3
                            {
                                start = 5;
                            }
                            var buff = new byte[m_ProgramCode.Length - start];
                            Buffer.BlockCopy(m_ProgramCode, start, buff, 0, buff.Length);
                            var shaderBytecode = new ShaderBytecode(buff);
                            sb.Append(shaderBytecode.Disassemble());*/
                            sb.Append("// shader disassembly not supported on DXBC");
                            break;
                        }
                    case ShaderGpuProgramType.kShaderGpuProgramMetalVS:
                    case ShaderGpuProgramType.kShaderGpuProgramMetalFS:
                        using (var reader = new BinaryReader(new MemoryStream(m_ProgramCode)))
                        {
                            var fourCC = reader.ReadUInt32();
                            if (fourCC == 0xf00dcafe)
                            {
                                int offset = reader.ReadInt32();
                                reader.BaseStream.Position = offset;
                            }
                            var entryName = reader.ReadStringToNull();
                            var buff = reader.ReadBytes((int)(reader.BaseStream.Length - reader.BaseStream.Position));
                            sb.Append(Encoding.UTF8.GetString(buff));
                        }
                        break;
                    case ShaderGpuProgramType.kShaderGpuProgramSPIRV:
                        try
                        {
                            sb.Append(SpirVShaderConverter.Convert(m_ProgramCode));
                        }
                        catch (Exception e)
                        {
                            sb.Append($"// disassembly error {e.Message}\n");
                        }
                        break;
                    case ShaderGpuProgramType.kShaderGpuProgramConsoleVS:
                    case ShaderGpuProgramType.kShaderGpuProgramConsoleFS:
                    case ShaderGpuProgramType.kShaderGpuProgramConsoleHS:
                    case ShaderGpuProgramType.kShaderGpuProgramConsoleDS:
                    case ShaderGpuProgramType.kShaderGpuProgramConsoleGS:
                        sb.Append(Encoding.UTF8.GetString(m_ProgramCode));
                        break;
                    default:
                        sb.Append($"//shader disassembly not supported on {m_ProgramType}");
                        break;
                }
            }
            sb.Append('"');
            return sb.ToString();
        }
    }
}