using System.IO;
using NUnit.Framework;
using UnityEngine;
using UniJSON;
using System;
using UniGLTF;
using System.Runtime.InteropServices;
using System.Collections.Generic;
using VRMShaders;

namespace UniVRM10
{
    public class MigrationTests
    {
        static string AliciaPath
        {
            get
            {
                return Path.GetFullPath(Application.dataPath + "/../Tests/Models/Alicia_vrm-0.51/AliciaSolid_vrm-0.51.vrm")
                    .Replace("\\", "/");
            }
        }

        static JsonNode GetVRM0(byte[] bytes)
        {
            using (var glb = new GlbBinaryParser(bytes, "vrm0").Parse())
            {
                var json = glb.Json.ParseAsJson();
                return json["extensions"]["VRM"];
            }
        }

        T GetExtension<T>(UniGLTF.glTFExtension extensions, UniJSON.Utf8String key, Func<JsonNode, T> deserializer)
        {
            if (extensions is UniGLTF.glTFExtensionImport import)
            {
                foreach (var kv in import.ObjectItems())
                {
                    if (kv.Key.GetUtf8String() == key)
                    {
                        return deserializer(kv.Value);
                    }
                }
            }

            return default;
        }

        [Test]
        public void Migrate0to1()
        {
            var vrm0Bytes = File.ReadAllBytes(AliciaPath);
            var vrm0Json = GetVRM0(vrm0Bytes);

            var vrm1 = MigrationVrm.Migrate(vrm0Bytes);
            using (var glb = new GlbBinaryParser(vrm1, "vrm1").Parse())
            {
                var json = glb.Json.ParseAsJson();
                var gltf = UniGLTF.GltfDeserializer.Deserialize(json);

                MigrationVrm.Check(vrm0Json, GetExtension(gltf.extensions, UniGLTF.Extensions.VRMC_vrm.GltfDeserializer.ExtensionNameUtf8,
                    UniGLTF.Extensions.VRMC_vrm.GltfDeserializer.Deserialize), MigrationVrm.CreateMeshToNode(gltf));
                MigrationVrm.Check(vrm0Json, GetExtension(gltf.extensions, UniGLTF.Extensions.VRMC_springBone.GltfDeserializer.ExtensionNameUtf8,
                    UniGLTF.Extensions.VRMC_springBone.GltfDeserializer.Deserialize), gltf.nodes);
            }
        }

        const float EPS = 1e-4f;

        static bool Nearly(float l, float r)
        {
            return Mathf.Abs(l - r) <= EPS;
        }

        static bool Nearly(Vector3 l, Vector3 r)
        {
            if (!Nearly(l.x, r.x)) return false;
            if (!Nearly(l.y, r.y)) return false;
            if (!Nearly(l.z, r.z)) return false;
            return true;
        }

        [Test]
        public void RotateY180Test()
        {
            var euler = new Vector3(0, 10, 20);
            var r = Quaternion.Euler(euler);
            var node = new glTFNode
            {
                translation = new float[] { 1, 2, 3 },
                // rotation = new float[] { r.x, r.y, r.z, r.w },
                scale = new float[] { 1, 2, 3 },
            };
            RotateY180.Rotate(node);

            Assert.AreEqual(new Vector3(-1, 2, -3), node.translation.ToVector3());
            Assert.AreEqual(new Vector3(1, 2, 3), node.scale.ToVector3());

            // var result = node.rotation.ToQuaternion().ToUnityQuaternion().eulerAngles;
            // Debug.LogFormat($"{result}");

            // Assert.True(Nearly(0, result.x));
            // Assert.True(Nearly(10, result.y));
            // Assert.True(Nearly(20, result.z));
        }

        [Test]
        public void UnityEngineMatrixTest()
        {
            var u = new UnityEngine.Matrix4x4();
            u.m00 = 0;
            u.m01 = 1;
            u.m02 = 2;
            u.m03 = 3;
            u.m10 = 4;
            u.m11 = 5;
            u.m12 = 6;
            u.m13 = 7;
            u.m20 = 8;
            u.m21 = 9;
            u.m22 = 10;
            u.m23 = 11;
            u.m30 = 12;
            u.m31 = 13;
            u.m32 = 14;
            u.m33 = 15;
            Assert.AreEqual(new UnityEngine.Vector4(0, 1, 2, 3), u.GetRow(0));
            var bytes = new Byte[64];
            SafeMarshalCopy.CopyArrayToToBytes(new[] { u }, new ArraySegment<byte>(bytes));
            Assert.AreEqual(1.0f, BitConverter.ToSingle(bytes, 16));
        }

        [Test]
        public void NumericMatrixTest()
        {
            var u = new System.Numerics.Matrix4x4();
            u.M11 = 0;
            u.M12 = 1;
            u.M13 = 2;
            u.M14 = 3;
            u.M21 = 4;
            u.M22 = 5;
            u.M23 = 6;
            u.M24 = 7;
            u.M31 = 8;
            u.M32 = 9;
            u.M33 = 10;
            u.M34 = 11;
            u.M41 = 12;
            u.M42 = 13;
            u.M43 = 14;
            u.M44 = 15;
            var bytes = new Byte[64];
            SafeMarshalCopy.CopyArrayToToBytes(new[] { u }, new ArraySegment<byte>(bytes));
            Assert.AreEqual(1.0f, BitConverter.ToSingle(bytes, 4));
        }

        static IEnumerable<FileInfo> EnumerateGltfFiles(DirectoryInfo dir)
        {
            if (dir.Name == ".git")
            {
                yield break;
            }

            foreach (var child in dir.EnumerateDirectories())
            {
                foreach (var x in EnumerateGltfFiles(child))
                {
                    yield return x;
                }
            }

            foreach (var child in dir.EnumerateFiles())
            {
                switch (child.Extension.ToLower())
                {
                    case ".vrm":
                        yield return child;
                        break;
                }
            }
        }

        [Test]
        public void Migrate_VrmTestModels()
        {
            var env = System.Environment.GetEnvironmentVariable("VRM_TEST_MODELS");
            if (string.IsNullOrEmpty(env))
            {
                return;
            }
            var root = new DirectoryInfo(env);
            if (!root.Exists)
            {
                return;
            }

            foreach (var gltf in EnumerateGltfFiles(root))
            {
                try
                {
                    Vrm10.LoadPathAsync(gltf.FullName, true, controlRigGenerationOption: ControlRigGenerationOption.None).Wait();
                }
                catch (UnNormalizedException)
                {
                    Debug.LogWarning($"[Not Normalized] {gltf}");
                }
            }
        }

        /// <summary>
        /// migration で x が反転することを確認
        /// </summary>
        [Test]
        public void Migrate_SpringBoneTest()
        {
            //
            // vrm0 のオリジナルの値
            //
            var VALUE = new Vector3(-0.0359970331f, -0.0188314915f, 0.00566166639f);
            var bytes0 = File.ReadAllBytes(AliciaPath);
            int groupIndex = default;
            using (var data0 = new GlbLowLevelParser(AliciaPath, bytes0).Parse())
            {
                var json0 = data0.Json.ParseAsJson();
                groupIndex = json0["extensions"]["VRM"]["secondaryAnimation"]["boneGroups"][0]["colliderGroups"][0].GetInt32();
                var x = json0["extensions"]["VRM"]["secondaryAnimation"]["colliderGroups"][groupIndex]["colliders"][0]["offset"]["x"].GetSingle();
                var y = json0["extensions"]["VRM"]["secondaryAnimation"]["colliderGroups"][groupIndex]["colliders"][0]["offset"]["y"].GetSingle();
                var z = json0["extensions"]["VRM"]["secondaryAnimation"]["colliderGroups"][groupIndex]["colliders"][0]["offset"]["z"].GetSingle();
                Assert.AreEqual(VALUE.x, x);
                Assert.AreEqual(VALUE.y, y);
                Assert.AreEqual(VALUE.z, z);
            }

            //
            // vrm1 に migrate
            //
            var bytes1 = MigrationVrm.Migrate(bytes0);
            using (var data1 = new GlbLowLevelParser(AliciaPath, bytes1).Parse())
            {
                Assert.True(UniGLTF.Extensions.VRMC_springBone.GltfDeserializer.TryGet(data1.GLTF.extensions, out UniGLTF.Extensions.VRMC_springBone.VRMC_springBone springBone));
                var spring = springBone.Springs[0];
                // var colliderNodeIndex = spring.ColliderGroups[0];
                // x軸だけが反転する

                var colliderIndex = 0;
                for (int i = 0; i < groupIndex; ++i)
                {
                    colliderIndex += springBone.ColliderGroups[i].Colliders.Length;
                }

                Assert.AreEqual(-VALUE.x, springBone.Colliders[colliderIndex].Shape.Sphere.Offset[0]);
                Assert.AreEqual(VALUE.y, springBone.Colliders[colliderIndex].Shape.Sphere.Offset[1]);
                Assert.AreEqual(VALUE.z, springBone.Colliders[colliderIndex].Shape.Sphere.Offset[2]);
            }
        }

        [Test]
        public void MigrateMeta()
        {
            using (var data = new GlbFileParser(AliciaPath).Parse())
            {
                using (var migrated = Vrm10Data.Migrate(data, out Vrm10Data vrm, out MigrationData migration))
                {
                    Assert.NotNull(vrm);
                    Assert.NotNull(migration);
                }
            }
        }

        class TempFile : IDisposable
        {
            public string Path { get; }

            TempFile(string path)
            {
                Path = path;
            }

            public void Dispose()
            {
                // File.Delete(Path);
            }

            public static TempFile Create(string path, byte[] bytes)
            {
                File.WriteAllBytes(path, bytes);
                return new TempFile(path);
            }
        }

        [Test]
        public void GltfValidator()
        {
            if (!VRMShaders.PathObject.TryGetFromEnvironmentVariable("GLTF_VALIDATOR", out var exe))
            {
                return;
            }
            if (!exe.Exists)
            {
                return;
            }
            using (var data = new GlbFileParser(AliciaPath).Parse())
            using (var migrated = Vrm10Data.Migrate(data, out Vrm10Data vrm, out MigrationData migration))
            {
                var json = GltfJsonUtil.FindUsedExtensionsAndUpdateJson(migrated.Json);
                var glb = Glb.Create(json, new ArraySegment<byte>(migrated.Bin.ToArray())).ToBytes();
                using (var tmp = TempFile.Create("GltfValidator_tmp.glb", glb))
                {
                    var processStartInfo = new System.Diagnostics.ProcessStartInfo(exe.FullPath, $"{tmp.Path} -o")
                    {
                        CreateNoWindow = true,
                        UseShellExecute = false,
                        RedirectStandardOutput = true,
                        RedirectStandardError = true,
                    };

                    var process = System.Diagnostics.Process.Start(processStartInfo);
                    string standardOutput = process.StandardOutput.ReadToEnd();
                    string standardError = process.StandardError.ReadToEnd();
                    int exitCode = process.ExitCode;
                    Debug.Log($"{exitCode}\n{standardOutput}\n{standardError}\n");
                    Assert.AreEqual(0, exitCode);
                }
            }
        }

        [Test]
        public void MigrateMaterials()
        {
            // NOTE: Standard Shader の emission の値がそのまま gamma value として emissiveFactor に出力されていた v0.106.0 のファイル
            var model106 = File.ReadAllBytes(Path.Combine(Application.dataPath, "../Tests/Models/Materials/EmissionMigration_v0.106.0.vrm"));
            // NOTE: Standard Shader の emission の値が linear value に変換されて emissiveFactor に出力される v0.107.0 のファイル
            var model107 = File.ReadAllBytes(Path.Combine(Application.dataPath, "../Tests/Models/Materials/EmissionMigration_v0.107.0.vrm"));

            var materialCount = 6;

            var correctMaterialNames = new string[]
            {
                "Unlit_SRGB_0.5",
                "Standard_Emission_0.5",
                "Standard_Emission_2.0",
                "Unlit_Linear_0.5",
                "MToon_Emission_0.5",
                "MToon_Emission_2.0",
            };
            var correctShaderNames = new string[]
            {
                "UniGLTF/UniUnlit",
                "Standard",
                "Standard",
                "UniGLTF/UniUnlit",
                "VRM10/MToon10",
                "VRM10/MToon10",
            };
            var colorName = "_Color";
            var correctColors = new Color[]
            {
                new Color(0.5f, 0.5f, 0.5f, 1),
                new Color(0f, 0f, 0f, 1),
                new Color(0f, 0f, 0f, 1),
                new Color(Mathf.LinearToGammaSpace(0.5f), Mathf.LinearToGammaSpace(0.5f), Mathf.LinearToGammaSpace(0.5f), 1),
                new Color(0f, 0f, 0f, 1),
                new Color(0f, 0f, 0f, 1),
            };
            var emissionName = "_EmissionColor";
            var correctEmissions = new Color?[]
            {
                null,
                new Color(0.5f, 0.5f, 0.5f, 1),
                new Color(2.0f, 2.0f, 2.0f, 1),
                null,
                new Color(0.5f, 0.5f, 0.5f, 1),
                new Color(2.0f, 2.0f, 2.0f, 1),
            };

            var instance106 = Vrm10.LoadBytesAsync(model106, awaitCaller: new ImmediateCaller()).Result;
            var materials106 = instance106.GetComponent<RuntimeGltfInstance>().Materials;
            Assert.AreEqual(materialCount, materials106.Count);
            for (var idx = 0; idx < materialCount; ++idx)
            {
                var material = materials106[idx];
                Assert.AreEqual(correctMaterialNames[idx], material.name);
                Assert.AreEqual(correctShaderNames[idx], material.shader.name);
                AssertAreApproximatelyEqualColor(correctColors[idx], material.GetColor(colorName));
                if (correctEmissions[idx].HasValue) AssertAreApproximatelyEqualColor(correctEmissions[idx].Value, material.GetColor(emissionName));
            }

            var instance107 = Vrm10.LoadBytesAsync(model107, awaitCaller: new ImmediateCaller()).Result;
            var materials107 = instance107.GetComponent<RuntimeGltfInstance>().Materials;
            Assert.AreEqual(materialCount, materials107.Count);
            for (var idx = 0; idx < materialCount; ++idx)
            {
                var material = materials107[idx];
                Assert.AreEqual(correctMaterialNames[idx], material.name);
                Assert.AreEqual(correctShaderNames[idx], material.shader.name);
                AssertAreApproximatelyEqualColor(correctColors[idx], material.GetColor(colorName));
                if (correctEmissions[idx].HasValue) AssertAreApproximatelyEqualColor(correctEmissions[idx].Value, material.GetColor(emissionName));
            }
        }

        private void AssertAreApproximatelyEqualColor(Color expected, Color actual)
        {
            const float colorEpsilon = 0.5f / 255f;

            Assert.That(actual.r, Is.EqualTo(expected.r).Within(colorEpsilon));
            Assert.That(actual.g, Is.EqualTo(expected.g).Within(colorEpsilon));
            Assert.That(actual.b, Is.EqualTo(expected.b).Within(colorEpsilon));
        }
    }
}