public void EventReceivedHandler(object sender, EventInfo eventInfo)
        {
            if (eventInfo.Type == EventInfo.EventTypes.TAG_REPORT)
            {
                var tagid = eventInfo.GetParameter(EventInfo.EventTagReportParams.TagId);
                var antenna = eventInfo.GetParameter(EventInfo.EventTagReportParams.Antenna);
                var time = eventInfo.GetParameter(EventInfo.EventTagReportParams.Time);
                var phase = eventInfo.GetParameter(EventInfo.EventTagReportParams.Phase);
                var frequency = eventInfo.GetParameter(EventInfo.EventTagReportParams.Frequency);
                var rssi = eventInfo.GetParameter(EventInfo.EventTagReportParams.Rssi);

                var phaseAngle = _phaseUtils.PhaseAngle(phase);

                if (tagid != null)
                {
                    var reading = new Reading
                    {
                        TagId = tagid,
                        Antenna = antenna,
                        PhaseAngle = phaseAngle,
                        Frequency = frequency,
                        Rssi = rssi,
                        Time = time
                    };

                    //Console.WriteLine(reading);
                    Readings.Add(reading);
                }
            }
        }

        protected override IEnumerator<object> OnPreferencesChanged(EventInfo evt, string[] prefNames)
        {
            string prefsJson = null;
            yield return Preferences.GetAllJson().Bind(() => prefsJson);

            yield return CallFunction("weaponhelper", "notifyPrefsChanged", prefsJson);
        }

		public override EventInfo[] __GetDeclaredEvents()
		{
			int token = this.MetadataToken;
			// TODO use binary search?
			for (int i = 0; i < module.EventMap.records.Length; i++)
			{
				if (module.EventMap.records[i].Parent == token)
				{
					int evt = module.EventMap.records[i].EventList - 1;
					int end = module.EventMap.records.Length > i + 1 ? module.EventMap.records[i + 1].EventList - 1 : module.Event.records.Length;
					EventInfo[] events = new EventInfo[end - evt];
					if (module.EventPtr.RowCount == 0)
					{
						for (int j = 0; evt < end; evt++, j++)
						{
							events[j] = new EventInfoImpl(module, this, evt);
						}
					}
					else
					{
						for (int j = 0; evt < end; evt++, j++)
						{
							events[j] = new EventInfoImpl(module, this, module.EventPtr.records[evt] - 1);
						}
					}
					return events;
				}
			}
			return Empty<EventInfo>.Array;
		}

    void ColorChanged(EventInfo eventInfo)
    {
        ColorEventInfo info = (ColorEventInfo)eventInfo;
        currentColor = info.newColor;

        SetCurrentMaterials();
    }

    private void BroadcastStateChange(EventInfo eventInfo)
    {
        Debug.Log ("Broadcasting state change.");

        foreach (ScreenController screenController in screenControllers) {
            screenController.MatchStateChanged (eventInfo);
        }
    }

        protected override IEnumerator<object> OnPreferencesChanged(EventInfo evt, string[] prefNames)
        {
            long fontScale = 100, fontWidth = 100;
            yield return Preferences.Get<long>("FontScale").Bind(() => fontScale);
            yield return Preferences.Get<long>("FontWidth").Bind(() => fontWidth);

            yield return CallFunction("fontsizer", "setFontSize", fontScale / 100.0f, fontWidth / 100.0f);
        }

    public void PlayerDied(EventInfo eventInfo)
    {
        PlayerController playerController = ((PlayerSpawnedEventInfo)eventInfo).player;

        switch (playerController.Id)
        {
            case 1: target1 = null; break;
            case 2: target2 = null; break;
        }
    }

 //Test function
 void ColorChanged(EventInfo eventInfo)
 {
     switch (((ColorEventInfo)eventInfo).newColor)
     {
         case ChromaColor.RED: RenderSettings.skybox.SetColor("_Tint", Color.red); break;
         case ChromaColor.GREEN: RenderSettings.skybox.SetColor("_Tint", Color.green); break;
         case ChromaColor.BLUE: RenderSettings.skybox.SetColor("_Tint", Color.blue); break;
         case ChromaColor.YELLOW: RenderSettings.skybox.SetColor("_Tint", Color.yellow); break;
     }
     
 }

        // ReSharper disable InconsistentNaming
        public void TaskSheduler_ResourceHistory_ShouldConstructCorrectly()
        // ReSharper restore InconsistentNaming
        {
            var a = new List<IDebugState>();
            var b = new EventInfo(new DateTime(2001, 01, 01), new TimeSpan(1, 0, 0), new DateTime(2001, 01, 01), ScheduleRunStatus.Error, "sdf");
            var res = new ResourceHistory("output", a, b, "bob");
            Assert.AreEqual(a, res.DebugOutput);
            Assert.AreEqual(b, res.TaskHistoryOutput);
            Assert.AreEqual("bob", res.UserName);

        }

            /// <summary>
            /// Creates an event handler for the specified event
            /// </summary>
            /// <param Name="Info">The event info class of the event</param>
            /// <returns>The created event handler help class.</returns>
            public object GetEventHandler(EventInfo Info)
            {
                Type eventHandlerType = emitter.GetEventHandlerType(Info);

                // Call constructor of event handler type to create event handler
                ConstructorInfo myCtor = eventHandlerType.GetConstructor(new Type[] { typeof(EventInfo) });
                object[] ctorArgs = new object[] { Info };
                object eventHandler = myCtor.Invoke(ctorArgs);

                return eventHandler;
            }

 /// <summary>
 /// Emits dynamically a event handler with a given signature, which fills all arguments of the event in an object array 
 /// and calls a common event.
 /// </summary>
 /// <returns></returns>
 public Type GetEventHandlerType(EventInfo Info)
 {
     string handlerName = assemblyName + Info.Name;
     Type tpEventHandler = (Type)handlerTypes[handlerName];
     if (tpEventHandler == null)
     {
     // Create the type
     tpEventHandler = EmitHelperClass(handlerName, Info);
     handlerTypes.Add(handlerName, tpEventHandler);
     }
     return tpEventHandler;
 }

        public void TestMethod1()
        {
            EventInfo eventinfo = new EventInfo();
            eventinfo.Name = "1";
            eventinfo.Root = "helo";
            eventinfo.Description = "helloo";
            eventinfo.Save();

            eventinfo = EventInfo.Load(1);

            eventinfo.DeleteOnSave();
        }

 public STElementInfo(JSONNode stJson)
 {
     string spriteName = stJson["sprite"];
     m_alwaysSeen = stJson["doShow"].AsBool;
     JSONNode color = stJson["color"];
     Color col = Color.white;
     if(color != null) {
         col = new Color(color["r"].AsFloat, color["g"].AsFloat, color["b"].AsFloat);
     }
     m_spriteName = spriteName;
     m_spriteColor = col;
     m_eventInfo = new EventInfo(stJson);
 }

 public void LoadEventInfo(MobManager mobManager, Storytrack storyTrack, EventInfo info)
 {
     ClearMobs();
     m_st = storyTrack;
     m_info = info;
     foreach(string mobName in m_info.mobs) {
         MobInfo mobInfo = mobManager.GetMobByName(mobName);
         Mob mob = CreateMob(mobInfo, transform.position);
         if(mob == null) continue;
         m_mobs.Add(mob);
     }
     MoveMobsToSpawns();
 }

 public static string ArrayToCommaList(EventInfo[] ArrayToConvert)
 {
     string returnString = "";
     if (ArrayToConvert.Length > 0)
     {
         returnString = ArrayToConvert[0].ToString();
         for (int i = 1; i < ArrayToConvert.Length; i++)
         {
             returnString += ", " + ArrayToConvert[i].ToString();
         }
     }
     return returnString;
 }

        public void TaskSheduler_EventInfo_ShouldconstructCorrectly()
        {

            EventInfo ie = new EventInfo(new DateTime(2000, 1, 1), TimeSpan.MaxValue, new DateTime(2001, 1, 1),ScheduleRunStatus.Error, 
                                         "12345");
            Assert.AreEqual(new DateTime(2000, 1, 1), ie.StartDate);
            Assert.AreEqual(new DateTime(2001, 1, 1), ie.EndDate);
            Assert.AreEqual(TimeSpan.MaxValue, ie.Duration);
            Assert.AreEqual(ScheduleRunStatus.Error, ie.Success);
            Assert.AreEqual("12345", ie.EventId);


        }

	private Delegate GetEventHandler(EventInfo ei, Type eaType, string fieldToAssign)
	{
		ParameterExpression senderParam = Expression.Parameter(typeof(object), "sender");
		ParameterExpression eventArgsParam = Expression.Parameter(eaType, "e");
		Delegate handler = Expression.Lambda(ei.EventHandlerType,
			Expression.Assign(
				Expression.Field(Expression.Constant(this), this.GetType().GetField(fieldToAssign)),
				Expression.Property(eventArgsParam, eaType.GetProperty("Value").GetGetMethod())
			),
			senderParam,
			eventArgsParam
		).Compile();
		return handler;
	}

        private void AddEventInfo_Click(object sender, RoutedEventArgs e)
        {
            EventInfo p = new EventInfo();

            if (p.ShowDialog().Value)
            {
                Event AddEvent = new Event();
                AddEvent.EventName = p.EName.Text;
                AddEvent.EventCost = Decimal.Parse(p.ECost.Text);
                AddEvent.UserID = userId;
                infoContext.Events.AddObject(AddEvent);
                saveMeToDataBase();
                fetchUserData(infoContext);
            }
        }

        public void AddEventHandler_RemoveEventHandler(EventInfo eventInfo, EI_Class target, Delegate handler, int expectedStaticVariable)
        {
            // Add and make sure we bound the event.
            eventInfo.AddEventHandler(target, handler);
            target?.InvokeAllEvents();
            EI_Class.InvokeStaticEvent();
            Assert.Equal(expectedStaticVariable, EI_Class.AddEventHandler_RemoveEventHandler_Test_TrackingVariable);
            EI_Class.AddEventHandler_RemoveEventHandler_Test_TrackingVariable = 0; // Reset

            // Remove and make sure we unbound the event.
            eventInfo.RemoveEventHandler(target, handler);
            target?.InvokeAllEvents();
            EI_Class.InvokeStaticEvent();
            Assert.Equal(0, EI_Class.AddEventHandler_RemoveEventHandler_Test_TrackingVariable);
        }

        private IEnumerable<IEventInfo> GetEventInfosBase(TimeLineVisualizationState state, int index, HierarchicalItem hierarchicalItem)
        {
            var dateRange = hierarchicalItem.SourceItem as IDateRange;
            var roundedRange = state.Rounder.Round(dateRange);
            var taskRange = new Range<long>(roundedRange.Start.Ticks, roundedRange.End.Ticks);

            if (taskRange.IntersectsWith(state.VisibleTimeRange))
            {
                var eventInfo = new EventInfo(taskRange, index, 1, new Range<int>(0), IsSummary(hierarchicalItem.SourceItem), IsMilestone(hierarchicalItem.SourceItem))
                {
                    OriginalEvent = hierarchicalItem.SourceItem
                };

                yield return eventInfo;
            }
        }