using System.Collections.Generic;
using System.Linq;
using UnityEditor;
using UnityEngine;

namespace AlterchaseSDK.Editor
{
    public class ModAssetLibrary : EditorWindow
    {
        private Vector2 scrollPosition;
        private ModAssetType selectedTab = ModAssetType.Level;
        private List<LevelModAsset> levelAssets = new List<LevelModAsset>();
        private List<ModelModAsset> modelAssets = new List<ModelModAsset>();
        private List<EnemyModAsset> enemyAssets = new List<EnemyModAsset>();
        private string searchQuery = "";

        [MenuItem("Alterchase SDK/Mod Asset Library", priority = 2)]
        public static void ShowWindow()
        {
            ModAssetLibrary window = GetWindow<ModAssetLibrary>("Mod Asset Library");
            window.minSize = new Vector2(600, 400);
            window.Show();
        }

        private void OnEnable()
        {
            RefreshAssets();
        }

        private void OnGUI()
        {
            DrawHeader();
            DrawToolbar();
            DrawAssetList();
        }

        private void DrawHeader()
        {
            EditorGUILayout.LabelField("Alterchase Mod Asset Library", EditorStyles.boldLabel);
            EditorGUILayout.LabelField("Browse and manage all mod assets in your project.", EditorStyles.miniLabel);
            EditorGUILayout.Space(5);
            EditorGUILayout.LabelField("", GUI.skin.horizontalSlider);
            EditorGUILayout.Space(5);
        }

        private void DrawToolbar()
        {
            EditorGUILayout.BeginHorizontal();
            
            if (GUILayout.Toggle(selectedTab == ModAssetType.Level, $"Levels ({levelAssets.Count})", "Button"))
            {
                selectedTab = ModAssetType.Level;
            }
            
            if (GUILayout.Toggle(selectedTab == ModAssetType.Model, $"Models ({modelAssets.Count})", "Button"))
            {
                selectedTab = ModAssetType.Model;
            }
            
            if (GUILayout.Toggle(selectedTab == ModAssetType.Enemy, $"Enemies ({enemyAssets.Count})", "Button"))
            {
                selectedTab = ModAssetType.Enemy;
            }
            
            EditorGUILayout.EndHorizontal();
            
            EditorGUILayout.Space(5);
            
            EditorGUILayout.BeginHorizontal();
            searchQuery = EditorGUILayout.TextField("Search:", searchQuery);
            
            if (GUILayout.Button("Refresh", GUILayout.Width(80)))
            {
                RefreshAssets();
            }
            
            if (GUILayout.Button("Create New", GUILayout.Width(100)))
            {
                CreateNewAsset();
            }
            
            EditorGUILayout.EndHorizontal();
            
            EditorGUILayout.Space(5);
        }

        private void DrawAssetList()
        {
            scrollPosition = EditorGUILayout.BeginScrollView(scrollPosition);
            
            switch (selectedTab)
            {
                case ModAssetType.Level:
                    DrawLevelAssets();
                    break;
                case ModAssetType.Model:
                    DrawModelAssets();
                    break;
                case ModAssetType.Enemy:
                    DrawEnemyAssets();
                    break;
            }
            
            EditorGUILayout.EndScrollView();
        }

        private void DrawLevelAssets()
        {
            var filteredAssets = FilterAssets(levelAssets);
            
            if (filteredAssets.Count == 0)
            {
                EditorGUILayout.HelpBox("No level assets found. Create one to get started!", MessageType.Info);
                return;
            }
            
            foreach (var asset in filteredAssets)
            {
                DrawAssetCard(asset);
            }
        }

        private void DrawModelAssets()
        {
            var filteredAssets = FilterAssets(modelAssets);
            
            if (filteredAssets.Count == 0)
            {
                EditorGUILayout.HelpBox("No model assets found. Create one to get started!", MessageType.Info);
                return;
            }
            
            foreach (var asset in filteredAssets)
            {
                DrawAssetCard(asset);
            }
        }

        private void DrawEnemyAssets()
        {
            var filteredAssets = FilterAssets(enemyAssets);
            
            if (filteredAssets.Count == 0)
            {
                EditorGUILayout.HelpBox("No enemy assets found. Create one to get started!", MessageType.Info);
                return;
            }
            
            foreach (var asset in filteredAssets)
            {
                DrawAssetCard(asset);
            }
        }

        private void DrawAssetCard(ModAsset asset)
        {
            EditorGUILayout.BeginVertical("box");
            
            EditorGUILayout.BeginHorizontal();
            
            if (asset.Thumbnail != null)
            {
                GUILayout.Label(asset.Thumbnail, GUILayout.Width(64), GUILayout.Height(64));
            }
            else
            {
                GUILayout.Box("No Preview", GUILayout.Width(64), GUILayout.Height(64));
            }
            
            EditorGUILayout.BeginVertical();
            
            EditorGUILayout.LabelField(asset.AssetName, EditorStyles.boldLabel);
            EditorGUILayout.LabelField($"By: {asset.CreatorName} | Version: {asset.Version}", EditorStyles.miniLabel);
            
            if (!string.IsNullOrEmpty(asset.Description))
            {
                EditorGUILayout.LabelField(asset.Description, EditorStyles.wordWrappedMiniLabel, GUILayout.Height(30));
            }
            
            EditorGUILayout.BeginHorizontal();
            
            if (GUILayout.Button("Select", GUILayout.Width(80)))
            {
                Selection.activeObject = asset;
                EditorGUIUtility.PingObject(asset);
            }
            
            if (GUILayout.Button("Validate", GUILayout.Width(80)))
            {
                if (asset.ValidateAsset(out string error))
                {
                    EditorUtility.DisplayDialog("Validation Success", 
                        $"Asset '{asset.AssetName}' passed validation!", "OK");
                }
                else
                {
                    EditorUtility.DisplayDialog("Validation Failed", 
                        $"Asset '{asset.AssetName}' failed validation:\n{error}", "OK");
                }
            }
            
            EditorGUILayout.EndHorizontal();
            EditorGUILayout.EndVertical();
            EditorGUILayout.EndHorizontal();
            EditorGUILayout.EndVertical();
            
            EditorGUILayout.Space(5);
        }

        private List<T> FilterAssets<T>(List<T> assets) where T : ModAsset
        {
            if (string.IsNullOrEmpty(searchQuery))
            {
                return assets;
            }
            
            return assets.Where(a => 
                a.AssetName.ToLower().Contains(searchQuery.ToLower()) ||
                a.CreatorName.ToLower().Contains(searchQuery.ToLower()) ||
                a.Description.ToLower().Contains(searchQuery.ToLower())
            ).ToList();
        }

        private void RefreshAssets()
        {
            levelAssets = FindAssets<LevelModAsset>();
            modelAssets = FindAssets<ModelModAsset>();
            enemyAssets = FindAssets<EnemyModAsset>();
        }

        private List<T> FindAssets<T>() where T : ModAsset
        {
            string[] guids = AssetDatabase.FindAssets($"t:{typeof(T).Name}");
            List<T> results = new List<T>();
            
            foreach (string guid in guids)
            {
                string path = AssetDatabase.GUIDToAssetPath(guid);
                T asset = AssetDatabase.LoadAssetAtPath<T>(path);
                if (asset != null)
                {
                    results.Add(asset);
                }
            }
            
            return results;
        }

        private void CreateNewAsset()
        {
            string assetName = "";
            string menuPath = "";
            
            switch (selectedTab)
            {
                case ModAssetType.Level:
                    assetName = "NewLevelMod";
                    menuPath = "Alterchase SDK/Level Mod Asset";
                    break;
                case ModAssetType.Model:
                    assetName = "NewModelMod";
                    menuPath = "Alterchase SDK/Model Mod Asset";
                    break;
                case ModAssetType.Enemy:
                    assetName = "NewEnemyMod";
                    menuPath = "Alterchase SDK/Enemy Mod Asset";
                    break;
            }
            
            string path = EditorUtility.SaveFilePanelInProject(
                $"Create New {selectedTab} Mod Asset",
                assetName,
                "asset",
                "Choose a location to save the new mod asset");

            if (!string.IsNullOrEmpty(path))
            {
                ModAsset newAsset = null;
                
                switch (selectedTab)
                {
                    case ModAssetType.Level:
                        newAsset = CreateInstance<LevelModAsset>();
                        break;
                    case ModAssetType.Model:
                        newAsset = CreateInstance<ModelModAsset>();
                        break;
                    case ModAssetType.Enemy:
                        newAsset = CreateInstance<EnemyModAsset>();
                        break;
                }
                
                if (newAsset != null)
                {
                    AssetDatabase.CreateAsset(newAsset, path);
                    AssetDatabase.SaveAssets();
                    RefreshAssets();
                    Selection.activeObject = newAsset;
                }
            }
        }
    }
}
