using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using UnityEditor;
using UnityEngine;
using Sirenix.Utilities.Editor;
using Sirenix.OdinInspector.Editor;
using BehaviorDesigner.Editor;
using BehaviorDesigner.Runtime;
using MyGame.Gameplay.AI.BehaviorTree;

namespace MyGame.Gameplay.Agents.Controllers.Editor {
    [CustomEditor(typeof(NPCController))]
    public class NPCControllerEditor : OdinEditor {
        public override void OnInspectorGUI() {
            base.OnInspectorGUI();

            if (!GUILayout.Button("Update Behavior Tree Mapped Properties", SirenixGUIStyles.Button)) { return; }

            NPCController npcController = (NPCController)target;
            BehaviorTree[] behaviorTrees = npcController.GetComponents<BehaviorTree>();

            for (int i = 0; i < behaviorTrees.Length; i++) {
                Debug.LogWarningFormat("Updating Behavior Tree: {0}", i);

                UpdateBehaviorTreeMappedProperties<NPCController>(npcController.gameObject, behaviorTrees[i]);
            }

            EditorUtility.SetDirty(npcController.gameObject);
        }

        static void UpdateBehaviorTreeMappedProperties<T>(GameObject gameObject, BehaviorTree behaviorTree) {
            Type type = typeof(T);
            PropertyInfo[] properties = type.GetProperties();
            string propertyFormat = type.FullName + "/{0}";

            List<SharedVariable> btVariables = behaviorTree.GetAllVariables();
            List<PropertyInfo> mappedProperties = new List<PropertyInfo>();
            List<string> newPropertyNames = new List<string>();

            foreach (PropertyInfo property in properties) {
                MappedPropertyAttribute attribute = (MappedPropertyAttribute)property.GetCustomAttributes(typeof(MappedPropertyAttribute), false).FirstOrDefault();

                if (attribute == null) { continue; }

                SharedVariable sharedVariable = btVariables.FirstOrDefault(variable => variable.Name == property.Name);
                bool isNew = sharedVariable == null;

                if (isNew) {
                    if (!CreateSharedVariable(property, ref sharedVariable)) { continue; }

                    btVariables.Add(sharedVariable);
                    newPropertyNames.Add(property.Name);
                } else {
                    if (!IsSharedVariableForPropertyType(sharedVariable.GetType(), property.PropertyType)) {
                        Debug.LogErrorFormat("Type mismatch on property {0}: MappedProperty type: {1}, SharedVariable type: {2}", property.Name, property.PropertyType, sharedVariable.GetType());

                        continue;
                    }
                }

                sharedVariable.PropertyMapping = string.Format(propertyFormat, property.Name);
                sharedVariable.PropertyMappingOwner = gameObject;

                mappedProperties.Add(property);
            }

            string[] btVariablesUnmapped = btVariables.Where(variable => variable.Name != "NPCController" && mappedProperties.All(mappedProperty => mappedProperty.Name != variable.Name)).Select(variable => variable.Name).ToArray();

            btVariables = btVariables.OrderBy(variable => variable.Name != "NPCController")
                                     .ThenBy(variable => btVariablesUnmapped.Contains(variable.Name))
                                     .ThenBy(variable => mappedProperties.FindIndex(mappedProperty => mappedProperty.Name == variable.Name))
                                     .ToList();

            SerializeBehaviorTree(behaviorTree, btVariables);

            if (newPropertyNames.Count > 0) { Debug.LogFormat("{0} new properties created: {1}", newPropertyNames.Count, string.Join(", ", newPropertyNames.ToArray())); }
            if (btVariablesUnmapped.Length > 0) { Debug.LogFormat("Unmapped variables: {0}", string.Join(", ", btVariablesUnmapped)); }
        }

        static bool CreateSharedVariable(PropertyInfo property, ref SharedVariable sharedVariable) {
            Type sharedVariableType = GetSharedVariableForPropertyType(property.PropertyType);

            if (sharedVariableType == null) {
                Debug.LogErrorFormat("Cannot find SharedVariable class for {0} (property type: {1})", property.Name, property.PropertyType);

                return false;
            }

            sharedVariable = (SharedVariable)Activator.CreateInstance(sharedVariableType);
            sharedVariable.IsShared = true;
            sharedVariable.IsGlobal = false;
            sharedVariable.IsDynamic = false;
            sharedVariable.Name = property.Name;

            return true;
        }

        static Type GetSharedVariableForPropertyType(Type propertyType) {
            Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();

            return assemblies.Select(assembly => assembly.GetTypes().FirstOrDefault(type => IsSharedVariableForPropertyType(type, propertyType)))
                             .FirstOrDefault(sharedType => sharedType != null);
        }

        static bool IsSharedVariableForPropertyType(Type type, Type propertyType) {
            Type baseType = type.BaseType;

            return baseType != null &&
                   baseType.IsGenericType &&
                   baseType.GetGenericTypeDefinition() == typeof(SharedVariable<>) &&
                   baseType.GetGenericArguments()[0] == propertyType;
        }

        static void SerializeBehaviorTree(BehaviorTree behaviorTree, List<SharedVariable> variables) {
            BehaviorSource behaviorSource = behaviorTree.GetBehaviorSource();
            behaviorSource.SetAllVariables(variables);

            if (BehaviorDesignerPreferences.GetBool(BDPreferences.BinarySerialization)) {
                BinarySerialization.Save(behaviorSource);
            } else {
                JSONSerialization.Save(behaviorSource);
            }
        }
    }
}