using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text.RegularExpressions;
using Cysharp.Threading.Tasks;
using UnityEditor;
using UnityEngine;
using VketCloudGUITools.Runtime;
using VketCloudGUITools.Serialization;

namespace VketCloudGUITools.Editor
{
    public class VCGUICanvasImporterEditorSettings
    {
        /// <summary>
        /// Editor用インポート動作補助
        /// </summary>
        public class EditorImporterSettingsAgent
        {
            /// <summary>
            /// <see cref="InputDataPath"/>を参照。
            /// </summary>
            private string _inputDataPath = string.Empty;

            /// <summary>
            /// <see cref="OutputAssetPath"/>を参照。
            /// </summary>
            private string _outputAssetPath = string.Empty;

            /// <summary>
            /// Editor用：インポートの外部アセット読込先ルートを指定。
            /// </summary>
            public string InputDataPath
            {
                get => _inputDataPath;
                set => _inputDataPath = value;
            }

            /// <summary>
            /// Editor用：インポート時のUnityアセット保存先ルートを指定。
            /// </summary>
            public string OutputAssetPath
            {
                get => _outputAssetPath;
                set => _outputAssetPath = value;
            }

            /// <summary>
            /// Editor用：Spriteインポート動作
            /// </summary>
            /// <param name="assetID"></param>
            /// <param name="importProgress"></param>
            /// <param name="settings"></param>
            /// <returns></returns>
            public async UniTask<Sprite> EditorOnImportSprite(string assetID, ImportProgress importProgress, VCCanvasImporterSettings settings)
            {
                await settings.SmartYield();
                ImportAsset(InputDataPath, assetID, OutputAssetPath);
                await settings.SmartYield();
                importProgress.Done();
                return null;
            }

            /// <summary>
            /// Editor用：Sprite読み込み動作
            /// </summary>
            /// <param name="assetID"></param>
            /// <param name="loadProgress"></param>
            /// <param name="settings"></param>
            /// <returns></returns>
            public async UniTask<Sprite> EditorOnLoadSprite(string assetID, ImportProgress loadProgress, VCCanvasImporterSettings settings)
            {
                if (assetID.StartsWith("./"))
                {
                    assetID = assetID.Substring(2);
                }
                await settings.SmartYield();
                Sprite sprite = UnityEditor.AssetDatabase.LoadAssetAtPath<Sprite>($"{OutputAssetPath}/{assetID}");
                await settings.SmartYield();
                loadProgress.Done();
                return sprite;
            }

            public async UniTask<TextAsset> EditorOnImportHeliodorScript(string assetID, ImportProgress importProgress, VCCanvasImporterSettings settings)
            {
                await settings.SmartYield();
                ImportAsset(InputDataPath, assetID, OutputAssetPath, true);
                await settings.SmartYield();
                importProgress.Done();
                return null;
            }
            public async UniTask<TextAsset> EditorOnLoadHeliodorScript(string assetID, ImportProgress loadProgress, VCCanvasImporterSettings settings)
            {
                int index = assetID.IndexOf("Canvas");

                if (index != -1)
                {
                    // Add the length of "Canvas/" to the index to start after this substring
                    assetID = assetID.Substring(index);
                }
                else
                {
                    Debug.Log("Substring 'Canvas' not found.");
                }
                await settings.SmartYield();
                TextAsset textAsset = UnityEditor.AssetDatabase.LoadAssetAtPath<TextAsset>($"{OutputAssetPath}/{assetID}");
                await settings.SmartYield();
                loadProgress.Done();
                return textAsset;
            }

            /// <summary>
            /// Canvas名を確定する。ImportDataPathのファイル名（拡張子なし）。
            /// </summary>
            /// <returns></returns>
            public string DeterminateCanvasNameFromImportDataPath()
            {
                return Path.GetFileNameWithoutExtension(InputDataPath);
            }

            /// <summary>
            /// CanvasTypeを確定する。ImportDataPathからキーワード検索。
            /// </summary>
            /// <returns></returns>
            public CanvasType DeterminateCanvasTypeFromImportDataPath()
            {
                var canvasType = CanvasType.None;
                // フォルダ階層を上へ順に見る
                var directoryNames = InputDataPath.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;
                    }
                }
                return canvasType;
            }
        }

        /// <summary>
        /// エディタ用インポート基本設定
        /// </summary>
        /// <param name="importInputDataPath"></param>
        /// <param name="importOutputAssetPath"></param>
        /// <returns></returns>
        public static VCCanvasImporterSettings EditorDefaults(string importInputDataPath, string importOutputAssetPath)
        {
            var settings = new VCCanvasImporterSettings();
            var agent = new EditorImporterSettingsAgent();

            agent.InputDataPath = importInputDataPath;
            agent.OutputAssetPath = importOutputAssetPath;

            settings.onImportSprite = agent.EditorOnImportSprite;
            settings.onLoadSprite = agent.EditorOnLoadSprite;

            settings.onImportHeliodorScript = agent.EditorOnImportHeliodorScript;
            settings.onLoadHeliodorScript = agent.EditorOnLoadHeliodorScript;
            settings.determinateCanvasName = agent.DeterminateCanvasNameFromImportDataPath;
            settings.determinateCanvasType = agent.DeterminateCanvasTypeFromImportDataPath;

            settings.taskSafeIntervalMS = 1000;

            return settings;
        }

        /// <summary>
        /// 外部アセットを保存
        /// </summary>
        /// <param name="importTargetPath">インポート対象ファイルパス</param>
        /// <param name="assetInputPath">インポート元のルートパス</param>
        /// <param name="assetOutputPath">インポート先のルートパス</param>
        private static void ImportAsset(string importTargetPath, string assetInputPath, string assetOutputPath, bool isText = false)
        {
            var dataFolder = Path.GetDirectoryName(Path.GetDirectoryName(Path.GetDirectoryName(importTargetPath)));

            // ターゲットが"data"ディレクトリ直下ではないとき
            // "data"ディレクトリを得る
            //if (Path.GetFileName(Path.GetDirectoryName(dataFolder)) != "data")
            //{
            //    // 空白のときは明示的なnullアセットとみなす
            //    if (string.IsNullOrEmpty(dataFolder))
            //        return;

            //    // ディレクトリ名に"data"が見つかるまで親ディレクトリを探す
            //    dataFolder = Path.GetDirectoryName(dataFolder);
            //    while (Path.GetFileName(Path.GetDirectoryName(dataFolder)) != "data")
            //    {
            //        dataFolder = Path.GetDirectoryName(dataFolder);
            //        if (string.IsNullOrEmpty(dataFolder))
            //            return;
            //    }

            //    // "data"ディレクトリを得る
            //    dataFolder = Path.GetDirectoryName(dataFolder);
            //}

            if(isText)
            {
                // Find the index of "Canvas" in the string
                int index = assetInputPath.IndexOf("Canvas");

                if (index != -1)
                {
                    // Add the length of "Canvas/" to the index to start after this substring
                    assetInputPath = assetInputPath.Substring(index);
                }
                else
                {
                    Debug.Log("Substring 'Canvas' not found.");
                }
            } else
            {
                // Remove leading "./" if present
                if (assetInputPath.StartsWith("./"))
                {
                    assetInputPath = assetInputPath.Substring(2);
                }
            }

            // アセット出力先ディレクトリ
            var destDir = Path.GetDirectoryName($"{assetOutputPath}/{assetInputPath}");

            // アセット読込先
            var importedAssetsPath = $"{assetOutputPath}/{assetInputPath}";

            // 出力先ディレクトリがなければ作る
            if (!Directory.Exists(destDir))
                Directory.CreateDirectory(destDir);

            // 読込先ファイルがなければエラー
            if (!File.Exists($"{dataFolder}/{assetInputPath}"))
            {
                Debug.LogError($"Copy Asset Failed: Missing Source File(from {dataFolder}/{assetInputPath}");
                return;
            }

            // 読込先から出力先へアセットをコピーしAssetDatabaseに登録
            File.Copy($"{dataFolder}/{assetInputPath}", importedAssetsPath, true);
            AssetDatabase.ImportAsset(importedAssetsPath, ImportAssetOptions.ForceUpdate);
            if (!isText)
            {
                var importer = AssetImporter.GetAtPath(importedAssetsPath) as UnityEditor.TextureImporter;
                importer.textureType = TextureImporterType.Sprite;
                AssetDatabase.WriteImportSettingsIfDirty(importedAssetsPath);
                importer.SaveAndReimport();
            }
            AssetDatabase.SaveAssets();
            AssetDatabase.Refresh();
        }
    }
}