using System;
using System.Collections.Generic;
using System.Linq;
using System.IO;
using System.Threading.Tasks;
using Bfres.Structs;
using SharpYaml;
using SharpYaml.Events;
using SharpYaml.Serialization;
using SharpYaml.Serialization.Serializers;
using Syroot.NintenTools.NSW.Bfres;
using System.Reflection;
using System.Text.RegularExpressions;

namespace FirstPlugin
{
    public class YamlFmaa
    {
        public class AnimConfig
        {
            public string Name { get; set; }
            public string Path { get; set; }
            public bool Loop { get; set; }
            public int FrameCount { get; set; }

            public List<MatAnimConfig> MaterialAnimConfigs { get; set; }

            public void ToYaml(MaterialAnim materialAnim, FMAA.AnimationType animType)
            {
                MaterialAnimConfigs = new List<MatAnimConfig>();

                Name = materialAnim.Name;
                Path = materialAnim.Path;
                FrameCount = materialAnim.FrameCount;
                Loop = materialAnim.Loop;

                foreach (var mat in materialAnim.MaterialAnimDataList)
                {
                    MatAnimConfig matConfig = new MatAnimConfig();
                    matConfig.Name = mat.Name;
                    MaterialAnimConfigs.Add(matConfig);

                    foreach (var paramInfo in mat.ParamAnimInfos)
                    {
                        ParamInfo paramCfg = new ParamInfo();
                        paramCfg.Name = paramInfo.Name;
                        paramCfg.IsConstant = paramInfo.ConstantCount != 0;
                        matConfig.ParamInfos.Add(paramCfg);

                        if (paramInfo.ConstantCount != 0)
                        {
                            paramCfg.Constants = new List<ConstantConfig>();
                            for (int i = 0; i < paramInfo.ConstantCount; i++)
                            {
                                AnimConstant constant = mat.Constants[paramInfo.BeginConstant + i];
                                ConstantConfig ConstantValue = new ConstantConfig();
                                ConstantValue.Offset = ConvertParamOffset(constant.AnimDataOffset, animType);
                                ConstantValue.Value = constant.Value;

                                paramCfg.Constants.Add(ConstantValue);
                            }
                        }

                        if (paramInfo.BeginCurve != ushort.MaxValue)
                        {
                            paramCfg.CurveData = new List<CurveConfig>();
                            for (int i = 0; i < paramInfo.IntCurveCount + paramInfo.FloatCurveCount; i++)
                            {
                                var curve = mat.Curves[(int)paramInfo.BeginCurve + i];
                                var CurveCfg = new CurveConfig();
                                CurveCfg.Offset = ConvertParamOffset(curve.AnimDataOffset, animType);

                                if (curve.Scale == 0)
                                    curve.Scale = 1;

                                for (int f = 0; f < curve.Frames.Length; f++)
                                {
                                    int frame = (int)curve.Frames[f];
                                    float Value = curve.Offset + curve.Keys[f, 0] * curve.Scale;
                                    CurveCfg.KeyFrames.Add(frame, Value);
                                }

                                paramCfg.CurveData.Add(CurveCfg);
                            }
                        }
                    }

                    foreach (var patternInfo in mat.TexturePatternAnimInfos)
                    {
                        PatternInfo infoCfg = new PatternInfo();
                        infoCfg.Name = patternInfo.Name;
                        infoCfg.IsConstant = patternInfo.BeginConstant != ushort.MaxValue;
                        matConfig.TexturePatternInfos.Add(infoCfg);

                        if (infoCfg.IsConstant)
                        {
                            infoCfg.ConstantValue = new ConstantTPConfig();
                            int Index = (int)mat.Constants[(int)patternInfo.BeginConstant].Value;
                            infoCfg.ConstantValue.Texture = materialAnim.TextureNames[Index];
                        }
                        if (patternInfo.CurveIndex != ushort.MaxValue)
                        {
                            var curve = mat.Curves[(int)patternInfo.CurveIndex];
                            infoCfg.CurveData = new CurveTPConfig();

                            if (curve.Scale == 0)
                                curve.Scale = 1;

                            for (int f = 0; f < curve.Frames.Length; f++)
                            {
                                int frame = (int)curve.Frames[f];
                                int Value = (int)curve.Offset + (int)curve.Keys[f, 0] * (int)curve.Scale;

                                infoCfg.CurveData.KeyFrames.Add(frame, materialAnim.TextureNames[Value]);
                            }
                        }
                    }
                }
            }

            private uint ConvertParamOffset(string offset)
            {
                uint val = 0;
                switch (offset)
                {
                    case "R": return 0;
                    case "G": return 4;
                    case "B": return 8;
                    case "A": return 12;
                    case "Mode": return 0;
                    case "Scale X": return 4;
                    case "Scale Y": return 8;
                    case "Rotate": return 12;
                    case "Rotation": return 12;
                    case "Rotation X": return 12;
                    case "Rotate X": return 12;
                    case "Translate X": return 16;
                    case "Translate Y": return 20;
                    default:
                        bool isOffset = uint.TryParse(offset, out val);
                        if (!isOffset)
                            throw new Exception($"Invalid offset value {offset}");
                        break;
                }

                return val;
            }


            private string ConvertParamOffset(uint offset, FMAA.AnimationType animType)
            {
                if (animType== FMAA.AnimationType.Color)
                {
                    switch (offset)
                    {
                        case 0: return "R";
                        case 4: return "G";
                        case 8: return "B";
                        case 12: return "A";
                        default:
                            return offset.ToString();
                    }
                }
                else if (animType == FMAA.AnimationType.TextureSrt)
                {
                    switch (offset)
                    {
                        case 0: return "Mode";
                        case 4: return "Scale X";
                        case 8: return "Scale Y";
                        case 12: return "Rotate";
                        case 16: return "Translate X";
                        case 20: return "Translate Y";
                        default:
                            return offset.ToString();
                    }
                }

                return offset.ToString();
            }

            public MaterialAnim FromYaml()
            {
                MaterialAnim matAnim = new MaterialAnim();
                matAnim.Name = Name;
                matAnim.Path = Path;
                matAnim.Loop = Loop;
                matAnim.FrameCount = FrameCount;
                matAnim.TextureNames = GenerateTextureList();
                matAnim.BindIndices = new ushort[MaterialAnimConfigs.Count];
                for (int i = 0; i < matAnim.BindIndices.Length; i++)
                    matAnim.BindIndices[i] = ushort.MaxValue;

                int ShaderParamCurveIndex = 0;
                int TexturePatternCurveIndex = 0;

                Console.WriteLine("MaterialAnimConfigs " + MaterialAnimConfigs.Count);
                foreach (var matCfg in MaterialAnimConfigs)
                {
                    var matAnimData = new MaterialAnimData();
                    matAnimData.Name = matCfg.Name;
                    matAnimData.Constants = new List<AnimConstant>();
                    matAnimData.Curves = new List<AnimCurve>();
                    matAnimData.TexturePatternAnimInfos = new List<TexturePatternAnimInfo>();
                    matAnimData.ParamAnimInfos = new List<ParamAnimInfo>();
                    matAnimData.BeginVisalConstantIndex = -1;
                    matAnimData.ShaderParamCurveIndex = -1;
                    matAnimData.VisualConstantIndex = -1;
                    matAnimData.TexturePatternCurveIndex = -1;
                    matAnimData.VisalCurveIndex = -1;
                    matAnim.MaterialAnimDataList.Add(matAnimData);

                    ushort CurveIndex = 0;
                    ushort BeginConstantIndex = 0;

                    foreach (var texturePatternCfg in matCfg.TexturePatternInfos)
                    {
                        TexturePatternAnimInfo patternInfo = new TexturePatternAnimInfo();
                        patternInfo.Name = texturePatternCfg.Name;
                        matAnimData.TexturePatternAnimInfos.Add(patternInfo);

                        if (texturePatternCfg.IsConstant && texturePatternCfg.ConstantValue != null)
                        {
                            patternInfo.BeginConstant = BeginConstantIndex++;

                            AnimConstant constant = new AnimConstant();
                            constant.AnimDataOffset = 0;
                            constant.Value = matAnim.TextureNames.IndexOf(texturePatternCfg.ConstantValue.Texture);
                            matAnimData.Constants.Add(constant);

                            matAnimData.VisualConstantIndex = 0;
                            matAnimData.BeginVisalConstantIndex = 0;
                        }
                        else if (texturePatternCfg.CurveData != null)
                        {
                            patternInfo.CurveIndex = CurveIndex++;

                            matAnimData.TexturePatternCurveIndex = TexturePatternCurveIndex;
                            matAnimData.BeginVisalConstantIndex = 0;

                            AnimCurve curve = new AnimCurve();
                            matAnimData.Curves.Add(curve);

                            curve.Offset = 0;
                            curve.AnimDataOffset = 0;
                            curve.Scale = 1;
                            curve.CurveType = AnimCurveType.StepInt;
                            curve.StartFrame = 0;

                            int FrameCount = texturePatternCfg.CurveData.KeyFrames.Count;

                            curve.Frames = new float[FrameCount];
                            curve.Keys = new float[FrameCount, 1];

                            int MaxFrame = 0;
                            int MaxIndex = 0;

                            int i = 0;
                            foreach (var KeyFrame in texturePatternCfg.CurveData.KeyFrames)
                            {
                                int Index = matAnim.TextureNames.IndexOf(KeyFrame.Value);
                                Console.WriteLine($"{Index} {KeyFrame.Value}");

                                curve.Frames[i] = KeyFrame.Key;
                                curve.Keys[i, 0] = Index;

                                MaxFrame = Math.Max(MaxIndex, KeyFrame.Key);
                                MaxIndex = Math.Max(MaxIndex, Index);

                                i++;
                            }

                            curve.EndFrame = curve.Frames.Max();

                            if (curve.Keys.Length > 1)
                            {
                                curve.Delta = curve.Keys[curve.Keys.Length - 1,0] - curve.Keys[0, 0];
                            }

                            if (MaxFrame < byte.MaxValue)
                                curve.FrameType = AnimCurveFrameType.Byte;
                            else if (MaxFrame < ushort.MaxValue)
                                curve.FrameType = AnimCurveFrameType.Decimal10x5;
                            else
                                curve.FrameType = AnimCurveFrameType.Single;

                            if (MaxIndex < byte.MaxValue)
                                curve.KeyType = AnimCurveKeyType.SByte;
                            else if (MaxIndex < ushort.MaxValue)
                                curve.KeyType = AnimCurveKeyType.Int16;
                            else
                                curve.KeyType = AnimCurveKeyType.Single;
                        }
                    }

                    foreach (var paramCfg in matCfg.ParamInfos)
                    {
                        ParamAnimInfo paramInfo = new ParamAnimInfo();
                        paramInfo.Name = paramCfg.Name;
                        matAnimData.ParamAnimInfos.Add(paramInfo);

                        if (paramCfg.Constants != null && paramCfg.Constants.Count > 0)
                        {
                            paramInfo.BeginConstant = BeginConstantIndex;
                            paramInfo.ConstantCount = (ushort)paramCfg.Constants.Count;

                            BeginConstantIndex += (ushort)paramCfg.Constants.Count;
                            foreach (var constantCfg in paramCfg.Constants)
                            {
                                AnimConstant constant = new AnimConstant();
                                constant.AnimDataOffset = ConvertParamOffset(constantCfg.Offset);
                                constant.Value = constantCfg.Value;
                                matAnimData.Constants.Add(constant);
                            }
                        }

                        if (paramCfg.CurveData != null && paramCfg.CurveData.Count > 0)
                        {
                            matAnimData.ShaderParamCurveIndex = ShaderParamCurveIndex;

                            paramInfo.BeginCurve = CurveIndex;
                            paramInfo.FloatCurveCount = (ushort)paramCfg.CurveData.Count;

                            CurveIndex += (ushort)paramCfg.CurveData.Count;
                            foreach (var curveCfg in paramCfg.CurveData)
                            {
                                AnimCurve curve = new AnimCurve();
                                matAnimData.Curves.Add(curve);
                                curve.Offset = 0;
                                curve.AnimDataOffset = ConvertParamOffset(curveCfg.Offset);
                                curve.Scale = 1;
                                curve.CurveType = AnimCurveType.Linear;
                                curve.StartFrame = 0;

                                int MaxFrame = 0;
                                float MaxValue = 0;

                                int FrameCount = curveCfg.KeyFrames.Count;
                                curve.Frames = new float[FrameCount];
                                curve.Keys = new float[FrameCount, 2];

                                int i = 0;
                                var values = curveCfg.KeyFrames.Values.ToList();
                                foreach (var KeyFrame in curveCfg.KeyFrames)
                                {
                                    curve.Frames[i] = KeyFrame.Key;
                                    curve.Keys[i, 0] = KeyFrame.Value;

                                    //Calculate delta
                                    float Delta = 0;
                                    if (i < values.Count - 1)
                                        Delta = values[i + 1] - values[i];

                                    curve.Keys[i, 1] = Delta;

                                    MaxFrame = Math.Max(MaxFrame, KeyFrame.Key);
                                    MaxValue = Math.Max(MaxValue, KeyFrame.Value);
                                    i++;
                                }

                                curve.EndFrame = curve.Frames.Max();

                                if (curve.Keys.Length > 1)
                                {
                                    curve.Delta = values[values.Count - 1] - values[0];
                                }

                                curve.KeyType = AnimCurveKeyType.Single;
                                curve.FrameType = AnimCurveFrameType.Single;

                            /*    if (MaxFrame < byte.MaxValue)
                                    curve.FrameType = AnimCurveFrameType.Byte;
                                else if (MaxFrame < ushort.MaxValue)
                                    curve.FrameType = AnimCurveFrameType.Decimal10x5;
                                else
                                    curve.FrameType = AnimCurveFrameType.Single;

                                if (MaxValue < byte.MaxValue)
                                    curve.KeyType = AnimCurveKeyType.SByte;
                                else if (MaxValue < ushort.MaxValue)
                                    curve.KeyType = AnimCurveKeyType.Int16;
                                else
                                    curve.KeyType = AnimCurveKeyType.Single;*/
                            }
                        }
                    }

                    TexturePatternCurveIndex += matAnimData.TexturePatternAnimInfos.Where(item => item.CurveIndex != uint.MaxValue).ToList().Count;
                    ShaderParamCurveIndex += CurveIndex;
                }

                return matAnim;
            }

            private List<string> GenerateTextureList()
            {
                List<string> Textures = new List<string>();
                foreach (var matCfg in MaterialAnimConfigs)
                {
                    foreach (var texturePatternCfg in matCfg.TexturePatternInfos)
                    {
                        if (texturePatternCfg.ConstantValue != null)
                        {
                            if (!Textures.Contains(texturePatternCfg.ConstantValue.Texture))
                                Textures.Add(texturePatternCfg.ConstantValue.Texture);
                        }

                        if (texturePatternCfg.CurveData == null)
                            continue;

                        foreach (var KeyFrame in texturePatternCfg.CurveData.KeyFrames)
                            if (!Textures.Contains(KeyFrame.Value))
                                Textures.Add(KeyFrame.Value);
                    }
                }

                return Textures;
            }
        }

        public class ConstantConfig
        {
            public string Offset { get; set; }
            public float Value { get; set; }
        }

        public class ConstantTPConfig
        {
            public string Texture { get; set; }
        }

        public class CurveConfig
        {
            public Dictionary<int, float> KeyFrames { get; set; }

            public string Offset;

            public CurveConfig()
            {
                KeyFrames = new Dictionary<int, float>();
            }
        }

        public class CurveTPConfig
        {
            public Dictionary<int, string> KeyFrames { get; set; }

            public CurveTPConfig()
            {
                KeyFrames = new Dictionary<int, string>(); 
            }
        }

        public class MatAnimConfig
        {
            public string Name { get; set; }

            public List<PatternInfo> TexturePatternInfos { get; set; }
            public List<ParamInfo> ParamInfos { get; set; }

            public MatAnimConfig()
            {
                TexturePatternInfos = new List<PatternInfo>();
                ParamInfos = new List<ParamInfo>();
            }
        }

        public class ParamInfo
        {
            public string Name { get; set; }

            public bool IsConstant { get; set; }

            public List<ConstantConfig> Constants { get; set; }

            public List<CurveConfig> CurveData { get; set; }
        }

        public class PatternInfo
        {
            public string Name { get; set; }

            public bool IsConstant { get; set; }

            public ConstantTPConfig ConstantValue { get; set; }

            public CurveTPConfig CurveData { get; set; }
        }

        public static MaterialAnim FromYaml(string Name)
        {
            var serializerSettings = new SerializerSettings()
            {
               // EmitTags = false
            };

            serializerSettings.DefaultStyle = YamlStyle.Any;
            serializerSettings.ComparerForKeySorting = null;
            serializerSettings.RegisterTagMapping("AnimConfig", typeof(AnimConfig));

            var serializer = new Serializer( serializerSettings);
            AnimConfig config = serializer.Deserialize<AnimConfig>(File.ReadAllText(Name));

            return config.FromYaml();
        }

        public static string ToYaml(string Name, MaterialAnim MatAnim, FMAA.AnimationType animType)
        {
            var serializerSettings = new SerializerSettings()
            {
                EmitTags = false,
                EmitAlias = false,
                EmitCapacityForList = false,
                EmitShortTypeName = false
            };

            serializerSettings.DefaultStyle = YamlStyle.Any;
            serializerSettings.ComparerForKeySorting = null;
            serializerSettings.RegisterTagMapping("AnimConfig", typeof(AnimConfig));

            var config = new AnimConfig();
            config.ToYaml(MatAnim, animType);

            var serializer = new Serializer(serializerSettings);
            string yaml = serializer.Serialize(config, typeof(AnimConfig));

            return yaml;
        }

        private void SetConfig()
        {

        }
    }
}