using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using MCPForUnity.Editor.Helpers;
using Newtonsoft.Json.Linq;
using UnityEditor;
using UnityEngine;
using MCPForUnity.Runtime.Helpers;

namespace MCPForUnity.Editor.Tools.Graphics
{
    internal static class VolumeOps
    {
        // === volume_create ===
        // Params: name (string), is_global (bool, default true), weight (float, default 1),
        //         priority (float, default 0), profile_path (string, optional - path to save VolumeProfile asset),
        //         effects (array of {type, ...params}, optional - effects to add immediately)
        internal static object CreateVolume(JObject @params)
        {
            var p = new ToolParams(@params);
            string name = p.Get("name") ?? "Volume";
            bool isGlobal = p.GetBool("is_global", true);
            float weight = p.GetFloat("weight") ?? 1.0f;
            float priority = p.GetFloat("priority") ?? 0f;
            string profilePath = p.Get("profile_path");
            if (!string.IsNullOrEmpty(profilePath))
            {
                if (!profilePath.StartsWith("Assets/", StringComparison.OrdinalIgnoreCase) &&
                    !profilePath.StartsWith("Assets\\", StringComparison.OrdinalIgnoreCase))
                    profilePath = "Assets/" + profilePath;
                if (!profilePath.EndsWith(".asset", StringComparison.OrdinalIgnoreCase))
                    profilePath += ".asset";
            }

            var go = new GameObject(name);
            Undo.RegisterCreatedObjectUndo(go, $"Create Volume '{name}'");

            // Add Volume component via reflection
            var volumeComp = go.AddComponent(GraphicsHelpers.VolumeType);

            // Set properties via reflection
            SetProperty(volumeComp, "isGlobal", isGlobal);
            SetProperty(volumeComp, "weight", weight);
            SetProperty(volumeComp, "priority", priority);

            // Create or load VolumeProfile
            object profile;
            if (!string.IsNullOrEmpty(profilePath))
            {
                // Load existing or create new profile asset
                profile = AssetDatabase.LoadAssetAtPath(profilePath, GraphicsHelpers.VolumeProfileType);
                if (profile == null)
                {
                    profile = ScriptableObject.CreateInstance(GraphicsHelpers.VolumeProfileType);
                    // Ensure directory exists
                    var dir = System.IO.Path.GetDirectoryName(profilePath);
                    if (!string.IsNullOrEmpty(dir) && !System.IO.Directory.Exists(dir))
                        System.IO.Directory.CreateDirectory(dir);
                    AssetDatabase.CreateAsset((UnityEngine.Object)profile, profilePath);
                }
            }
            else
            {
                // Create embedded profile (not saved as asset)
                profile = ScriptableObject.CreateInstance(GraphicsHelpers.VolumeProfileType);
            }

            // Assign profile (sharedProfile is a public field, handled by SetProperty's field fallback)
            SetProperty(volumeComp, "sharedProfile", profile);

            // Add initial effects if provided
            var effectsToken = p.GetRaw("effects") as JArray;
            var addedEffects = new List<string>();
            if (effectsToken != null)
            {
                foreach (var effectDef in effectsToken)
                {
                    if (effectDef is JObject effectObj)
                    {
                        string effectType = ParamCoercion.CoerceString(effectObj["type"], null);
                        if (string.IsNullOrEmpty(effectType)) continue;

                        var type = GraphicsHelpers.ResolveVolumeComponentType(effectType);
                        if (type == null) continue;

                        // profile.Add(type, true)
                        var addMethod = GraphicsHelpers.VolumeProfileType.GetMethod("Add",
                            new[] { typeof(Type), typeof(bool) });
                        if (addMethod != null)
                        {
                            var component = addMethod.Invoke(profile, new object[] { type, true });
                            if (component != null)
                            {
                                // Set parameters — support both nested {"parameters": {...}} and flat fields
                                var paramObj = effectObj["parameters"] as JObject;
                                if (paramObj != null)
                                {
                                    foreach (var pp in paramObj.Properties())
                                        SetVolumeParameter(component, pp.Name, pp.Value);
                                }
                                else
                                {
                                    foreach (var prop in effectObj.Properties())
                                    {
                                        if (prop.Name == "type") continue;
                                        SetVolumeParameter(component, prop.Name, prop.Value);
                                    }
                                }
                                addedEffects.Add(effectType);
                            }
                        }
                    }
                }
                if (profile is UnityEngine.Object profileObj)
                    EditorUtility.SetDirty(profileObj);
            }

            GraphicsHelpers.MarkDirty(volumeComp);

            return new
            {
                success = true,
                message = $"Created {(isGlobal ? "global" : "local")} Volume '{name}'" +
                         (addedEffects.Count > 0 ? $" with effects: {string.Join(", ", addedEffects)}" : ""),
                data = new
                {
                    instanceID = go.GetInstanceIDCompat(),
                    isGlobal,
                    weight,
                    priority,
                    profilePath = profilePath ?? "(embedded)",
                    effects = addedEffects
                }
            };
        }

        // === volume_add_effect ===
        // Params: target (string/int), effect (string - type name like "Bloom")
        internal static object AddEffect(JObject @params)
        {
            var p = new ToolParams(@params);
            string effectName = p.Get("effect");
            if (string.IsNullOrEmpty(effectName))
                return new ErrorResponse("'effect' parameter is required (e.g., 'Bloom', 'Vignette').");

            var volume = GraphicsHelpers.FindVolume(@params);
            if (volume == null)
                return new ErrorResponse("Volume not found. Specify 'target' (name or instance ID).");

            var effectType = GraphicsHelpers.ResolveVolumeComponentType(effectName);
            if (effectType == null)
            {
                var available = GraphicsHelpers.GetAvailableEffectTypes()
                    .Select(t => t.Name).ToList();
                return new ErrorResponse(
                    $"Effect type '{effectName}' not found. Available: {string.Join(", ", available.Take(20))}");
            }

            var profile = GetProperty(volume, "sharedProfile");
            if (profile == null)
                return new ErrorResponse("Volume has no profile assigned.");

            // Check if effect already exists
            var components = GetProperty(profile, "components") as System.Collections.IList;
            if (components != null)
            {
                foreach (var comp in components)
                {
                    if (comp != null && comp.GetType() == effectType)
                        return new ErrorResponse($"Effect '{effectName}' already exists on this Volume. Use volume_set_effect to modify it.");
                }
            }

            // profile.Add(effectType, true) -- 'true' means override all params
            var addMethod = GraphicsHelpers.VolumeProfileType.GetMethod("Add",
                new[] { typeof(Type), typeof(bool) });
            if (addMethod == null)
                return new ErrorResponse("Could not find VolumeProfile.Add method.");

            var component = addMethod.Invoke(profile, new object[] { effectType, true });
            if (component == null)
                return new ErrorResponse($"Failed to add effect '{effectName}'.");

            if (profile is UnityEngine.Object profileObj)
                EditorUtility.SetDirty(profileObj);
            GraphicsHelpers.MarkDirty(volume);

            return new
            {
                success = true,
                message = $"Added '{effectName}' to Volume '{(volume as Component)?.gameObject.name}'.",
                data = new { effect = effectName, volumeInstanceID = (volume as Component)?.gameObject.GetInstanceIDCompat() }
            };
        }

        // === volume_set_effect ===
        // Params: target (string/int), effect (string), parameters (dict of field->value)
        internal static object SetEffect(JObject @params)
        {
            var p = new ToolParams(@params);
            string effectName = p.Get("effect");
            if (string.IsNullOrEmpty(effectName))
                return new ErrorResponse("'effect' parameter is required.");

            var volume = GraphicsHelpers.FindVolume(@params);
            if (volume == null)
                return new ErrorResponse("Volume not found. Specify 'target'.");

            var profile = GetProperty(volume, "sharedProfile");
            if (profile == null)
                return new ErrorResponse("Volume has no profile assigned.");

            var effectType = GraphicsHelpers.ResolveVolumeComponentType(effectName);
            if (effectType == null)
                return new ErrorResponse($"Effect type '{effectName}' not found.");

            // Find the effect component in the profile
            var components = GetProperty(profile, "components") as System.Collections.IList;
            if (components == null)
                return new ErrorResponse("Could not read profile components.");

            object targetComponent = null;
            foreach (var comp in components)
            {
                if (comp != null && comp.GetType() == effectType)
                {
                    targetComponent = comp;
                    break;
                }
            }

            if (targetComponent == null)
                return new ErrorResponse($"Effect '{effectName}' not found on this Volume. Use volume_add_effect first.");

            // Set parameters
            var parameters = p.GetRaw("parameters") as JObject;
            if (parameters == null)
                return new ErrorResponse("'parameters' dict is required.");

            var setParams = new List<string>();
            var failedParams = new List<string>();
            foreach (var prop in parameters.Properties())
            {
                if (SetVolumeParameter(targetComponent, prop.Name, prop.Value))
                    setParams.Add(prop.Name);
                else
                    failedParams.Add(prop.Name);
            }

            if (profile is UnityEngine.Object profileObj)
                EditorUtility.SetDirty(profileObj);

            var msg = $"Set {setParams.Count} parameter(s) on '{effectName}'";
            if (failedParams.Count > 0)
                msg += $". Failed: {string.Join(", ", failedParams)}";

            return new
            {
                success = true,
                message = msg,
                data = new { effect = effectName, set = setParams, failed = failedParams }
            };
        }

        // === volume_remove_effect ===
        // Params: target, effect
        internal static object RemoveEffect(JObject @params)
        {
            var p = new ToolParams(@params);
            string effectName = p.Get("effect");
            if (string.IsNullOrEmpty(effectName))
                return new ErrorResponse("'effect' parameter is required.");

            var volume = GraphicsHelpers.FindVolume(@params);
            if (volume == null)
                return new ErrorResponse("Volume not found.");

            var effectType = GraphicsHelpers.ResolveVolumeComponentType(effectName);
            if (effectType == null)
                return new ErrorResponse($"Effect type '{effectName}' not found.");

            var profile = GetProperty(volume, "sharedProfile");
            if (profile == null)
                return new ErrorResponse("Volume has no profile.");

            // Check if effect exists before removing
            bool found = false;
            var components = GetProperty(profile, "components") as System.Collections.IList;
            if (components != null)
            {
                foreach (var comp in components)
                {
                    if (comp != null && comp.GetType() == effectType)
                    {
                        found = true;
                        break;
                    }
                }
            }
            if (!found)
                return new ErrorResponse($"Effect '{effectName}' not found on this Volume.");

            var removeMethod = GraphicsHelpers.VolumeProfileType.GetMethod("Remove",
                new[] { typeof(Type) });
            if (removeMethod == null)
                return new ErrorResponse("Could not find VolumeProfile.Remove method.");

            removeMethod.Invoke(profile, new object[] { effectType });

            if (profile is UnityEngine.Object profileObj)
                EditorUtility.SetDirty(profileObj);
            GraphicsHelpers.MarkDirty(volume);

            return new
            {
                success = true,
                message = $"Removed '{effectName}' from Volume.",
                data = new { effect = effectName }
            };
        }

        // === volume_get_info ===
        // Params: target (optional -- if omitted, returns info for all volumes)
        internal static object GetInfo(JObject @params)
        {
            var volume = GraphicsHelpers.FindVolume(@params);
            if (volume == null)
                return new ErrorResponse("Volume not found.");

            var info = BuildVolumeInfo(volume);
            return new
            {
                success = true,
                message = $"Volume info for '{(volume as Component)?.gameObject.name}'.",
                data = info
            };
        }

        // === volume_set_properties ===
        // Params: target, weight, priority, is_global, blend_distance
        //         OR properties dict with those keys
        internal static object SetProperties(JObject @params)
        {
            var p = new ToolParams(@params);
            var volume = GraphicsHelpers.FindVolume(@params);
            if (volume == null)
                return new ErrorResponse("Volume not found.");

            // Unpack "properties" dict into top-level params so callers can use either style
            var propsDict = p.GetRaw("properties") as JObject;
            if (propsDict != null)
            {
                foreach (var prop in propsDict.Properties())
                {
                    if (@params[prop.Name] == null)
                        @params[prop.Name] = prop.Value;
                }
                p = new ToolParams(@params);
            }

            var changed = new List<string>();

            var weight = p.GetFloat("weight");
            if (weight.HasValue) { SetProperty(volume, "weight", weight.Value); changed.Add("weight"); }

            var priority = p.GetFloat("priority");
            if (priority.HasValue) { SetProperty(volume, "priority", priority.Value); changed.Add("priority"); }

            if (p.Has("is_global")) { SetProperty(volume, "isGlobal", p.GetBool("is_global")); changed.Add("isGlobal"); }

            var blendDist = p.GetFloat("blend_distance");
            if (blendDist.HasValue) { SetProperty(volume, "blendDistance", blendDist.Value); changed.Add("blendDistance"); }

            if (changed.Count == 0)
                return new ErrorResponse("No properties specified. Use: weight, priority, is_global, blend_distance.");

            GraphicsHelpers.MarkDirty(volume);
            return new
            {
                success = true,
                message = $"Updated Volume properties: {string.Join(", ", changed)}",
                data = new { changed }
            };
        }

        // === volume_list_effects ===
        // No params needed -- lists all available VolumeComponent types
        internal static object ListEffects(JObject @params)
        {
            var types = GraphicsHelpers.GetAvailableEffectTypes();
            var effectList = types.Select(t => new
            {
                name = t.Name,
                fullName = t.FullName,
                ns = t.Namespace
            }).ToList();

            return new
            {
                success = true,
                message = $"Found {effectList.Count} available volume effects.",
                data = new { pipeline = GraphicsHelpers.GetPipelineName(), effects = effectList }
            };
        }

        // === volume_create_profile ===
        // Params: path (string -- asset path like "Assets/Settings/MyProfile.asset")
        internal static object CreateProfile(JObject @params)
        {
            var p = new ToolParams(@params);
            string path = p.Get("path");
            if (string.IsNullOrEmpty(path))
                return new ErrorResponse("'path' parameter is required (e.g., 'Settings/MyProfile' or 'Assets/Settings/MyProfile.asset').");

            // Auto-prepend Assets/ if missing (paths are relative to Assets/ by convention)
            if (!path.StartsWith("Assets/", StringComparison.OrdinalIgnoreCase) &&
                !path.StartsWith("Assets\\", StringComparison.OrdinalIgnoreCase))
                path = "Assets/" + path;

            if (!path.EndsWith(".asset", StringComparison.OrdinalIgnoreCase))
                path += ".asset";

            // Ensure directory exists
            var dir = System.IO.Path.GetDirectoryName(path);
            if (!string.IsNullOrEmpty(dir) && !AssetDatabase.IsValidFolder(dir))
            {
                // Create folders recursively
                var parts = dir.Replace("\\", "/").Split('/');
                string current = parts[0];
                for (int i = 1; i < parts.Length; i++)
                {
                    string next = current + "/" + parts[i];
                    if (!AssetDatabase.IsValidFolder(next))
                        AssetDatabase.CreateFolder(current, parts[i]);
                    current = next;
                }
            }

            var profile = ScriptableObject.CreateInstance(GraphicsHelpers.VolumeProfileType);
            AssetDatabase.CreateAsset(profile, path);
            AssetDatabase.SaveAssets();

            return new
            {
                success = true,
                message = $"Created VolumeProfile at '{path}'.",
                data = new { path }
            };
        }

        // === ListVolumes (used by VolumesResource) ===
        internal static object ListVolumes(JObject @params)
        {
            if (!GraphicsHelpers.HasVolumeSystem)
                return new { success = true, message = "Volume system not available.", data = new { volumes = new List<object>() } };

            var allVolumes = UnityFindObjectsCompat.FindAll(GraphicsHelpers.VolumeType);
            var volumeList = new List<object>();

            foreach (Component vol in allVolumes)
            {
                volumeList.Add(BuildVolumeInfo(vol));
            }

            return new
            {
                success = true,
                message = $"Found {volumeList.Count} volume(s).",
                data = new { pipeline = GraphicsHelpers.GetPipelineName(), volumes = volumeList }
            };
        }

        // --- Helper: Build info object for a single Volume ---
        private static object BuildVolumeInfo(object volumeComponent)
        {
            var comp = volumeComponent as Component;
            if (comp == null) return null;

            bool isGlobal = GetPropertyValue<bool>(volumeComponent, "isGlobal", true);
            float weight = GetPropertyValue<float>(volumeComponent, "weight", 1f);
            float priority = GetPropertyValue<float>(volumeComponent, "priority", 0f);
            float blendDistance = GetPropertyValue<float>(volumeComponent, "blendDistance", 0f);

            var profile = GetProperty(volumeComponent, "sharedProfile");
            string profileName = profile is UnityEngine.Object profileObj2 ? profileObj2.name : null;
            string profilePath = profile is UnityEngine.Object po ? AssetDatabase.GetAssetPath(po) : null;

            var effectsList = new List<object>();
            if (profile != null)
            {
                var components = GetProperty(profile, "components") as System.Collections.IList;
                if (components != null)
                {
                    foreach (var effect in components)
                    {
                        if (effect == null) continue;
                        var effectType = effect.GetType();
                        bool active = GetPropertyValue<bool>(effect, "active", true);

                        // Collect overridden parameters
                        var overriddenParams = new List<string>();
                        foreach (var field in effectType.GetFields(BindingFlags.Public | BindingFlags.Instance))
                        {
                            var fieldValue = field.GetValue(effect);
                            if (fieldValue == null) continue;
                            var overrideProp = fieldValue.GetType().GetProperty("overrideState");
                            if (overrideProp != null)
                            {
                                bool overridden = (bool)overrideProp.GetValue(fieldValue);
                                if (overridden)
                                    overriddenParams.Add(field.Name);
                            }
                        }

                        effectsList.Add(new
                        {
                            type = effectType.Name,
                            active,
                            overridden_params = overriddenParams
                        });
                    }
                }
            }

            return new
            {
                name = comp.gameObject.name,
                instance_id = comp.gameObject.GetInstanceIDCompat(),
                is_global = isGlobal,
                weight,
                priority,
                blend_distance = blendDistance,
                profile = profileName,
                profile_path = profilePath ?? "",
                effects = effectsList
            };
        }

        // --- Helper: Set a VolumeParameter field value via reflection ---
        // VolumeParameter<T> has: overrideState (bool), value (T)
        internal static bool SetVolumeParameter(object component, string fieldName, JToken value)
        {
            if (component == null || string.IsNullOrEmpty(fieldName)) return false;

            var field = component.GetType().GetField(fieldName,
                BindingFlags.Public | BindingFlags.Instance);
            if (field == null)
            {
                // Try camelCase conversion from snake_case
                string camelCase = StringCaseUtility.ToCamelCase(fieldName);
                field = component.GetType().GetField(camelCase,
                    BindingFlags.Public | BindingFlags.Instance);
            }
            if (field == null) return false;

            var param = field.GetValue(component);
            if (param == null) return false;

            // Set value with type conversion, then enable override on success
            var valueProp = param.GetType().GetProperty("value");
            if (valueProp == null) return false;

            try
            {
                object converted = ConvertToParameterType(value, valueProp.PropertyType);
                valueProp.SetValue(param, converted);

                var overrideProp = param.GetType().GetProperty("overrideState");
                if (overrideProp != null)
                    overrideProp.SetValue(param, true);

                return true;
            }
            catch (Exception ex)
            {
                McpLog.Warn($"[VolumeOps] Failed to set '{fieldName}': {ex.Message}");
                return false;
            }
        }

        // --- Helper: Convert JToken to target parameter type ---
        private static object ConvertToParameterType(JToken value, Type targetType)
        {
            if (value == null || value.Type == JTokenType.Null) return null;

            // Handle Color
            if (targetType == typeof(Color))
            {
                if (value is JArray arr && arr.Count >= 3)
                {
                    float r = arr[0].Value<float>();
                    float g = arr[1].Value<float>();
                    float b = arr[2].Value<float>();
                    float a = arr.Count >= 4 ? arr[3].Value<float>() : 1f;
                    return new Color(r, g, b, a);
                }
                // Try hex string
                if (value.Type == JTokenType.String)
                {
                    if (ColorUtility.TryParseHtmlString(value.ToString(), out Color c))
                        return c;
                }
            }

            // Handle Vector2
            if (targetType == typeof(Vector2))
            {
                if (value is JArray arr && arr.Count >= 2)
                    return new Vector2(arr[0].Value<float>(), arr[1].Value<float>());
            }

            // Handle Vector3
            if (targetType == typeof(Vector3))
            {
                if (value is JArray arr && arr.Count >= 3)
                    return new Vector3(arr[0].Value<float>(), arr[1].Value<float>(), arr[2].Value<float>());
            }

            // Handle Vector4
            if (targetType == typeof(Vector4))
            {
                if (value is JArray arr && arr.Count >= 4)
                    return new Vector4(arr[0].Value<float>(), arr[1].Value<float>(),
                                      arr[2].Value<float>(), arr[3].Value<float>());
            }

            // Handle enums
            if (targetType.IsEnum)
            {
                string str = value.ToString();
                if (Enum.TryParse(targetType, str, true, out object enumVal))
                    return enumVal;
                // Try as int
                if (int.TryParse(str, out int intVal))
                    return Enum.ToObject(targetType, intVal);
            }

            // Handle bool
            if (targetType == typeof(bool))
                return ParamCoercion.CoerceBool(value, false);

            // Handle float
            if (targetType == typeof(float))
                return ParamCoercion.CoerceFloat(value, 0f);

            // Handle int
            if (targetType == typeof(int))
                return ParamCoercion.CoerceInt(value, 0);

            // Handle Texture2D (by asset path)
            if (targetType == typeof(Texture2D) || targetType == typeof(Texture))
            {
                string path = value.ToString();
                return AssetDatabase.LoadAssetAtPath<Texture2D>(path);
            }

            // Fallback: try Convert
            try
            {
                return Convert.ChangeType(value.ToObject<object>(), targetType);
            }
            catch
            {
                return value.ToObject<object>();
            }
        }

        // --- Reflection helpers (with field fallback for Volume.sharedProfile etc.) ---
        private static object GetProperty(object obj, string name)
        {
            if (obj == null) return null;
            var prop = obj.GetType().GetProperty(name,
                BindingFlags.Public | BindingFlags.Instance);
            if (prop != null) return prop.GetValue(obj);
            // Fallback: try as a field (e.g., Volume.sharedProfile is a public field, not a property)
            var field = obj.GetType().GetField(name,
                BindingFlags.Public | BindingFlags.Instance);
            return field?.GetValue(obj);
        }

        private static T GetPropertyValue<T>(object obj, string name, T defaultValue)
        {
            var val = GetProperty(obj, name);
            if (val is T typed) return typed;
            return defaultValue;
        }

        private static void SetProperty(object obj, string name, object value)
        {
            if (obj == null) return;
            var prop = obj.GetType().GetProperty(name,
                BindingFlags.Public | BindingFlags.Instance);
            if (prop != null && prop.CanWrite)
            {
                prop.SetValue(obj, value);
                return;
            }
            // Fallback: try as a field (e.g., Volume.sharedProfile is a public field, not a property)
            var field = obj.GetType().GetField(name,
                BindingFlags.Public | BindingFlags.Instance);
            field?.SetValue(obj, value);
        }
    }
}