using System.Linq;
using UnityEngine;
using Sirenix.Utilities;
using System;
using System.IO;
#if UNITY_EDITOR
using UnityEditor;
#endif

[AttributeUsage(AttributeTargets.Class, AllowMultiple = true, Inherited = true)]
public class SingletonAssetPathAttribute : Attribute
{
    public readonly string Path;

    public SingletonAssetPathAttribute(string path)
    {
        this.Path = path;
    }
}

public static class UnityObjectSingleton<T>
    where T : UnityEngine.Object
{
    private static readonly bool isBehaviour = typeof(Behaviour).IsAssignableFrom(typeof(T));
    private static readonly bool isScriptableObject = typeof(ScriptableObject).IsAssignableFrom(typeof(T));
    private static readonly SingletonAssetPathAttribute assetAttribute = typeof(T).GetAttribute<SingletonAssetPathAttribute>(true);
    private static T instance;

    public static T Instance
    {
        get
        {
            if (!instance)
            {
                instance = FindOrCreateInstance();
            }

            return instance;
        }
    }

    public static void ForceSetInstance(T objInstance)
    {
        instance = objInstance;
    }

    private static T FindOrCreateInstance()
    {
        T tmp = null;
        tmp = FindAssetInMemory();
        if (tmp) return tmp;

#if UNITY_EDITOR
        tmp = FindAssetInstance();
        if (tmp) return tmp;

        tmp = TryCreateAsset();
        if (tmp) return tmp;
#endif

        tmp = CreateNewInstanceInMemory();
        if (tmp) return tmp;

        if (tmp == null)
        {
            throw new Exception("Could not find or create a singleton instance of type " + typeof(T).GetNiceName());
        }

        return tmp;
    }

    private static T CreateNewInstanceInMemory()
    {
        if (isBehaviour)
        {
            var obj = new GameObject(typeof(T).Name, typeof(T)).GetComponent<T>();
            obj.name = typeof(T).Name;
            return obj;
        }
        else if (isScriptableObject)
        {
            return ScriptableObject.CreateInstance(typeof(T)) as T;
        }
        else
        {
            throw new NotImplementedException(typeof(T).FullName + " is neither a Component or a ScriptableObject.");
        }
    }

    private static T FindAssetInMemory()
    {
        if (isBehaviour)
        {
            T obj = null;

            // Active scene objects
            obj = UnityEngine.Object.FindObjectOfType<T>();
            if (obj) return obj;

            // Inactive scene objects
            obj = Resources
                .FindObjectsOfTypeAll<T>()
                .Where(x => (x as Behaviour).gameObject.scene.name != null)
                .FirstOrDefault();

            return obj;
        }
        else if (isScriptableObject)
        {
            return Resources.FindObjectsOfTypeAll<T>().FirstOrDefault();
        }
        else
        {
            throw new NotImplementedException(typeof(T).FullName + " is neither a Component or a ScriptableObject.");
        }

    }

    private static string GetAssetPath(string path)
    {
        path = path.Replace('\\', '/').Trim('/');

        if (!path.StartsWith("assets", StringComparison.InvariantCultureIgnoreCase))
        {
            path = "Assets/" + path;
        }

        path = path.Trim('/'); // if path was ""

        if (string.IsNullOrEmpty(Path.GetExtension(path)))
        {
            string extension;

            if (isBehaviour)
            {
                extension = "prefab";
            }
            else
            {
                extension = "asset";
            }

            path += "/" + typeof(T).Name + "." + extension;
        }

        return path;
    }

#if UNITY_EDITOR
    private static T TryCreateAsset()
    {
        if (assetAttribute == null)
        {
            return null;
        }

        var assetPath = GetAssetPath(assetAttribute.Path);
        var folder = Path.GetDirectoryName(assetPath);
        if (!Directory.Exists(folder))
        {
            Directory.CreateDirectory(folder);
        }

        var name = Path.GetFileNameWithoutExtension(assetPath);

        if (isBehaviour)
        {
            var tmp = new GameObject(name, typeof(T));
            var prefab = PrefabUtility.CreatePrefab(assetPath, tmp);
            UnityEngine.Object.DestroyImmediate(tmp);
            return prefab.GetComponent<T>();
        }
        else
        {
            var tmp = ScriptableObject.CreateInstance(typeof(T));
            tmp.name = name;
            AssetDatabase.CreateAsset(tmp, assetPath);
            return tmp as T;
        }
    }

    private static T FindAssetInstance()
    {
        if (assetAttribute != null)
        {
            var assetPath = GetAssetPath(assetAttribute.Path);
            if (isBehaviour)
            {
                var asset = AssetDatabase.LoadAssetAtPath(assetPath, typeof(GameObject));
                if (asset)
                {
                    var prefabInstance = (PrefabUtility.InstantiatePrefab(asset) as GameObject).GetComponent<T>();
                    prefabInstance.name = asset.name;
                    return prefabInstance;
                }
                else
                {
                    // Not found.
                    return null;
                }
            }
            else if (isScriptableObject)
            {
                var asset = AssetDatabase.LoadAssetAtPath<T>(assetPath);
                if (asset)
                {
                    return asset;
                }

                // The asset could have been moved to a diferent location.
                var newAssetPath = AssetDatabase.FindAssets("t:" + (typeof(T).Name))
                    .Select(guid => AssetDatabase.GUIDToAssetPath(guid))
                    .FirstOrDefault();

                if (newAssetPath != null)
                {
                    asset = AssetDatabase.LoadAssetAtPath<T>(newAssetPath);
                    if (asset)
                    {
                        Debug.LogWarning("The singleton of type" + typeof(T).Name + " was expected to be found at: '" + assetPath + "', but was instead found at: '" + newAssetPath + "'");
                        return asset;
                    }
                }
            }
            else
            {
                throw new NotSupportedException();
            }
        }

        return null;
    }
#endif
}