using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Xml;
using System.Xml.Linq;
using UnityEditor;
using UnityEngine;

namespace Wwise.Wooduan.Tools
{
    public class AkWooduanScriptingTools
    {
        
    #region XML
        public static void WriteXml(string filePath, XElement xRoot)
        {
            var settings = new XmlWriterSettings
            {
                Encoding = new UTF8Encoding(false), 
                Indent = true
            };
            var xmlWriter = XmlWriter.Create(filePath, settings);
            xRoot.Save(xmlWriter);
            xmlWriter.Flush();
            xmlWriter.Close();
        }

        public static string GetXmlAttribute(XElement node, string attribute)
        {
            if (node == null) return "";
            var a = node.Attribute(attribute);
            return a != null ? a.Value : "";
        }

        public static string GetXmlElement(XElement node, string nodeName)
        {
            if (node == null) return "";
            var a = node.Element(nodeName);
            return a != null ? a.Value : "";
        }

        public static void RemoveComponentXml(XElement xComponent)
        {
            var parent = xComponent.Parent;
            xComponent.Remove();
            if (parent != null && !parent.HasElements)
                parent.Remove();
        }

    #endregion

    #region TypeCast

    public static float StringToFloat(string s)
    {
        float outValue;
        float.TryParse(s, out outValue);
        return outValue;
    }

    public static byte StringToByte(string s)
    {
        byte outValue;
        byte.TryParse(s, out outValue);
        return outValue;
    }

    public static int StringToInt(string s)
    {
        int outValue;
        int.TryParse(s, out outValue);
        return outValue;
    }

    public static bool StringToBool(string s)
    {
        return s == "true";
    }
    
    public static Guid StringToGuid(string s)
    {
        return new Guid(s);
    }

    public static Vector3 StringToVector3(string s)
    {
        var numbers = s.Split(',');
        if (numbers.Length != 3) return Vector3.zero;
        float x, y, z;
        float.TryParse(numbers[0].Trim(), out x);
        float.TryParse(numbers[1].Trim(), out y);
        float.TryParse(numbers[2].Trim(), out z);
        return new Vector3(x, y, z);
    }

    public static Type StringToType(string typeName)
    {
        if (typeName == "") return null;
        var assembly = Assembly.Load("Assembly-CSharp");
        return (assembly.GetType(typeName) ?? assembly.GetType("AK.Wooduan.Components." + typeName)) ??
               Type.GetType("UnityEngine." + typeName + ", UnityEngine");
    }

    public static void AddToArray<T>(ref T[] array, T element)
    {
        var list = array.ToList();
        list.Add(element);
        array = list.ToArray();
    }

    public static void RemoveFromArray<T>(ref T[] array, T element)
    {
        var list = array.ToList();
        list.Remove(element);
        array = list.ToArray();
    }

    public static uint GenerateUniqueID(string in_name)
    {
        var buffer = Encoding.UTF8.GetBytes(in_name.ToLower());
        var hval = 2166136261;

        foreach (var bt in buffer)
        {
            hval *= 16777619;
            hval ^= bt;
        }
        return hval;
    }
    #endregion

    #region FileIO
    public static void CheckDirectoryExist(string directory)
    {
        if (directory != null && !Directory.Exists(directory))
            Directory.CreateDirectory(directory);
    }

    public static string ShortPath(string longPath, bool includeAssetsPrefix = true)
    {
        longPath = longPath.Replace("\\", "/");
        var index = longPath.IndexOf("Assets", StringComparison.Ordinal);
        if (index >= 0)
            return includeAssetsPrefix ? longPath.Substring(index) : longPath.Substring(index + 7);
        return longPath;
    }

    public static string CombinePath(string path1, string path2, string path3 = "", string path4 = "")
    {
        if (string.IsNullOrEmpty(path2))
            return path1.Replace("\\", "/");
        var path = Path.Combine(path1, path2);
        if (path3 != "")
            path = Path.Combine(path, path3);
        if (path4 != "")
            path = Path.Combine(path, path4);
        return path.Replace("\\", "/");
    }
    #endregion

    #region Process

    public static void RunCommand(string cmd, string arguments)
    {
        var process = new Process
        {
            StartInfo =
            {
                FileName = cmd,
                UseShellExecute = false,
                RedirectStandardOutput = true,
                CreateNoWindow = true,
                Arguments = arguments
            }
        };

        process.Start();

        var reader = process.StandardOutput;
        reader.ReadToEnd();
        process.WaitForExit();
        process.Close();
    }

    #endregion

    #region Json
    public static string FromJson(string jsonString, string fieldName)
    {
        var propertyString = "\"" + fieldName + "\": ";
        var indexStart = jsonString.IndexOf(propertyString, StringComparison.Ordinal);
        if (indexStart < 0)
            return "";
        indexStart += propertyString.Length;
        var trimmedValue = jsonString.Substring(indexStart);
        
        if (trimmedValue.StartsWith("["))
            return trimmedValue.Substring(1, trimmedValue.IndexOf(']') - 1);
        if (trimmedValue.StartsWith("{"))
            return trimmedValue.Substring(1, trimmedValue.IndexOf('}') - 1);
        if (trimmedValue.StartsWith("\""))
        {
            trimmedValue = trimmedValue.Substring(1);
            return trimmedValue.Substring(0, trimmedValue.IndexOf('\"'));
        }
        return "";
    }

    public static string[] ParseJsonArray(string arrayData)
    {
        var body = arrayData.Substring(1, arrayData.Length - 2);
        var objects = body.Split('{');
        if (objects.Length > 0)
            return objects.Select(obj => obj.Replace("}, ", "").Replace("}", "")).ToArray();
        var clipPaths = body.Split(',');
        return clipPaths.Select(p => p.Trim().Trim('\"')).ToArray();
    }

    public static string ToJson(object obj)
    {
        var argument = "{";
        var properties = obj.GetType().GetProperties();
        for (var i = 0; i < properties.Length; i++)
        {
            WriteJsonLine(ref argument, properties[i], obj);
            if (i < properties.Length - 1)
                argument += ", ";
        }
        var fields = obj.GetType().GetFields();
        for (var i = 0; i < fields.Length; i++)
        {
            WriteJsonLine(ref argument, fields[i], obj);
            if (i < fields.Length - 1)
                argument += ", ";
        }
        argument += "}";
        return argument;
    }

    private static void WriteJsonLine(ref string argument, MemberInfo info, object obj)
    {
        var pInfo = info as PropertyInfo;
        var fInfo = info as FieldInfo;
        var type = pInfo != null ? pInfo.PropertyType : fInfo.FieldType;
        var value = pInfo != null ? pInfo.GetValue(obj, null) : fInfo.GetValue(obj);
        if (type.IsArray)
        {
            argument += $"\"{info.Name}\": [";
            var array = value as IEnumerable;
            var hasElements = false;
            if (array != null)
            {
                foreach (var element in array)
                {
                    hasElements = true;
                    WriteJsonArray(ref argument, element);
                    argument.Remove(argument.Length - 3);
                }
            }
            if (hasElements)
                argument = argument.Remove(argument.Length - 2) + "]";
            else
                argument += "]";
        }
        else if (type == typeof(string) || type == typeof(bool) || type == typeof(int) || type == typeof(float))
            argument += $"\"{info.Name}\": \"{value}\"";
        else
            argument += $"\"{info.Name}\": {ToJson(value)}";
    }

    private static void WriteJsonArray(ref string argument, object obj)
    {
        var type = obj.GetType();
        if (type == typeof(string) || type == typeof(bool))
            argument += string.Format("\"{0}\"", obj);
        else if (type == typeof(Guid))
            argument += "\"{" + obj + "}\"";
        else if (type.IsClass)
            argument += ToJson(obj);
        else
            argument += obj.ToString();
        argument += ", ";
    }
    #endregion
    
    #region GUI
        public static void DrawSphere(UnityEngine.Vector3 in_position, float in_radius)
        {
            UnityEditor.Handles.color = AkWwiseEditorSettings.Instance.attenuationSphereColor;

            if ((UnityEditor.SceneView.lastActiveSceneView.camera.transform.position - in_position).sqrMagnitude > in_radius * in_radius)
            {
                UnityEditor.Handles.SphereHandleCap(0, in_position, UnityEngine.Quaternion.identity, in_radius * 2.0f, UnityEngine.EventType.Repaint);
            }
            else
            {
                DrawDiscs(UnityEngine.Vector3.up, UnityEngine.Vector3.down, 6, in_position, in_radius);
            }
        }
        
        public static void DrawDiscs(UnityEngine.Vector3 in_startNormal, UnityEngine.Vector3 in_endNormal, uint in_nbDiscs,
            UnityEngine.Vector3 in_position, float in_radius)
        {
            var f = 1.0f / in_nbDiscs;
            for (var i = 0; i < in_nbDiscs; i++)
            {
                UnityEditor.Handles.DrawWireDisc(in_position, UnityEngine.Vector3.Slerp(in_startNormal, in_endNormal, f * i), in_radius);
            }
        }
    #endregion
    
    #region AssetManagement

    public static void IterateSelectedGameObjects<T>(Action<T> action) where T : MonoBehaviour
    {
        foreach (var gameObject in Selection.gameObjects)
        {
            var component = gameObject.GetComponent<T>();
            if (component)
                action.Invoke(component);
        }
    }
    
    public static void CheckoutLockedFile(string filePath)
    {
        var fileInfo = new FileInfo(filePath);
        if (!fileInfo.Exists) return;
        if (fileInfo.IsReadOnly)
        {
            if (UnityEditor.VersionControl.Provider.isActive)
                UnityEditor.VersionControl.Provider.Checkout(filePath, UnityEditor.VersionControl.CheckoutMode.Asset);
            fileInfo.IsReadOnly = false;
        }
    }
    
    public static void SetAssetBundleName(GameObject gameObject, string assetBundleName, string variantName = "")
    {
        var prefabAsset = UnityEditor.PrefabUtility.GetPrefabParent(gameObject);
        if (!prefabAsset)
            prefabAsset = UnityEditor.PrefabUtility.GetPrefabObject(gameObject);
        if (!prefabAsset)
            return;
        var assetPath = UnityEditor.AssetDatabase.GetAssetPath(prefabAsset);
        var importer = UnityEditor.AssetImporter.GetAtPath(assetPath);
        if (importer)
            importer.SetAssetBundleNameAndVariant(assetBundleName, variantName);
        importer.SaveAndReimport();
    }
    #endregion
    }
}