using System.Collections.Generic;

namespace TruegearSdk
{
    public enum ActionType
    {
        Shake,
        Electrical
    }
    public enum IntensityMode
    {
        Const,
        Fade,
        FadeInAndOut
    }

    public class EffectObject
    {
        public string name { get; set; }

        public string uuid { get; set; }

        public TrackObject[] trackList { get; set; }

        public bool keep { get; set; }

        public static EffectObject Copy(EffectObject curj)
        {
            List<TrackObject> list = new List<TrackObject>();
            EffectObject effectObject = new EffectObject();
            effectObject.name = curj.name;
            effectObject.uuid = curj.uuid;
            effectObject.keep = curj.keep;
            foreach (TrackObject trackObject in curj.trackList)
            {
                TrackObject trackObject2 = new TrackObject();
                trackObject2.start_time = trackObject.start_time;
                trackObject2.end_time = trackObject.end_time;
                trackObject2.start_intensity = trackObject.start_intensity;
                trackObject2.interval = trackObject.interval;
                trackObject2.end_intensity = trackObject.end_intensity;
                trackObject2.intensity_mode = trackObject.intensity_mode;
                trackObject2.action_type = trackObject.action_type;
                trackObject2.stopName = trackObject.stopName;
                trackObject2.once = trackObject.once;
                List<int> list2 = new List<int>();
                foreach (int item in trackObject.index)
                {
                    list2.Add(item);
                }
                trackObject2.index = list2.ToArray();
                list.Add(trackObject2);
            }
            effectObject.trackList = list.ToArray();
            return effectObject;
        }

        public JSONObject ToJsonObject()
        {
            JSONObject jsonobject = new JSONObject();
            jsonobject["name"] = this.name;
            jsonobject["uuid"] = this.name;
            jsonobject["keep"] = this.keep.ToString();
            JSONNode jsonnode = jsonobject["tracks"] = new JSONArray();
            JSONArray jsonarray = (JSONArray)jsonnode;
            TrackObject[] array = this.trackList;
            bool flag = this.trackList == null;
            if (flag)
            {
                array = new List<TrackObject>().ToArray();
            }
            TrackObject[] array2 = array;
            foreach (TrackObject trackObject in array2)
            {
                jsonarray.Add(trackObject.ToJsonObject());
            }
            return jsonobject;
        }

        public static EffectObject ToObject(JSONObject jsonObj)
        {
            List<TrackObject> list = new List<TrackObject>();
            EffectObject effectObject = new EffectObject();
            effectObject.name = jsonObj.GetValueOrDefault("name", "");
            effectObject.uuid = jsonObj.GetValueOrDefault("uuid", "");
            effectObject.keep = false;
            bool flag = jsonObj.GetValueOrDefault("keep", "False") == "True";
            if (flag)
            {
                effectObject.keep = true;
            }
            foreach (KeyValuePair<string, JSONNode> keyValuePair in jsonObj["tracks"])
            {
                TrackObject item = TrackObject.ToObject(keyValuePair.Value.AsObject);
                list.Add(item);
            }
            effectObject.trackList = list.ToArray();
            return effectObject;
        }
    }

    public class TrackObject
    {
        public ActionType action_type { get; set; }

        public bool once { get; set; }

        public string stopName { get; set; }

        public int interval { get; set; }

        public int start_time { get; set; }

        public int end_time { get; set; }

        public int start_intensity { get; set; }

        public int end_intensity { get; set; }

        public int[] index { get; set; }

        public JSONObject ToJsonObject()
        {
            JSONObject jsonobject = new JSONObject();
            jsonobject["start_time"] = this.start_time;
            jsonobject["end_time"] = this.end_time;
            jsonobject["stop_name"] = this.stopName;
            jsonobject["start_intensity"] = this.start_intensity;
            jsonobject["end_intensity"] = this.end_intensity;
            jsonobject["intensity_mode"] = this.intensity_mode.ToString();
            jsonobject["action_type"] = this.action_type.ToString();
            jsonobject["once"] = this.once.ToString();
            jsonobject["interval"] = this.interval;
            JSONNode jsonnode = jsonobject["index"] = new JSONArray();
            JSONArray jsonarray = (JSONArray)jsonnode;
            int[] index = this.index;
            int[] array = index;
            foreach (int n in array)
            {
                jsonarray.Add(n);
            }
            return jsonobject;
        }

        private static int GetInt(JSONObject obj, string key, int defaultValue = -1)
        {
            JSONNode valueOrDefault = obj.GetValueOrDefault(key, defaultValue);
            bool isNumber = valueOrDefault.IsNumber;
            int result;
            if (isNumber)
            {
                result = obj[key].AsInt;
            }
            else
            {
                bool isString = valueOrDefault.IsString;
                if (isString)
                {
                    result = int.Parse(obj[key]);
                }
                else
                {
                    result = defaultValue;
                }
            }
            return result;
        }

        public static TrackObject ToObject(JSONObject asObject)
        {
            TrackObject trackObject = new TrackObject();
            trackObject.start_time = TrackObject.GetInt(asObject, "start_time", -1);
            trackObject.end_time = TrackObject.GetInt(asObject, "end_time", -1);
            trackObject.start_intensity = TrackObject.GetInt(asObject, "start_intensity", -1);
            trackObject.interval = TrackObject.GetInt(asObject, "interval", -1);
            trackObject.end_intensity = TrackObject.GetInt(asObject, "end_intensity", -1);
            trackObject.stopName = asObject.GetValueOrDefault("stop_name", "");
            string a = asObject.GetValueOrDefault("action_type", "Shake");
            bool flag = a == "Electrical";
            if (flag)
            {
                trackObject.action_type = ActionType.Electrical;
            }
            bool flag2 = a == "Shake";
            if (flag2)
            {
                trackObject.action_type = ActionType.Shake;
            }
            string a2 = asObject.GetValueOrDefault("intensity_mode", "Const");
            bool flag3 = a2 == "Const";
            if (flag3)
            {
                trackObject.intensity_mode = IntensityMode.Const;
            }
            bool flag4 = a2 == "Fade";
            if (flag4)
            {
                trackObject.intensity_mode = IntensityMode.Fade;
            }
            bool flag5 = a2 == "FadeInAndOut";
            if (flag5)
            {
                trackObject.intensity_mode = IntensityMode.FadeInAndOut;
            }
            trackObject.once = false;
            bool flag6 = asObject.GetValueOrDefault("once", "False") == "True";
            if (flag6)
            {
                trackObject.once = true;
            }
            List<int> list = new List<int>();
            JSONNode.Enumerator enumerator = asObject["index"].GetEnumerator();
            while (enumerator.MoveNext())
            {
                List<int> list2 = list;
                KeyValuePair<string, JSONNode> keyValuePair = enumerator.Current;
                list2.Add(keyValuePair.Value);
            }
            trackObject.index = list.ToArray();
            return trackObject;
        }

        public IntensityMode intensity_mode;
    }
}