/JSONConfig.cs

using UnityEngine;

using System;

using System.Collections;

using System.Collections.Generic;

using System.Linq;

using System.Reflection;

using System.IO;



// By Ryan Duane Williams, with slight modifications by Johannes Hoff and Chris Pine



/*

 * Attach this script to a single object in the scene which has the "Static" tag.  This is the "Unitary" pattern.

 *

 * JSON files are expected to live in Assets/Resources/Config in the source tree and have the

 * extension ".bytes" (the extension is so Unity's asset bundling doesn't munge their contents).  If you're

 * building a webplayer you should create a corresponding Config/ directory at the same level as webplayer.html.

 * The player will try to load files from that directory, and if it certain errors occur it'll

 * fall back on the configs from Assets/Resources which will be packed into the ".unity3d" file.  Most errors

 * it'll just bitch at you continually until you fix the files.

 *

 * Here's a very basic sample usage:

         JSONConfig.inst.LoadConfig("Config/fish.bytes", (f, dict) => {

            JSONConfig.SetFields(this, dict);

            Debug.Log("Loaded " + f);

        });

 */

public class JSONConfig : MonoBehaviour {

    public static JSONConfig _inst = null;

    public static JSONConfig inst {

        get {

            if(_inst == null) _inst = GameObject.FindGameObjectWithTag("Static").GetComponent<JSONConfig>();

            return _inst;

        }

    }



    // don't even try WWW on these platforms because it just times out (but: can cause you to introduce race conditions, so be sure to test with skipWeb == false)

    private bool skipWeb {

        get {

            return (Application.platform != RuntimePlatform.OSXWebPlayer &&

           Application.platform != RuntimePlatform.WindowsWebPlayer &&

           Application.platform != RuntimePlatform.NaCl);

        }

    }



    public delegate void LoadDelegate(string s, Dictionary<string, object> d);

    private Dictionary<string, Dictionary<string, object>> loadedConfigs = new Dictionary<string, Dictionary<string, object>>();

    private Dictionary<string, LoadDelegate> pendingLoads = new Dictionary<string, LoadDelegate>();



    // convenience method to parse an enum value out of a string

    public static T GetEnum<T>(string v)

    {

        return (T)Enum.Parse(typeof(T),v);

    }



    // create an instance of an object and immediately set fields on it from the json dict.  Requires a zero-args constructor on the type.

    public static T CreateInstance<T>(Dictionary<string, object> dict) {

        var obj = System.Activator.CreateInstance<T>();

        SetFields (obj, dict);

        return obj;

    }



    // non-generic CreateInstance sometimes comes in handy

    public static object CreateInstance(Type t, Dictionary<string, object> dict) {

        var obj = System.Activator.CreateInstance(t);

        SetFields (obj, dict);

        return obj;

    }



    public static void SetFields(System.Object obj, Dictionary<string, object> dict) {

        Type type = obj.GetType();

        SetFields (type, obj, dict);

    }



    /* Sets all members on the object *obj* based on the appropriate key from *dict*, which is presumed to be in JSON form.

    * So if you have an instance of a Thing:

    *   public class Thing {

    *      float m1;

    *      string m2;

    *   }

    *

    * You can modify its fields with the parsed form of this JSON:

    *  {"m1":1.0, "m2":"test"}

    *

    * Ignores any name mismatches that might arise because that's more useful than being strict for me right now.  Sets static and private variables.

    */

    public static void SetFields(Type type, System.Object obj, Dictionary<string, object> dict) {

        if(dict == null) return;

        foreach (FieldInfo f in type.GetFields(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static)) {

            if(dict.ContainsKey(f.Name)) {

                SetField(f, obj, dict[f.Name]);

            }

        }

    }



    // Sets an individual field on an object from a parsed JSON structure.

    // Uses many different rules, based mostly on the type of the field, to decide how to do the setting.

    public static void SetField(FieldInfo f, object obj, object value) {

        f.SetValue(obj, GetValueOfType(f.FieldType, value));

    }



    private static object GetValueOfType(Type fieldType, object value) {

        if (fieldType == typeof(float)) {

            return Convert.ToSingle(value);

        }

        if (fieldType == typeof(int)) {

            return Convert.ToInt32(value);

        }

        if (fieldType == typeof(string)) {

            return value;

        }

        if (fieldType == typeof(List<int>)) {         // List<int>, [1,2,3] => new List<int>({1,2,3});

            var c = ((List<object>)value).ConvertAll<int>(Convert.ToInt32);

            return c;

        }

        if (fieldType.IsEnum) {        // AudioRolloffMode, "Custom" => AudioRolloffMode.Custom

            return Enum.Parse(fieldType, (string)value, true);

        }

        if (fieldType == typeof(Vector2)) {         // Vector2, [1,2] => new Vector2(1,2);

            var c = ((List<object>)value).ConvertAll<float>(Convert.ToSingle);

            return new Vector2(Convert.ToSingle(c[0]), Convert.ToSingle(c[1]));

        }

        if (fieldType == typeof(Color)) {          // Color, [1,1,1,1] => new Color(1,1,1,1)

            var c = ((List<object>)value).ConvertAll<float>(Convert.ToSingle);



            if (c.Count == 3) {

                return new Color(c[0], c[1], c[2]);

            }

            if (c.Count == 4) {

                return new Color(c[0], c[1], c[2], c[3]);

            }

        }

        if (fieldType.IsGenericType) {

            // this chunk of code handles generic dictionaries and lists; it only works with string keys on the dictionaries, and for now any values must have zero-args constructors

            if (fieldType.GetGenericTypeDefinition() == typeof(Dictionary<,>)) {

                Type[] typeParameters = fieldType.GetGenericArguments();

                if (typeParameters[0] == typeof(string)) {

                    var sourceDict = (Dictionary<string, object>)value;

                    var destDict = Activator.CreateInstance(fieldType);

                    var addToDest = fieldType.GetMethod("Add", typeParameters);

                    foreach (var kv in sourceDict) {

                        if (typeParameters[1] == typeof(object)) {

                            addToDest.Invoke(destDict, new[] { kv.Key, kv.Value });

                        } else {

                            var subValue = CreateInstance(typeParameters[1], (Dictionary<string, object>)kv.Value);

                            addToDest.Invoke(destDict, new[] { kv.Key, subValue });

                        }

                    }

                    return destDict;

                }



                Debug.Log("Dictionary doesn't have string keys");  // could theoretically handle non-string keys, but it's more work

                return null;

            }

            if (fieldType.GetGenericTypeDefinition() == typeof(List<>)) {

                Type[] typeParameters = fieldType.GetGenericArguments();

                var sourceList = (List<object>)value;

                var destList = Activator.CreateInstance(fieldType);

                var addToDest = fieldType.GetMethod("Add", typeParameters);

                foreach (var val in sourceList.Select(item => GetValueOfType(typeParameters[0], item))) {

                    addToDest.Invoke(destList, new[] { val });

                }

                return destList;

            }

        }

        if (fieldType.GetMethod("FromJson") != null) { // if there's a custom parser method on the class, delegate all work to that

            MethodInfo m = fieldType.GetMethod("FromJson");

            return m.Invoke(null, new[] { value });

        }

        if (fieldType.IsClass) {

            // Try instantiating a single object with CreateInstance

            var memb = CreateInstance(fieldType, (Dictionary<string, object>)value);

            return memb;

        }



        // catchall, this will probably never work

        return value;

    }



    // Loads a json file and calls the callback when it's completely parsed.

    // Filename should be of the form "Config/foo.bytes"

    public void LoadConfig(string filename, LoadDelegate cb) {

        LoadConfig(filename, cb, new string[]{}, false);

    }



    // More arguments to LoadConfig.  Dependencies specify a list of other configs that must be loaded (and their own callbacks called) before the callback is called.  This is definitely not the right system level to express initialization dependencies so try not to use this argument unless you are super lazy.

    // The *force* boolean forces the file to be reloaded (instead of using an in-memory cache); useful if you want to check for changes without reloading the game.

    public void LoadConfig(string filename, LoadDelegate cb, IEnumerable<string> dependencies, bool force) {

        if (!force && loadedConfigs.ContainsKey(filename) && areDependenciesLoaded(dependencies)) {

            cb(filename, loadedConfigs[filename]);

        }

        if(pendingLoads.ContainsKey(filename)) {

            pendingLoads[filename] = pendingLoads[filename] + cb;

        } else {

            pendingLoads[filename] = cb;

            StartCoroutine(WaitForLoad(filename, dependencies));

        }

    }



    void FinishLoad(string filename, Dictionary<string, object> dict) {

        loadedConfigs[filename] = dict;

        pendingLoads[filename](filename, dict);

        pendingLoads.Remove(filename);

    }



    IEnumerator WaitForLoad(string filename, IEnumerable<string> dependencies) {

        if(skipWeb) {

            var dict = LoadFromResources(filename);

            while (!areDependenciesLoaded(dependencies)) {

                Debug.Log ("Waiting for dependencies for " + filename);

                yield return new WaitForSeconds(0f);

            }

            FinishLoad(filename, dict);

            yield break;

        }

        while (true) {

            WWW www = new WWW(filename);

            yield return www;

            if (www.error == null) {

                var dict = MiniJSON.Json.Deserialize(www.text) as Dictionary<string, object>;

                while (!areDependenciesLoaded(dependencies)) yield return new WaitForSeconds(0.1f);

                FinishLoad(filename, dict);

                break;

            }

            else {

                if (www.error.EndsWith("(Domain name not found)") || www.error.EndsWith("Host not found")) {

                    Debug.Log("Falling back to bundled resource for " + filename);

                    var dict = LoadFromResources(filename);

                    while (!areDependenciesLoaded(dependencies)) yield return new WaitForSeconds(0.1f);

                    FinishLoad(filename, dict);

                    break;

                }

                else {

                    Debug.LogError("Error loading from server: " + www.error);

                    Debug.Log("Error loading from server " + www.error);

                    yield return new WaitForSeconds(0.5f);

                }

            }

        }

    }



    Dictionary<string, object> LoadFromResources(string filename) {

        string resource_filename = Path.ChangeExtension(filename, null); // for some reason it prefers them without extensions

        TextAsset asset = (TextAsset)Resources.Load(resource_filename);

        var dict = MiniJSON.Json.Deserialize(asset.text) as Dictionary<string, object>;

        return dict;

    }



    private bool areDependenciesLoaded(IEnumerable<string> deps) {

        bool loaded = true;

        foreach (var dep in deps) {

            loaded = loaded && loadedConfigs.ContainsKey(dep);

        }

        return loaded;

    }

}





/*

public class TestClass {

    public string key;

    public TestClass() {

        key = "wrong";

    }

}



 Test code:

        LoadConfig("Config/test.json", f, d => {

            Debug.Log("loaded " + f);

            var tc = new TestClass();

            SetFields(tc, d);

            Debug.Log ("ok " + tc.key);

            Debug.Log("ok " + tc.key);

        });*/