using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using Newtonsoft.Json;
using UnityEditor;
using UnityEditor.AnimatedValues;
using UnityEngine;
using UnityEngine.UI;
using VketCloudGUITools.Runtime;
using VketCloudGUITools.Serialization;
using VketCloudGUITools.Utilities;

namespace VketCloudGUITools.Editor
{

    public class VCEditorCanvasExporter : EditorWindow
    {
        /// <summary>
        /// CanvasのExport前のCheck時のエラーor警告メッセージ、およびメッセージ発生対象
        /// </summary>
        public class CheckMessage
        {
            /// <summary>
            /// メッセージ
            /// </summary>
            public string message;
            /// <summary>
            /// メッセージ発生対象
            /// </summary>
            public UnityEngine.Object obj;

            public Action onDrawAutoFixButton = null;
        }

        public class AutoApplyAutoFixSettings
        {
            public bool activate = false;

            public bool safe = false;
            public bool major = false;
            public bool removeComponent = false;
            public bool hierarchical = false;
            public bool animation = false;

            public bool generateAutoLayer = false;
        }

        private const string prefix = "VketCloudGUIToolsExporter_";
        private const string helliodorDataPathKey = prefix + "HeliodorDataPath";
        private const string unityDataPathKey = prefix + "UnityDataPath";

        string heliodorDataPath = "";
        string unityDataPath = "";
        bool zFlip = true;
        Canvas targetCanvas = null;

        List<CheckMessage> criticalMessages = new List<CheckMessage>();
        List<CheckMessage> errorMessages = new List<CheckMessage>();
        List<CheckMessage> warningMessages = new List<CheckMessage>();

        VCLayerList autoGeneratedLayerList = null;

        bool delayClearMessages = false;
        bool autoFixResolved = false;
        string delayMessage = string.Empty;

        double updateTime = 0;

        private AutoFixErrorHelper _autoFixErrorHelper = null;

        private AnimBool _autoApplyAutoFixExpand = null;

        private AutoApplyAutoFixSettings _autoApplyAutoFix = new AutoApplyAutoFixSettings();
        private bool advancedOptions = false;
        public AutoFixErrorHelper AutoFixError
        {
            get => _autoFixErrorHelper;
            set => _autoFixErrorHelper = value;
        }

        Vector2 scrollPosition;

        readonly Type[] allowedGUIComponents = new Type[]
        {
            typeof(RectTransform),
            typeof(CanvasRenderer),
            typeof(Button),
            typeof(Image),
            typeof(Text),
            typeof(Slider),
            typeof(VCTransform),
            typeof(VCGUIContent),
            typeof(VCButton),
            typeof(VCImage),
            typeof(VCText),
            typeof(VCSlider),
            typeof(VCComment),
        };
        readonly Type[] allowedCanvasComponents = new Type[]
        {
            typeof(RectTransform),
            typeof(Canvas),
            typeof(VCCanvas),
            typeof(CanvasScaler)
        };
        readonly Type[] allowedLayerComponents = new Type[]
        {
            typeof(RectTransform),
            typeof(VCLayerList)
        };

        private void OnEnable()
        {
            heliodorDataPath = EditorPrefs.GetString(helliodorDataPathKey);
            unityDataPath = EditorPrefs.GetString(unityDataPathKey, "Assets");
            EditorApplication.hierarchyChanged += OnExternalChange;
            Undo.undoRedoPerformed += OnExternalChange;

            _autoFixErrorHelper = new AutoFixErrorHelper(this);
            _autoApplyAutoFixExpand = new AnimBool();
            _autoApplyAutoFixExpand.valueChanged.AddListener(Repaint);
        }

        private void OnDisable()
        {
            Undo.undoRedoPerformed -= OnExternalChange;
            EditorApplication.hierarchyChanged -= OnExternalChange;
            EditorPrefs.SetString(helliodorDataPathKey, heliodorDataPath);
            EditorPrefs.SetString(unityDataPathKey, unityDataPath);

            _autoApplyAutoFixExpand.valueChanged.RemoveListener(Repaint);
        }

        private void OnInspectorUpdate()
        {
            Repaint();
        }

        private void OnExternalChange()
        {
            Repaint();
        }

        [MenuItem("VketCloudGUITools/GUI Exporter")]
        private static void Create()
        {
            GetWindow<VCEditorCanvasExporter>("VketCloud GUI Exporter");
        }
        private void OnGUI()
        {
            using (new GUILayout.HorizontalScope())
            {
                heliodorDataPath = EditorGUILayout.TextField("Export Canvas Path", heliodorDataPath);
                if (GUILayout.Button("...", GUILayout.Width(EditorGUIUtility.singleLineHeight)))
                {
                    var path = EditorUtility.SaveFolderPanel("Select Export Folder", heliodorDataPath, "");
                    if (!string.IsNullOrEmpty(path))
                        heliodorDataPath = path;
                }
            }
            
            targetCanvas = EditorGUILayout.ObjectField("Target Canvas", targetCanvas, typeof(Canvas), true) as Canvas;

            advancedOptions = EditorGUILayout.BeginFoldoutHeaderGroup(advancedOptions, "Advanced Options");
            if (advancedOptions)
            {
                EditorGUI.indentLevel++;
                using (new GUILayout.HorizontalScope())
                {
                    unityDataPath = EditorGUILayout.TextField("Assets Output Path", unityDataPath);
                    if (GUILayout.Button("...", GUILayout.Width(EditorGUIUtility.singleLineHeight)))
                    {
                        var path = EditorUtility.SaveFolderPanel("Select Assets Output Folder", unityDataPath, "");
                        if (IsDataPath(path))
                        {
                            path = "Assets" + StlipDataPath(path);
                        }

                        if (!string.IsNullOrEmpty(path))
                            unityDataPath = path;
                    }
                }

                autoGeneratedLayerList = EditorGUILayout.ObjectField("Auto Generated Layer", autoGeneratedLayerList, typeof(VCLayerList), true) as VCLayerList;
                // Error check (Auto cycle)
                if (EditorApplication.timeSinceStartup - updateTime >= 1.0 && Event.current.type == EventType.Layout)
                {
                    ClearMessages();
                    if (targetCanvas != null)
                    {
                        DoErrorCheck();

                        updateTime = EditorApplication.timeSinceStartup;
                    }
                }
                EditorGUI.indentLevel--;
            }


            // Draw Warnings & Auto Fix
            DrawErrorWarningList();

            // Export Button
            EditorGUI.BeginDisabledGroup(criticalMessages.Count > 0);
            if (targetCanvas != null && GUILayout.Button("Export .json"))
            {
                DoExport(targetCanvas);
            }
            EditorGUI.EndDisabledGroup();
        }

        private void DoErrorCheck()
        {
            var vcCanvas = targetCanvas.GetComponent<VCCanvas>();
            bool ok = false;
            if (vcCanvas == null)
            {
                ok = EditorUtility.DisplayDialog("注意", "対象はVCGUICanvasではありません。\n変換処理の可能性があるため、対象はコピーされます。", "OK", "キャンセル");
                if (ok)
                {
                    ConvertCancasToVCGUICanvas();
                }
                else
                {
                    targetCanvas = null;
                }
            }
            else if (vcCanvas != null && targetCanvas != null)
            {
                // Canvas自体のエラーチェック
                CanvasErrorCheck(targetCanvas);

                // Canvasの子要素のエラーチェック
                CanvasChildErrorCheck();

                // 名前の重複を確認
                CheckNameUniquness();
            }
        }

        private void ConvertCancasToVCGUICanvas()
        {
            var sourceTargetCanvas = targetCanvas;
            targetCanvas = Instantiate(targetCanvas);
            // Instantiateすると名前に(Clone)が勝手につくので戻す
            targetCanvas.name = sourceTargetCanvas.name;
            targetCanvas.transform.SetParent(sourceTargetCanvas.transform.parent);
            targetCanvas.transform.localPosition = sourceTargetCanvas.transform.localPosition;
            targetCanvas.transform.localRotation = sourceTargetCanvas.transform.localRotation;
            targetCanvas.transform.localScale = sourceTargetCanvas.transform.localScale;
            var vcCanvas2 = targetCanvas.gameObject.AddComponent<VCCanvas>();
            vcCanvas2.CanvasType = CanvasType.LandScape;
            sourceTargetCanvas.gameObject.SetActive(false);

            Selection.activeObject = targetCanvas;
        }

        private void CanvasChildErrorCheck()
        {
            for (int i = 0; i < targetCanvas.transform.childCount; ++i)
            {
                Transform child = targetCanvas.transform.GetChild(i);
                var canvasRenderer = child.GetComponent<CanvasRenderer>();
                var slider = child.GetComponent<Slider>();
                var childRectTransform = child.GetComponent<RectTransform>();

                if (childRectTransform != null && (slider != null || canvasRenderer != null))
                {
                    AddCriticalMessages("Canvasの直下にGUIコンテンツが存在しています。\nGUIコンテンツはレイヤーが必要です。\n手動でレイヤーに移動するか、[Auto Fix]からレイヤーを自動生成して移動してください。\n[Auto Fix]では、GUIコンテンツの座標などがズレてしまう場合があるため、手動調整を忘れないでください。", child, AutoFixError.Canvas.MoveChildToAutoGeneratedLayer(child, targetCanvas, autoGeneratedLayerList, l => autoGeneratedLayerList = l));
                    if (childRectTransform != null)
                        ContentErrorCheck(childRectTransform);
                }
                else
                {
                    var childRect = child.GetComponent<RectTransform>();

                    if (childRect == null)
                    {
                        AddWarningMessage($"{child.name}[Canvas]直下に、RectTransformではないものがあります。UIではないため、出力時には無視されます。", child, AutoFixError.Misc.RemoveOrConvertToRectTransform(child));
                    }
                    else if (childRect != null)
                    {
                        LayerErrorCheck(childRect);
                    }
                }
            }
        }

        private void CheckNameUniquness()
        {
            Dictionary<string, int> layerListNameCount = new Dictionary<string, int>();

            foreach (Transform decendant in targetCanvas.transform.GetAllDecendants())
            {
                var path = AnimationUtility.CalculateTransformPath(decendant, targetCanvas.transform);

                if (!layerListNameCount.ContainsKey(path))
                {
                    layerListNameCount[path] = 0;
                }
                layerListNameCount[path]++;
            }

            foreach (var kv in layerListNameCount)
            {
                var name = kv.Key;
                var count = kv.Value;

                if (count > 1)
                {
                    AddWarningMessage($"{name}[Content]名前が重複しています。\nPath : {name}\nは同じ階層に{count}個あります。\n予想できない動作を引き起こす可能性があるため、避けてください。", null);
                }
            }
        }

        /// <summary>
        /// エラー＆警告メッセージの一覧を表示
        /// </summary>
        private void DrawErrorWarningList()
        {
            using (var scrollView = new EditorGUILayout.ScrollViewScope(scrollPosition))
            {
                // Undo注意喚起
                if (criticalMessages.Count > 0 || warningMessages.Count > 0 || errorMessages.Count > 0)
                {
                    EditorGUILayout.HelpBox("間違えて[Auto Fix]を押した場合、あわてずにUndoをしてください。Undoに対応済みです。", MessageType.Info);
                }
                else if (targetCanvas != null)
                {
                    EditorGUILayout.HelpBox("エラーメッセージはありません。", MessageType.None);
                }

                _autoApplyAutoFixExpand.target = EditorGUILayout.Foldout(_autoApplyAutoFixExpand.target, "Auto Fix Settings");
                if (EditorGUILayout.BeginFadeGroup(_autoApplyAutoFixExpand.faded))
                {
                    GUILayout.BeginVertical(GUI.skin.box);
                    _autoApplyAutoFix.activate = EditorGUILayout.Toggle("Acticate", _autoApplyAutoFix.activate);

                    var defaultLabelWidth = EditorGUIUtility.labelWidth;
                    EditorGUIUtility.labelWidth = 180f;

                    EditorGUILayout.LabelField("Auto Apply Auto Fix", "Rules");
                    _autoApplyAutoFix.safe = EditorGUILayout.Toggle("Allow: Safe", _autoApplyAutoFix.safe);
                    _autoApplyAutoFix.major = EditorGUILayout.Toggle("Allow: Major Change", _autoApplyAutoFix.major);
                    _autoApplyAutoFix.hierarchical = EditorGUILayout.Toggle("Allow: Hierarchical", _autoApplyAutoFix.hierarchical);
                    _autoApplyAutoFix.removeComponent = EditorGUILayout.Toggle("Allow: Remove Component", _autoApplyAutoFix.removeComponent);
                    _autoApplyAutoFix.animation = EditorGUILayout.Toggle("Allow: Animation", _autoApplyAutoFix.animation);

                    _autoApplyAutoFix.generateAutoLayer = EditorGUILayout.Toggle("Allow: Generate Auto Layer", _autoApplyAutoFix.generateAutoLayer);

                    EditorGUIUtility.labelWidth = defaultLabelWidth;
                    GUILayout.EndVertical();
                }
                EditorGUILayout.EndFadeGroup();

                // 致命的なエラーメッセージ
                using (var criticalScope = new EditorGUILayout.VerticalScope())
                {
                    if (Event.current.type == EventType.Repaint)
                    {
                        EditorGUI.DrawRect(criticalScope.rect, new Color(1f, 0f, 0f, 0.25f));
                    }

                    if (criticalMessages.Count > 0)
                    {
                        EditorGUILayout.HelpBox("この色のメッセージは、修正が必要ですが、その順番によって結果が変わります。\n解決するまでExportが実行できません。", MessageType.Error);
                    }

                    foreach (var message in criticalMessages)
                    {
                        using (new EditorGUILayout.VerticalScope(GUI.skin.box))
                        {
                            using (new EditorGUILayout.HorizontalScope())
                            {
                                EditorGUILayout.HelpBox(message.message, MessageType.Error);

                                if (message.onDrawAutoFixButton != null)
                                {
                                    message.onDrawAutoFixButton();
                                }
                            }
                            using (new EditorGUILayout.HorizontalScope())
                            {
                                if (GUILayout.Button("Select", GUILayout.ExpandWidth(false)))
                                {
                                    Selection.activeObject = message.obj;
                                }
                                EditorGUILayout.ObjectField(message.obj, typeof(UnityEngine.Object), allowSceneObjects: true);
                            }
                        }
                        PostDrawMessage(message);
                        EditorGUILayout.Space();
                    }
                }

                // 警告メッセージ
                if (warningMessages.Count > 0)
                {
                    EditorGUILayout.HelpBox("この色のメッセージは、無視しても自動修正されてHeliodorで再現可能に出力されます。\n[Auto Fix]を押すか、再インポート時に修正済みの値になります。", MessageType.Warning);
                }
                foreach (var message in warningMessages)
                {
                    using (new EditorGUILayout.VerticalScope(GUI.skin.box))
                    {
                        using (new EditorGUILayout.HorizontalScope())
                        {
                            EditorGUILayout.HelpBox(message.message, MessageType.Warning);

                            if (message.onDrawAutoFixButton != null)
                            {
                                message.onDrawAutoFixButton();
                            }
                        }
                        using (new EditorGUILayout.HorizontalScope())
                        {
                            if (GUILayout.Button("Select", GUILayout.ExpandWidth(false)))
                            {
                                Selection.activeObject = message.obj;
                            }
                            EditorGUILayout.ObjectField(message.obj, typeof(UnityEngine.Object), allowSceneObjects: true);
                        }
                    }
                    PostDrawMessage(message);
                    EditorGUILayout.Space();
                }

                // エラーメッセージ
                if (errorMessages.Count > 0)
                {
                    EditorGUILayout.HelpBox("この色のメッセージは、Heliodorで正確に再現できない設定を警告しています。\n[Auto Fix]を押すとHeliodorで可能な動きの設定になります。\n自動修正でレイアウトが変わる可能性があるため、必ず再確認してください。", MessageType.Error);
                }
                foreach (var message in errorMessages)
                {
                    using (new EditorGUILayout.VerticalScope(GUI.skin.box))
                    {
                        using (new EditorGUILayout.HorizontalScope())
                        {
                            EditorGUILayout.HelpBox(message.message, MessageType.Error);
                            if (message.onDrawAutoFixButton != null)
                            {
                                message.onDrawAutoFixButton();
                            }
                        }
                        using (new EditorGUILayout.HorizontalScope())
                        {
                            if (GUILayout.Button("Select", GUILayout.ExpandWidth(false)))
                            {
                                Selection.activeObject = message.obj;
                            }
                            EditorGUILayout.ObjectField(message.obj, typeof(UnityEngine.Object), allowSceneObjects: true);
                        }
                    }
                    EditorGUILayout.Space();
                    PostDrawMessage(message);
                }
                scrollPosition = scrollView.scrollPosition;
            }

            if (Event.current.type == EventType.Repaint)
            {
                if (delayClearMessages)
                {
                    delayClearMessages = false;
                    ClearMessages();
                    AddWarningMessage(delayMessage, null);
                }
            }
        }

        public void DoExport(Canvas targetCanvas)
        {
            // 出力対象が選んでない
            if (targetCanvas == null)
            {
                EditorUtility.DisplayDialog("VketCloud GUI Exporter", "Canvasを指定してください", "OK");
                return;
            }

            // 出力対象にエラーが残っている
            if (criticalMessages.Count > 0)
            {
                EditorUtility.DisplayDialog("VketCloud GUI Exporter", "「致命的なエラー」が残っています。赤背景の警告に、すべて対応してください。", "OK");
                return;
            }

            // Canvasを解析してJson元データのCanvasDefを組み立てる
            Canvas canvasGameObject;
            VCCanvasDef canvasDef;
            VCCanvas vCanvas;
            ExportCanvas(targetCanvas, out canvasGameObject, out canvasDef, out vCanvas);

            // 保存先および関連パラメタを確定
            // CanvasTypeはCanvasJsonファイル内ではなく、ファイル名/フォルダ名で確定される
            DestroyImmediate(canvasGameObject.gameObject);
            var path = EditorUtility.SaveFilePanel("Save Canvas JSON", heliodorDataPath, targetCanvas.name + ".json", "json");

            // 出力先が選ばれなかったので中断
            if (string.IsNullOrEmpty(path))
                return;

            // CanvasTypeを出力先ディレクトリから確定する
            var canvasType = Runtime.CanvasType.None;
            var directoryNames = path.Replace('\\', '/').Split('/').Reverse();
            for (int i = 0; i < directoryNames.Count(); ++i)
            {
                var name = directoryNames.ElementAt(i);
                if (Regex.IsMatch(name, "landscape", RegexOptions.IgnoreCase))
                {
                    canvasType = Runtime.CanvasType.LandScape;
                    break;
                }
                else if (Regex.IsMatch(name, "portrait", RegexOptions.IgnoreCase))
                {
                    canvasType = Runtime.CanvasType.Portrait;
                    break;
                }
            }

            // Portrait設定と出力ディレクトリの不一致がないか確認する
            var landscapeCheck = vCanvas.CanvasType == CanvasType.LandScape && canvasType != CanvasType.LandScape;
            var portraitCheck = vCanvas.CanvasType == CanvasType.Portrait && canvasType != CanvasType.Portrait;
            var folderCheck = landscapeCheck || portraitCheck;

            // 出力ディレクトリがPortrait設定と不一致のとき、安全のためユーザーに確認する
            if (folderCheck && !EditorUtility.DisplayDialog("確認", $"{vCanvas.CanvasType}用Canvasを{canvasType}用のディレクトリに出力します。", "OK", "キャンセル"))
                return;

            // Json出力
            WriteJsonToFile(canvasDef, path);
            EditorUtility.DisplayDialog("VketCloud GUI Exporter", "JSONの出力が完了しました。", "OK");
        }

        private static void WriteJsonToFile(VCCanvasDef canvasDef, string path)
        {
            // Json出力
            JsonSerializer serializer = new JsonSerializer()
            {
                Formatting = Formatting.Indented,
            };

            serializer.Converters.Add(new SingleLineJsonConverter(typeof(int[]), typeof(float[])));

            serializer.FloatFormatHandling = FloatFormatHandling.String;
            using (var fileStream = new FileStream(path, FileMode.Create, FileAccess.Write))
            using (var streamWriter = new StreamWriter(fileStream))
            using (var writer = new JsonTextWriter(streamWriter))
            {
                serializer.Serialize(writer, canvasDef);
            }

            // エンコーディング統一
            if (File.Exists(path))
            {
                var str = File.ReadAllText(path);
                str = str.Replace("\\/", "/");
                using (var sw = new StreamWriter(path, false, new UTF8Encoding(false)))
                    sw.Write(str);
            }
        }

        private void ExportCanvas(Canvas targetCanvas, out Canvas canvasGameObject, out VCCanvasDef canvasDef, out VCCanvas vCanvas)
        {
            canvasGameObject = Instantiate(targetCanvas);
            canvasGameObject.name = "OutputCanvas";
            //JSON出力
            var zMpy = zFlip ? -1 : 1;
            canvasDef = new VCCanvasDef();
            canvasDef.Z = (int)(canvasGameObject.transform.localPosition.z * zMpy);
            vCanvas = canvasGameObject.GetComponent<Runtime.VCCanvas>();
            if (vCanvas != null)
            {
                canvasDef.Version = vCanvas.Version;
                canvasDef.Z = vCanvas.Z;
            }

            canvasDef.Layout = new List<VCLayerDef>();
            foreach (Transform layer in canvasGameObject.transform)
            {
                ExportContents(zMpy, canvasDef, layer);
            }

            var scripts = new List<string>();
            foreach (var textAsset in vCanvas.Scripts)
            {
                var assetPath = AssetDatabase.GetAssetPath(textAsset);
                // Assets/*/Canvas/~ Canvasまでをスキップ
                assetPath = assetPath.Substring(assetPath.IndexOf("/Canvas/",StringComparison.CurrentCulture) + 1);
                scripts.Add(assetPath);
                CopyAssets(textAsset);
            }
            canvasDef.Scripts = scripts.Distinct().ToList();
        }

        private void ExportContents(int zMpy, VCCanvasDef canvasDef, Transform layer)
        {
            var rectTransform = layer.GetComponent<RectTransform>();
            var vLayoutList = layer.GetComponent<VCLayerList>();
            if (rectTransform != null)
            {
                var layerDef = new VCLayerDef();
                layerDef.Name = layer.name;
                layerDef.Show = layer.gameObject.activeSelf;
                layerDef.Z = (int)(rectTransform.localPosition.z * zMpy);
                layerDef.SpreadMode = vLayoutList.SpreadMode;
                layerDef.AutoLoading = vLayoutList.AutoLoading;
                layerDef.Components = vLayoutList.Components;
                layerDef.Mask = ExportLayerMask(vLayoutList);
                layerDef.Gui = new List<VCContentDef>();
                foreach (Transform child in layer.transform)
                {
                    var childRect = child.gameObject.GetComponent<RectTransform>();
                    if (childRect == null)
                        continue;

                    // 関係しうる全てのコンポーネントをチェック
                    var vcTransform = child.gameObject.GetComponent<VCTransform>();
                    var button = child.GetComponent<Button>();
                    var vcButton = child.GetComponent<VCButton>();
                    var image = child.GetComponent<Image>();
                    var vcImage = child.GetComponent<VCImage>();
                    var text = child.GetComponent<Text>();
                    var vcText = child.GetComponent<VCText>();
                    var vcHtml = child.GetComponent<VCHtml>();
                    var slider = child.GetComponent<Slider>();
                    var vcSlider = child.GetComponent<VCSlider>();
                    var vcComment = child.GetComponent<VCComment>();
                    var vcUnknown = child.GetComponent<VCUnknown>();

                    var contentDef = new VCContentDef();
                    contentDef.Name = child.name;
                    contentDef.Show = child.gameObject.activeSelf;

                    // コメント行に限り、Transform情報を保存せずJsonを圧縮する
                    // コメント行でなければ、積極的にVCGUITransformをつけて座標を保存する
                    if (vcTransform == null && vcComment != null)
                    {
                        vcTransform = child.gameObject.AddComponent<VCTransform>();
                        vcTransform.GatherTransform();
                    }

                    // Transformを保存する
                    if (vcTransform != null)
                    {
                        ExportVCGUITransform(childRect, vcTransform, contentDef);
                    }

                    // GUIコンテンツを保存する
                    var vcContent = child.gameObject.GetComponent<Runtime.VCGUIContent>();
                    if (vcContent != null)
                    {
                        ExportVCGUIContent(contentDef, vcContent);
                    }
                    if (button != null || vcButton != null)
                    {   // Export Button
                        ExportButton(layerDef, vcButton, image, contentDef);

                    }
                    else if (image != null)
                    {   // Export Image
                        ExportImage(layerDef, image, vcImage, contentDef);
                    }
                    else if (text != null)
                    {
                        ExportText(layerDef, text, vcText, contentDef);
                    }
                    else if (slider != null || vcSlider != null)
                    {
                        ExportSlider(layerDef, slider, vcSlider, contentDef);
                    }
                    else if (vcHtml != null)
                    {
                        ExportHtml(layerDef, vcHtml, contentDef);
                    }
                    else if (vcComment != null)
                    {
                        ExportComment(layerDef, vcComment, contentDef);
                    }
                    else if (vcUnknown != null)
                    {
                        Debug.LogWarning("[VCGUIUnknown]はエクスポートできません。無視されます。");
                    }
                }
                canvasDef.Layout.Add(layerDef);
            }
        }

        private static void ExportComment(VCLayerDef layerDef, VCComment vcComment, VCContentDef contentDef)
        {
            contentDef.Name = null;
            contentDef.Pos = null;
            contentDef.Size = null;
            contentDef.Pivot = null;
            contentDef.Z = 0;
            contentDef.Anchor = null;
            contentDef.Comment = vcComment.name;
            layerDef.Gui.Add(contentDef);
        }

        private void ExportSlider(VCLayerDef layerDef, Slider slider, VCSlider vcSlider, VCContentDef contentDef)
        {
            if (vcSlider != null)
            {
                contentDef.Type = "Slider";
                var param = new ParamSlider();
                if (!IsBuiltinResource(vcSlider.BaseSprite, out string baseFileName))
                {
                    param.Base = baseFileName;
                    CopyAssets(vcSlider.BaseSprite);
                }
                if (!IsBuiltinResource(vcSlider.FrontSprite, out string frontFileName))
                {
                    param.Front = frontFileName;
                    CopyAssets(vcSlider.FrontSprite);
                }
                if (!IsBuiltinResource(vcSlider.OnHandleSprite, out string onFileName))
                {
                    param.OnName = onFileName;
                    CopyAssets(vcSlider.OnHandleSprite);
                }
                if (!IsBuiltinResource(vcSlider.OffHandleSprite, out string offFileName))
                {
                    param.OffName = offFileName;
                    CopyAssets(vcSlider.OffHandleSprite);
                }

                param.OnSize = vcSlider.Slider.handleRect.sizeDelta.ToVector2Int().ToArray();
                param.OffSize = vcSlider.Slider.handleRect.sizeDelta.ToVector2Int().ToArray();

                contentDef.ParamSlider = param;

                layerDef.Gui.Add(contentDef);
            }
            else if (slider != null)
            {
                contentDef.Type = "Slider";
                var param = new ParamSlider();

                Image handleImage = null;
                Image fillImage = null;
                Image backgroundImage = null;

                if (slider.targetGraphic != null)
                {
                    handleImage = slider.targetGraphic.GetComponent<Image>();
                }
                if (slider.fillRect != null)
                {
                    fillImage = slider.fillRect.GetComponent<Image>();
                }

                var subImages = slider.gameObject.GetComponentsInChildren<Image>();
                backgroundImage = subImages.Where(si => si != fillImage && si != handleImage).FirstOrDefault();

                if (!IsBuiltinResource(backgroundImage, out string baseFileName))
                {
                    param.Base = baseFileName;
                    CopyAssets(backgroundImage);
                }
                if (!IsBuiltinResource(fillImage, out string frontFileName))
                {
                    param.Front = frontFileName;
                    CopyAssets(fillImage);
                }
                if (!IsBuiltinResource(handleImage, out string handleFileName))
                {
                    param.OnName = handleFileName;
                    param.OffName = handleFileName;
                    CopyAssets(handleImage);
                }

                param.OnSize = vcSlider.Slider.handleRect.sizeDelta.ToVector2Int().ToArray();
                param.OffSize = vcSlider.Slider.handleRect.sizeDelta.ToVector2Int().ToArray();

                param.DriveField = vcSlider.DriveField;

                contentDef.ParamSlider = param;

                layerDef.Gui.Add(contentDef);
            }
        }

        private static void ExportText(VCLayerDef layerDef, Text text, VCText vcText, VCContentDef contentDef)
        {
            contentDef.Type = "text";
            var param = new ParamText();
            param.Text = text.text;
            param.FontSize = text.fontSize;
            param.Color = new float[] { text.color.r, text.color.g, text.color.b, text.color.a };
            if (vcText != null)
            {
                if (!string.IsNullOrEmpty(vcText.TextEn))
                {
                    param.TextEn = vcText.TextEn;
                }
                param.Alignment = vcText.Alignment.ToString();
            }
            param.FontFamily = vcText.FontFamily;
            param.CharaSpace = vcText.CharaSpace;
            param.LineSpace = vcText.LineSpace;
            param.OverflowWrap = vcText.OverflowWrap;
            param.URLClickable = vcText.URLClickable;
            param.URLColor = vcText.URLColor;
            contentDef.ParamText = param;
            layerDef.Gui.Add(contentDef);
        }

        private void ExportImage(VCLayerDef layerDef, Image image, VCImage vcImage, VCContentDef contentDef)
        {
            contentDef.Type = "image";
            var param = new ParamImage();
            if (!IsBuiltinResource(image.mainTexture, out string buttonImagePath))
            {
                CopyAssets(image.mainTexture);
                param.Uri = buttonImagePath;
            }
            if (vcImage != null)
            {
                if (vcImage.ToggleList.Count > 0)
                {
                    contentDef.Toggle = new List<VCStateToggleDef>();

                    for (int i = 0; i < vcImage.ToggleList.Count; ++i)
                    {
                        var toggle = vcImage.ToggleList[i];
                        var toggleDef = new VCStateToggleDef()
                        {
                            Name = toggle.Name,
                            State = toggle.State,
                        };

                        contentDef.Toggle.Add(toggleDef);
                    }
                }
                if (vcImage.UVArea != null && vcImage.UVArea.Count == 4)
                {
                    param.UVArea = vcImage.UVArea;
                }
                else
                {
                    param.UVArea = null;
                }
                if (vcImage.UVAreaRate != null && vcImage.UVAreaRate.Count == 4)
                {
                    param.UVAreaRate = vcImage.UVAreaRate;
                }
                else
                {
                    param.UVAreaRate = null;
                }

            }
            contentDef.ParamImage = param;
            layerDef.Gui.Add(contentDef);
        }

        private void ExportButton(VCLayerDef layerDef, VCButton vcButton, Image image, VCContentDef contentDef)
        {
            contentDef.Type = "button";
            var param = new ParamButton();

            if (vcButton != null)
            {
                if (!IsBuiltinResource(vcButton.DefaultImage, out string defaultImagePath))
                {
                    param.FileName = defaultImagePath;
                    CopyAssets(vcButton.DefaultImage);
                }
                if (!IsBuiltinResource(vcButton.OnCursorImage, out string onCursorImagePath))
                {
                    param.OnCursorFileName = onCursorImagePath;
                    CopyAssets(vcButton.OnCursorImage);
                }
                if (!IsBuiltinResource(vcButton.DownImage, out string downImagePath))
                {
                    param.DownFileName = downImagePath;
                    CopyAssets(vcButton.DownImage);
                }
                if (vcButton.ClickAreaImage != null)
                {
                    if (!IsBuiltinResource(vcButton.ClickAreaImage, out string crickAreaImagePath))
                    {
                        param.ClickAreaFileName = crickAreaImagePath;
                        CopyAssets(vcButton.ClickAreaImage);
                    }
                }
                else
                {
                    param.ClickAreaFileName = "";
                }
                if (vcButton.ToggleList.Count > 0)
                {
                    contentDef.Toggle = new List<VCStateToggleDef>();

                    for (int i = 0; i < vcButton.ToggleList.Count; ++i)
                    {
                        var toggle = vcButton.ToggleList[i];
                        var toggleDef = new VCStateToggleDef()
                        {
                            Name = toggle.Name,
                            State = toggle.State,
                        };

                        contentDef.Toggle.Add(toggleDef);
                    }
                }
                contentDef.GUIAction = new List<Dictionary<string, Dictionary<string, object>>>();
                for (int i = 0; i < vcButton.GUIActions.Count; i++)
                {
                    var guiDict = new Dictionary<string, Dictionary<string, object>>();
                    var action = vcButton.GUIActions[i];
                    if (action.GUIActionType == GUIAction.FuncType.Master ||
                        action.GUIActionType == GUIAction.FuncType.World ||
                        action.GUIActionType == GUIAction.FuncType.Voice ||
                        action.GUIActionType == GUIAction.FuncType.SE ||
                        action.GUIActionType == GUIAction.FuncType.SystemSE ||
                        action.GUIActionType == GUIAction.FuncType.Video)
                    {
                        var actionValues = new Dictionary<string, object>(action.GUIAction.GetActionValues);
                        actionValues.Remove("Name");
                        guiDict.Add(action.GUIAction.FuncName, actionValues);
                    }
                    else
                    {
                        guiDict.Add(action.GUIAction.FuncName, action.GUIAction.GetActionValues);
                    }
                    contentDef.GUIAction.Add(guiDict);
                }
            }
            else if (!IsBuiltinResource(image.mainTexture, out string buttonImagePath))
            {
                CopyAssets(image.mainTexture);
                param.FileName = buttonImagePath;
                param.OnCursorFileName = buttonImagePath;
                param.DownFileName = buttonImagePath;
            }
            if (vcButton.UVArea != null && vcButton.UVArea.Count == 4)
            {
                param.UVArea = vcButton.UVArea;
            }
            else
            {
                param.UVArea = null;
            }
            if (vcButton.UVAreaRate != null && vcButton.UVAreaRate.Count == 4)
            {
                param.UVAreaRate = vcButton.UVAreaRate;
            }
            else
            {
                param.UVAreaRate = null;
            }
            if (vcButton.ClickAreaSize != null && vcButton.ClickAreaSize.Count == 2)
            {
                param.ClickAreaSize = vcButton.ClickAreaSize;
            }
            else
            {
                param.ClickAreaSize = null;
            }
            if (vcButton.LTRB != null && vcButton.LTRB.Count == 4)
            {
                param.LTRB = vcButton.LTRB;
            }
            else
            {
                param.LTRB = null;
            }
            if (vcButton.Flick != null && !vcButton.Flick.IsDefaultValue())
            {
                param.Flick = vcButton.Flick;
            }
            else
            {
                param.Flick = null;
            }
            if (vcButton.OnKeyDownMulColor != null && vcButton.OnKeyDownMulColor.Count == 4)
            {
                param.OnKeyDownMulColor = vcButton.OnKeyDownMulColor;
            }
            else
            {
                param.OnKeyDownMulColor = null;
            }
            contentDef.ParamButton = param;
            layerDef.Gui.Add(contentDef);
        }

        private static void ExportVCGUIContent(VCContentDef contentDef, VCGUIContent vcContent)
        {
            contentDef.Portrait = vcContent.Portrait;
            contentDef.Platform = vcContent.Platform;
            contentDef.Language = vcContent.Language;
            contentDef.RaycastTarget = vcContent.RaycastTarget;
        }

        private static void ExportVCGUITransform(RectTransform childRect, VCTransform vcTransform, VCContentDef contentDef)
        {
            contentDef.Pos = new int[] { vcTransform.Pos.x, vcTransform.Pos.y };
            contentDef.Size = new int[] { (int)(vcTransform.Size.x * childRect.localScale.x), (int)(vcTransform.Size.y * childRect.localScale.y) };
            contentDef.Z = (int)vcTransform.Z;
            contentDef.Pivot = new float[] { vcTransform.Pivot.x, vcTransform.Pivot.y };
            contentDef.Anchor = vcTransform.Anchor.ToString();
        }

        private void CopyAssets(UnityEngine.Object obj)
        {
            if (Directory.Exists(heliodorDataPath))
            {
                var resourcePathWithAssets = AssetDatabase.GetAssetPath(obj);
                var resourcePath = resourcePathWithAssets;
                if (resourcePath.StartsWith("Assets/"))
                    resourcePath = resourcePath.Remove(0, (unityDataPath + "/").Length);
                Debug.Log($"Copy Asset: {resourcePathWithAssets} => {heliodorDataPath.Trim() + "/" + resourcePath}");
                if (File.Exists(resourcePathWithAssets))
                    File.Copy(resourcePathWithAssets, heliodorDataPath.Trim() + "/" + resourcePath, true);
            }
            else
                Debug.LogError("Assetのコピーを試みましたが、DataPathが未設定か、存在しません。");
        }

        private void CanvasErrorCheck(Canvas canvas)
        {
            if (canvas.sortingOrder != 0)
                AddErrorMessage($"{canvas.name}[Canvas]:SortingOrderには対応していません。描画順を変更するにはCanvasのZ値を変更してください。", canvas, AutoFixError.Canvas.SortingOrder(canvas));
            if (canvas.pixelPerfect != false)
                AddWarningMessage($"{canvas.name}[Canvas]:PixelPerfectには対応していないため、無視されます。", canvas, AutoFixError.Canvas.PixelPerfect(canvas));
            if (canvas.additionalShaderChannels != AdditionalCanvasShaderChannels.None)
                AddWarningMessage($"{canvas.name}[Canvas]:AdditionalShaderChannelsには対応していないため、無視されます。", canvas, AutoFixError.Canvas.AdditionalShaderCannels(canvas));
            if (canvas.GetComponents<VCCanvas>().Length > 1)
                AddCriticalMessages($"{canvas.name}[Canvas]:VCGUICanvasは、1つだけの必要があります。\n設定が正しいもの1つだけを残して、他を削除してください。", canvas);
            foreach (var component in targetCanvas.GetComponents<Component>())
                if (!allowedCanvasComponents.Contains(component.GetType()))
                    AddErrorMessage($"{targetCanvas.name}[Canvas]:の{component.GetType().Name}コンポーネントは非対応です。\n[Auto Fix]で削除できます。", targetCanvas, AutoFixError.Canvas.RemoveComponent(component));

        }

        private void LayerErrorCheck(RectTransform layer)
        {
            foreach (var component in layer.GetComponents<Component>())
                if (!allowedLayerComponents.Contains(component.GetType()))
                    AddErrorMessage($"{layer.name}[Layer]:コンポーネント{component.GetType().Name}は非対応なため、無視されます。", layer, AutoFixError.Layer.RemoveComponent(component));

            if (layer.anchorMax.x != 1 || layer.anchorMax.y != 1 || layer.anchorMin.x != 0 || layer.anchorMin.y != 0)
                AddWarningMessage($"{layer.name}[Layer]:アンカーがStretch以外に設定されているため、Canvasの大きさとずれてしまう可能性があります。GUIコンテンツの座標などがズレてしまう場合はアンカーをStretchにしてください。", layer, AutoFixError.Layer.Anchor(layer));
            else if (layer.anchoredPosition.x != 0 || layer.anchoredPosition.y != 0 || layer.sizeDelta.x != 0 || layer.sizeDelta.y != 0)
                AddWarningMessage($"{layer.name}[Layer]:Left/Top/Right/Bottom のいずれかの値が0以外なため、Canvasの大きさとずれてしまう可能性があります。GUIコンテンツの座標などがズレてしまう場合は Left/Top/Right/Bottom すべてに0を設定してください。", layer, AutoFixError.Layer.SizeDelta(layer));

            var layerList = layer.GetComponent<VCLayerList>();
            if (layerList == null)
                AddWarningMessage($"{layer.name}[Layer]は、LayerListと推定して自動変換されます。\n[Auto Fix]でLayerListとして明示します。", layer, AutoFixError.Layer.AddLayerListComponent(layer));

            for (int i = 0; i < layer.childCount; ++i)
            {
                var layerChild = layer.GetChild(i);
                var layerChildRect = layerChild.GetComponent<RectTransform>();
                if (layerChildRect != null)
                    ContentErrorCheck(layerChildRect);
                else
                    AddWarningMessage($"{layerChild.name}[Content]RectTransformではないものがあります。UIではないため、出力時には無視されます。", layerChild, AutoFixError.Misc.RemoveOrConvertToRectTransform(layerChild));
            }
        }

        private bool IsBuiltinResource(UnityEngine.Object obj)
        {
            return IsBuiltinResource(obj, out string a);
        }
        private bool IsBuiltinResource(UnityEngine.Object obj, out string resourcePath)
        {
            resourcePath = AssetDatabase.GetAssetPath(obj);
            if (resourcePath.StartsWith("Assets/"))
                resourcePath = resourcePath.Remove(0, (unityDataPath + "/").Length);
            resourcePath = resourcePath.Replace('\\', '/');
            return resourcePath == "Resources/unity_builtin_extra";
        }
        private void ContentErrorCheck(RectTransform content)
        {
            foreach (var component in content.GetComponents<Component>())
                if (!allowedGUIComponents.Contains(component.GetType()))
                    AddErrorMessage($"{content.name}[GUIContent]:コンポーネント{component.GetType().Name}は非対応なため、無視されます。", content, AutoFixError.Content.RemoveComponent(component));

            // 利用可能なコンポーネントをチェック
            var text = content.GetComponent<Text>();
            var vcText = content.GetComponent<VCText>();
            var vcHtml = content.GetComponent<VCHtml>();
            var button = content.GetComponent<Button>();
            var vcButton = content.GetComponent<VCButton>();
            var image = content.GetComponent<Image>();
            var vcImage = content.GetComponent<VCImage>();
            var slider = content.GetComponent<Slider>();
            var vcSlider = content.GetComponent<VCSlider>();
            var layerList = content.GetComponent<VCLayerList>();

            if (layerList != null)
                AddCriticalMessages($"{content.name}[GUIContent]:VCGUILayerListは入れ子構造にできません。\n[Auto Fix]を押してVCGUICanvasの直下まで移動してください。", content, AutoFixError.Content.MoveToParent(content));

            if (content.anchorMax.x != content.anchorMin.x || content.anchorMin.y != content.anchorMin.y)
                AddWarningMessage($"{content.name}[GUIContent]:アンカーにStretchが使用されています。VketCloudではStretchに非対応なためCenterMiddleに自動的に変換して出力を行います。", content, AutoFixError.Content.Anchor(content));
            if (text != null)
            {
                TextContentErrorCheck(content, text, button);
            }
            if (vcHtml != null)
            {
                HtmlContentErrorCheck(content, vcHtml);
            }
            if (button != null)
            {
                ButtonContentErrorCheck(content, button, image);
            }
            if (image != null)
            {
                ImageContentErrorCheck(content, image);
            }
            if (slider != null)
            {
                SliderContentErrorCheck(content, slider);
            }

            // 子オブジェクトが独自法則で配置されるものは検査しない
            bool keepSearchChildren = (slider == null) && (layerList == null);

            if (keepSearchChildren)
            {
                for (int i = 0; i < content.childCount; ++i)
                {
                    var contentChild = content.GetChild(i);
                    var contentChildRect = contentChild.GetComponent<RectTransform>();
                    if (contentChildRect != null)
                    {
                        AddCriticalMessages($"{contentChild.name}[Content]UIの入れ子構造があります。\n入れ子構造は再現できないため、レイヤー内で平坦化する必要があります。\n[Auto Fix]から自動で平坦化を行います。", contentChild, AutoFixError.Content.MoveToParent(contentChild));
                        ContentErrorCheck(contentChildRect);
                    }
                    else
                        AddWarningMessage($"{contentChild.name}[Content]RectTransformではないものがあります。UIではないため、出力時には無視されます。", contentChild, AutoFixError.Misc.RemoveOrConvertToRectTransform(contentChild));
                }
            }
        }

        private void SliderContentErrorCheck(RectTransform content, Slider slider)
        {
            bool hasErrorMissingHandle = false;
            bool hasErrorInvalidHandle = false;
            bool hasErrorMissingFill = false;
            bool hasErrorInvalidFill = false;
            var vcguiSlider = slider.GetComponent<VCSlider>();
            if (slider.transition != Selectable.Transition.SpriteSwap)
                AddErrorMessage($"{content.name}[Slider]:TransitionはSprite Swapのみ対応しています。", slider, AutoFixError.Slider.Transition(slider));

            if (slider.targetGraphic == null || (slider.targetGraphic != null && slider.handleRect != null && slider.targetGraphic.gameObject != slider.handleRect.gameObject))
                AddCriticalMessages($"{content.name}[Slider]:Target Graphicの変更は対応していません。Handleを指定する必要があります。\nデフォルトではSliderの子に「Handle Slide Area/Handle」として保存されていますが、\n名前変更または削除されている可能性があるためAuto Fixできません。", slider, AutoFixError.Slider.UnableToAutoFix(slider));

            if (slider.handleRect == null)
            {
                hasErrorMissingHandle = true;
                AddCriticalMessages($"{content.name}[Slider]:Handle Rectが指定されていません。\nHandle Rectとは「スライダーの掴み」部分です。\nデフォルトではSliderの子に「Handle Slide Area/Handle」として保存されていますが、\n名前変更または削除されている可能性があるためAuto Fixできません。", slider, AutoFixError.Slider.UnableToAutoFix(slider));
            }
            else
            {
                if (
                    slider.handleRect.parent != null &&
                    slider.handleRect.parent.parent != slider.transform)
                {
                    hasErrorInvalidHandle = true;
                    AddCriticalMessages($"{content.name}[Slider]Handle Rectの親子関係が正しくありません。\nHandle Rectは、Sliderの孫である必要があります。", slider, AutoFixError.Slider.UnableToAutoFix(slider));
                }
            }

            if (slider.fillRect == null)
            {
                hasErrorMissingFill = true;
                AddCriticalMessages($"{content.name}[Slider]:Fill Rectが指定されていません。\nHandle Rectとは「スライダーの伸縮」部分です。\nデフォルトではSliderの子に「Fill Area/Fill」として保存されていますが、\n名前変更または削除されている可能性があるためAuto Fixできません。", slider, AutoFixError.Slider.UnableToAutoFix(slider));
            }
            else
            {
                if (
                    slider.fillRect.parent != null &&
                    slider.fillRect.parent.parent != slider.transform)
                {
                    hasErrorInvalidFill = true;
                    AddCriticalMessages($"{content.name}[Slider]Fill Rectの親子関係が正しくありません。\nFill Rectは、Sliderの孫である必要があります。", slider, AutoFixError.Slider.UnableToAutoFix(slider));
                }
            }

            if (slider.navigation.mode != Navigation.Mode.Automatic)
                AddWarningMessage($"{content.name}[Slider]:Navigationの変更は対応していないため、無視されます。", slider, AutoFixError.Selectable.Navigation(slider, "Slider"));

            if (slider.direction != Slider.Direction.LeftToRight)
                AddCriticalMessages($"{content.name}[Slider]:DirectionはLeft To Rightのみサポートしています。\nこの修正は大幅なデザイン変更が予想されるため、可能ならば手動で修正してください。\n[Auto Fix]すると、デザインの整合性を無視してExport可能に変換します。", slider, AutoFixError.Slider.Direction(slider));

            if (slider.minValue != 0f)
                AddErrorMessage($"{content.name}[Slider]:Min Valueは 0 のみサポートしています。", slider, AutoFixError.Slider.MinValue(slider));

            if (slider.maxValue != 1f)
                AddErrorMessage($"{content.name}[Slider]:Max Valueは 1 のみサポートしています。", slider, AutoFixError.Slider.MaxValue(slider));

            if (slider.wholeNumbers != false)
                AddErrorMessage($"{content.name}[Slider]:Whole Numbersは対応していないため、無視されます。", slider, AutoFixError.Slider.WholeNumbers(slider));

            if (slider.value != 0f)
                AddWarningMessage($"{content.name}[Slider]:Valueの初期値の変更は無視されます。", slider, AutoFixError.Slider.Value(slider));

            // Slider内のUIを検証する
            var childImages = slider.GetComponentsInChildren<Graphic>();
            Image handleImage = null;
            Image fillImage = null;
            Image backgroundImage = null;

            var handleGraphic = childImages.FirstOrDefault(ci => ci.gameObject.transform == slider.handleRect);
            var fillGraphic = childImages.FirstOrDefault(ci => ci.gameObject.transform == slider.fillRect);
            var backgroundGraphics = childImages.Where(ci => ci != handleGraphic && ci != fillGraphic).ToList();

            if (!hasErrorMissingHandle && !hasErrorInvalidHandle)
            {
                if (handleGraphic == null)
                    AddErrorMessage($"{content.name}[Slider]:Handle RectにImageがありません。\n出力時には無視されます。", slider, AutoFixError.Slider.UnableToAutoFix(slider));
                else if (handleGraphic != null && !(handleGraphic is Image))
                    AddCriticalMessages($"{content.name}[Slider]:Handle Rectに、ImageではないUIがあります。\n[Auto Fix]は「白塗り画像」に置き換えるため、デザインを大幅に変える可能性があります。", slider, AutoFixError.Slider.UnableToAutoFix(slider));
                else
                    handleImage = handleGraphic as Image;
            }

            if (!hasErrorMissingFill && !hasErrorInvalidFill)
            {
                if (fillGraphic == null)
                    AddErrorMessage($"{content.name}[Slider]:Fill RectにImageがありません。\n出力時には無視されます。", slider, AutoFixError.Slider.UnableToAutoFix(slider));
                else if (fillGraphic != null && !(handleGraphic is Image))
                    AddCriticalMessages($"{content.name}[Slider]:Fill Rectに、ImageではないUIがあります。\nシンプルなImageに置き換えてください。", slider, AutoFixError.Slider.UnableToAutoFix(slider));
                else
                    fillImage = fillGraphic as Image;
            }

            if (backgroundGraphics.Count == 0)
            {
                AddErrorMessage($"{content.name}[Slider]:Backgroundがありません。\nシンプルなImageに置き換えてください。", slider, AutoFixError.Slider.UnableToAutoFix(slider));
            }
            else if (backgroundGraphics.Count == 1)
            {
                bool isImage = backgroundGraphics[0] is Image;
                bool isSliderDirectChild = backgroundGraphics[0].transform.parent == slider.transform;
                bool hasVSlider = vcguiSlider != null;
                if (isImage && isSliderDirectChild && !hasVSlider)
                {
                    // Slider直下にImageが1つだけあるなら、正しくBackgroundとなる。
                    backgroundImage = backgroundGraphics[0] as Image;
                }
                else if (!isImage || !isSliderDirectChild)
                {
                    AddCriticalMessages($"{content.name}[Slider]:過度に複雑な子要素を持っています。\n構造の推定が困難であるため、自動修正できません。", slider, AutoFixError.Slider.UnableToAutoFix(slider));
                }
            }
            else
            {
                AddCriticalMessages($"{content.name}[Slider]:過度に複雑な子要素を持っています。\n「背景」「スライダー棒」「ハンドル」の３つ以外があります。\n構造の推定が困難であるため、自動修正できません。", slider, AutoFixError.Slider.UnableToAutoFix(slider));
            }

            // 必須Imageを検証する。特にUnityで自動生成したときの問題を直す
            if (fillImage != null)
                CheckSliderFillImageError(slider, fillImage);

            if (handleImage != null)
                CheckSliderHandleImageError(slider, handleImage);

            if (vcguiSlider != null)
            {
                if (vcguiSlider.unityFrontImage == null)
                    AddCriticalMessages($"{content.name}[VCGUISlider]:unityFrontImageがありません。\n参照が壊れているため、Importしなおすか、Fill RectのImageを設定しなおしてください。", slider, AutoFixError.Slider.UnableToAutoFix(slider));
                if (vcguiSlider.unityBaseImage == null)
                    AddCriticalMessages($"{content.name}[VCGUISlider]:unityBaseImageがありません。\n参照が壊れているため、Importしなおすか、BackgroundのImageを設定しなおしてください。", slider, AutoFixError.Slider.UnableToAutoFix(slider));
                if (vcguiSlider.unityHandleImage == null)
                    AddCriticalMessages($"{content.name}[VCGUISlider]:unityHandleImageがありません。\n参照が壊れているため、Importしなおすか、Handle RectのImageを設定しなおしてください。", slider, AutoFixError.Slider.UnableToAutoFix(slider));
            }
        }

        public void CheckSliderFillImageError(Slider slider, Image fillImage)
        {
            var fillArea = fillImage.transform.parent as RectTransform;

            // 順番に解消しないと位置ずれるので排他表示
            if (fillArea.anchorMin.x != 0f || fillArea.anchorMin.y != 0f || fillArea.anchorMax.x != 1f || fillArea.anchorMax.y != 1f)
                AddErrorMessage($"{slider.name}[Slider]:Fill AreaのAnchorがStretchではありません。\nエクスポート時にStretchに自動修正されます。", fillArea, AutoFixError.Slider.FillAreaErrorAnchor(fillArea));
            else if (fillArea.pivot != VectorUtility.half2D)
                AddErrorMessage($"{slider.name}[Slider]:Fill AreaのPivotがMiddleCenterではありません。\nエクスポート時にMiddleCenterに自動修正されます。", fillArea, AutoFixError.Slider.FillAreaErrorPivot(fillArea));
        }

        private void CheckSliderHandleImageError(Slider slider, Image handleImage)
        {
            var handleSlideArea = handleImage.transform.parent as RectTransform;

            // 順番に解消しないと位置ずれるので排他表示
            if (handleSlideArea.anchorMin.x != 0f || handleSlideArea.anchorMin.y != 0.5f || handleSlideArea.anchorMax.x != 1f || handleSlideArea.anchorMax.y != 0.5f)
                AddErrorMessage($"{slider.name}[Slider]:Handle Slide AreaのAnchorがMiddleStretchではありません。\nエクスポート時にMiddleStretchに自動修正されます。", handleSlideArea, AutoFixError.Slider.HandleSlideAreaErrorAnchor(handleSlideArea));
            else if (handleSlideArea.pivot.x != 0.5f || handleSlideArea.pivot.y != 0.5f)
                AddErrorMessage($"{slider.name}[Slider]:Handle Slide AreaのPivotがMiddleCenterではありません。\nエクスポート時にMiddleCenterに自動修正されます。", handleSlideArea, AutoFixError.Slider.HandleSlideAreaPivot(handleSlideArea));
            else if (handleSlideArea.anchoredPosition.x != 0f || handleSlideArea.anchoredPosition.y != 0f || handleSlideArea.sizeDelta.x != 0f || handleSlideArea.sizeDelta.y != 0f)
                AddErrorMessage($"{slider.name}[Slider]:Handle Slide AreaのLeft/Pos Y/Right/Heightが0ではありません。\nエクスポート時にMiddleCenterに自動修正されます。", handleSlideArea, AutoFixError.Slider.HandleSlideAreaPositionSize(handleSlideArea));

            ImageContentErrorCheck(handleImage.rectTransform, handleImage);
        }

        /// <summary>
        /// VCGUIImageに変換可能なもの
        /// </summary>
        /// <param name="content"></param>
        /// <param name="image"></param>
        private void ImageContentErrorCheck(RectTransform content, Image image)
        {
            if (image.material.name != "Default UI Material")
                AddErrorMessage($"{content.name}[Image]:Materialの変更は対応していないため、無視されます。", image);
            if (image.raycastTarget != true)
                AddWarningMessage($"{content.name}[Image]:RaycastTargetの変更は対応していないため、無視されます。", image, AutoFixError.Graphic.RaycastTarget(image, "Image"));
            if (image.maskable != true)
                AddWarningMessage($"{content.name}[Image]:Maskableの変更は対応していないため、無視されます。", image, AutoFixError.MaskableGraphic.Maskable(image, "Image"));

            if (image.mainTexture != null && IsBuiltinResource(image.mainTexture))
                AddErrorMessage($"{content.name}[Image]:Unityビルトインリソースには現在、対応していません。", image, AutoFixError.Misc.MainTexture(image));
        }

        /// <summary>
        /// Sliderなど他のGUIの要素となっているImageの検証
        /// </summary>
        /// <param name="image"></param>
        private void ImageSubContentErrorCheck(Image image)
        {
            if (image.material.name != "Default UI Material")
                AddErrorMessage($"{image.name}[Image]:Materialの変更は対応していないため、無視されます。", image);
            if (image.raycastTarget != true)
                AddWarningMessage($"{image.name}[Image]:RaycastTargetの変更は対応していないため、無視されます。", image, AutoFixError.Graphic.RaycastTarget(image, "Image"));
            if (image.maskable != true)
                AddWarningMessage($"{image.name}[Image]:Maskableの変更は対応していないため、無視されます。", image, AutoFixError.MaskableGraphic.Maskable(image, "Image"));

            if (image.mainTexture != null && IsBuiltinResource(image.mainTexture))
                AddErrorMessage($"{image.name}[Image]:Unityビルトインリソースには現在、対応していません。", image, AutoFixError.Misc.MainTexture(image));
        }

        private void ButtonContentErrorCheck(RectTransform content, Button button, Image image)
        {
            if (button.transition != Selectable.Transition.SpriteSwap)
                AddErrorMessage($"{content.name}[Button]:TransitionはSpriteSwapのみ動作が再現できます。", button, AutoFixError.Button.Transition(button));
            if (image == null)
                AddErrorMessage($"{content.name}[Button]:同じGameObjectにImageが必要です。", button, AutoFixError.Button.AddTextComponent(button));
            if (button.targetGraphic == null || (button.targetGraphic != null && button.targetGraphic.gameObject != button.gameObject))
                AddWarningMessage($"{content.name}[Button]:TargetGraphicの変更は対応していないため、無視されます。", button, AutoFixError.Button.TargetGraphic(button));
            if (button.spriteState.pressedSprite != null)
                AddWarningMessage($"{content.name}[Button]:Pressed Spriteの変更は対応していないため、無視されます。", button, AutoFixError.Button.PressedSprite(button));
            if (button.spriteState.disabledSprite != null)
                AddWarningMessage($"{content.name}[Button]:Disabled Spriteの変更は対応していないため、無視されます。", button, AutoFixError.Button.DisabledSprite(button));
            if (button.navigation.mode != Navigation.Mode.Automatic)
                AddWarningMessage($"{content.name}[Button]:Navigationの変更は対応していないため、無視されます。", button, AutoFixError.Selectable.Navigation(button, "Button"));
        }

        private void TextContentErrorCheck(RectTransform content, Text text, Button button)
        {
            if (content.transform.parent != null && button != null)
                AddErrorMessage($"Button{content.transform.parent.name}にTextが設定されていますが、VketCloudではボタンのテキストを変更する機能が存在しないため、別のGUIコンテンツとして出力します。ボタンの画像にテキストを直接入れることを検討してください。", content);
            if (text.font == null || text.font.name != "Arial")
                AddWarningMessage($"{content.name}[Text]:Fontの変更は対応していないため、無視されます。", text, AutoFixError.Text.Font(text));
            if (text.fontStyle != FontStyle.Normal)
                AddWarningMessage($"{content.name}[Text]:FontStyleの変更は対応していないため、無視されます。", text, AutoFixError.Text.TextStyle(text));
            if (text.lineSpacing != 1)
                AddWarningMessage($"{content.name}[Text]:LineSpacingの変更は対応していないため、無視されます。", text, AutoFixError.Text.LineSpacing(text));
            if (text.supportRichText != false)
                AddWarningMessage($"{content.name}[Text]:RichTextは対応していないため、無視されます。", text, AutoFixError.Text.RichText(text));
            if (text.alignment != TextAnchor.UpperLeft)
                AddWarningMessage($"{content.name}[Text]:Alignmentの変更は対応していないため、無視されます。", text, AutoFixError.Text.Alignment(text));
            if (text.alignByGeometry != false)
                AddWarningMessage($"{content.name}[Text]:AlignByGeometryの変更は対応していないため、無視されます。", text, AutoFixError.Text.AlignByGeometry(text));
            if (text.horizontalOverflow != HorizontalWrapMode.Wrap)
                AddErrorMessage($"{content.name}[Text]:HorizontalOverflowの変更は対応していないため、無視されます。", text, AutoFixError.Text.HorizontalOverflow(text));
            if (text.verticalOverflow != VerticalWrapMode.Truncate)
                AddErrorMessage($"{content.name}[Text]:VerticalOverflowの変更は対応していないため、無視されます。", text, AutoFixError.Text.VerticalOverflow(text));
            if (text.resizeTextForBestFit != false)
                AddWarningMessage($"{content.name}[Text]:BestFitの変更は対応していないため、無視されます。", text, AutoFixError.Text.BestFit(text));
            if (text.material.name != "Default UI Material")
                AddErrorMessage($"{content.name}[Text]:Materialの変更は対応していないため、無視されます。", text);
            if (text.raycastTarget != true)
                AddWarningMessage($"{content.name}[Text]:RaycastTargetの変更は対応していないため、無視されます。", text, AutoFixError.Graphic.RaycastTarget(text, "Text"));
            if (text.maskable != true)
                AddWarningMessage($"{content.name}[Text]:Maskableの変更は対応していないため、無視されます。", text, AutoFixError.MaskableGraphic.Maskable(text, "Text"));
        }

        private void HtmlContentErrorCheck(RectTransform content, VCHtml html)
        {
        }

        public void OnAutoFixResolved()
        {
            AutoFixResolved();
        }

        private void AutoFixResolved()
        {
            autoFixResolved = true;
            updateTime = 0;
        }

        private void PostDrawMessage(CheckMessage message)
        {
            if (autoFixResolved)
            {
                message.onDrawAutoFixButton = null;
                message.message = "[修正確認中...] " + message.message;
                autoFixResolved = false;
            }
        }

        private bool ButtonAutoFix()
        {
            return GUILayout.Button("Auto Fix", GUILayout.ExpandWidth(false));
        }

        private void AutoFixNotification(string message)
        {
            ShowNotification(new GUIContent(message), 3f);
        }

        public void DelayClearMessages(string newDelayMessage)
        {
            delayClearMessages = true;
            delayMessage = newDelayMessage;
        }

        public void ClearMessages()
        {
            criticalMessages.Clear();
            errorMessages.Clear();
            warningMessages.Clear();
        }

        float lastAppliedTime = 0f;

        public bool AutoApplyAutoFix(params AutoFixTag[] tags)
        {
            var settings = _autoApplyAutoFix;
            if (settings.activate)
            {
                var result = AutoApplyAutoFixInternal(tags);
                if (Event.current.type == EventType.Repaint)
                {
                    if (result && Time.realtimeSinceStartup > lastAppliedTime + 1f)
                    {
                        lastAppliedTime = Time.realtimeSinceStartup;
                        return true;
                    }
                }
            }

            return false;
        }

        public bool AutoApplyAutoFixInternal(params AutoFixTag[] tags)
        {
            if (tags.Length == 0)
                return false;

            var settings = _autoApplyAutoFix;

            bool hasSafe = tags.Contains(AutoFixTag.Safe);
            bool hasMajorChange = tags.Contains(AutoFixTag.MajorChange);
            bool hasHierarchical = tags.Contains(AutoFixTag.Hierarchical);
            bool hasRemoveComponent = tags.Contains(AutoFixTag.RemoveComponent);
            bool hasAnimation = tags.Contains(AutoFixTag.Animation);
            bool hasCritical = tags.Contains(AutoFixTag.Critical);
            bool hasCanNotAutoApply = tags.Contains(AutoFixTag.CanNotAutoApply);
            bool hasGenerateAutoLayer = tags.Contains(AutoFixTag.AutoGenerateLayer);

            // 禁則：強い禁則ルールがあれば、自動修正はしない
            if (hasCritical)
                return false;

            if (hasCanNotAutoApply)
                return false;

            // 特化：ひとつでもフラグを満たしたら自動修正を行う
            if (hasGenerateAutoLayer && settings.generateAutoLayer)
                return true;

            // 汎用：
            // それぞれのタグにて、タグが許可されていたら自動修正を行う
            bool passSafe = !hasSafe || settings.safe && hasSafe;
            bool passMajorChange = !hasMajorChange || settings.major && hasMajorChange;
            bool passHierarchical = !hasHierarchical || settings.hierarchical && hasHierarchical;
            bool passRemoveComponent = !hasRemoveComponent || settings.removeComponent && hasRemoveComponent;
            bool passAnimation = !hasAnimation || settings.animation && hasAnimation;

            return passSafe && passMajorChange && passHierarchical && passRemoveComponent;
        }
        public void AddCriticalMessages(string message, UnityEngine.Object obj, Action onDrawAutoFixButton = null)
        {
            criticalMessages.Add(new CheckMessage() { message = message, obj = obj, onDrawAutoFixButton = onDrawAutoFixButton });
        }

        public void AddErrorMessage(string message, UnityEngine.Object obj, Action onDrawAutoFixButton = null)
        {
            errorMessages.Add(new CheckMessage() { message = message, obj = obj, onDrawAutoFixButton = onDrawAutoFixButton });
        }

        public void AddWarningMessage(string message, UnityEngine.Object obj, Action onDrawAutoFixButton = null)
        {
            warningMessages.Add(new CheckMessage() { message = message, obj = obj, onDrawAutoFixButton = onDrawAutoFixButton });
        }

        public static bool IsDataPath(string path)
        {
            return path.StartsWith(Application.dataPath);
        }

        public static string StlipDataPath(string path)
        {
            Debug.Log(path);
            Debug.Log(Application.dataPath);
            return path.Remove(0, Application.dataPath.Length);
        }

        public VCLayerMaskDef ExportLayerMask(VCLayerList layerList)
        {
            if (!layerList.Mask.HasValue)
            {
                return null;
            }
            var result = new VCLayerMaskDef();
            if (layerList.Mask.URI != null)
            {
                if (!IsBuiltinResource(layerList.Mask.URI, out string maskImagePath))
                {
                    result.URI = maskImagePath;
                    CopyAssets(layerList.Mask.URI);
                }
            }
            result.Show = layerList.Mask.Show;
            result.Pos = new[] { layerList.Mask.Pos.x, layerList.Mask.Pos.y };
            result.Size = new[] { layerList.Mask.Size.x, layerList.Mask.Size.y };
            result.Z = layerList.Mask.Z;
            result.Pivot = new[] { layerList.Mask.Pivot.x, layerList.Mask.Pivot.y };
            result.Anchor = layerList.Mask.Anchor.ToString();
            result.Color = new[] { layerList.Mask.Color.r, layerList.Mask.Color.g, layerList.Mask.Color.b, layerList.Mask.Color.a };
            result.Vertical = layerList.Mask.Vertical;
            result.FreeSlide = layerList.Mask.FreeSlide;
            result.WheelTravel = layerList.Mask.WheelTravel;
            result.SeekBar = ExportLayerMaskSeekBar(layerList.Mask.SeekBar);
            return result;
        }
        public VCLayerMaskSeekBarDef ExportLayerMaskSeekBar(VCLayerMaskSeekBar SeekBar)
        {
            if (!SeekBar.HasValue)
            {
                return null;
            }
            var result = new VCLayerMaskSeekBarDef();
            if (SeekBar.HasVerticalValue)
            {
                result.Vertical = ExportLayerMaskSeekBarItem(SeekBar.Vertical);
            }
            if (SeekBar.HasHorizontalValue)
            {
                result.Horizontal = ExportLayerMaskSeekBarItem(SeekBar.Horizontal);
            }
            return result;
        }
        public VCLayerMaskSeekBarItemDef ExportLayerMaskSeekBarItem(VCLayerMaskSeekBarItem item)
        {
            var result = new VCLayerMaskSeekBarItemDef();
            if (item.Base != null)
            {
                if (!IsBuiltinResource(item.Base, out string baseImagePath))
                {
                    result.Base = baseImagePath;
                    CopyAssets(item.Base);
                }
            }
            if (item.Front != null)
            {
                if (!IsBuiltinResource(item.Front, out string frontImagePath))
                {
                    result.Front = frontImagePath;
                    CopyAssets(item.Front);
                }
            }
            if (item.On != null)
            {
                if (!IsBuiltinResource(item.On, out string onImagePath))
                {
                    result.On = onImagePath;
                    CopyAssets(item.On);
                }
            }
            if (item.Off != null)
            {
                if (!IsBuiltinResource(item.Off, out string offImagePath))
                {
                    result.Off = offImagePath;
                    CopyAssets(item.Off);
                }
            }
            result.BarWidth = item.BarWidth;
            result.OnSize = new[] { item.OnSize.x, item.OnSize.y };
            result.OffSize = new[] { item.OffSize.x, item.OffSize.y };
            return result;
        }
        private static void ExportHtml(VCLayerDef layerDef, VCHtml vcHtml, VCContentDef contentDef)
        {
            contentDef.Type = "html";
            var param = new ParamHtml();
            param.FontSize = vcHtml.FontSize;
            contentDef.ParamHtml = param;
            layerDef.Gui.Add(contentDef);
        }

    }
}