CSPspEmu.Hle.HleThread.SetWaitAndPrepareWakeUp C# (CSharp) Method

        public void SetWaitAndPrepareWakeUp(WaitType WaitType, String WaitDescription, object WaitObject, Action<Action> PrepareCallback, bool HandleCallbacks = false)
        {
            if (this.HasAllStatus(Status.Waiting))
            {
                Console.Error.WriteLine("Trying to sleep an already sleeping thread!");
            }

            bool CalledAlready = false;
            YieldCount++;
            SetWait0(WaitType, WaitDescription, WaitObject, HandleCallbacks);
            {
                //PrepareCallback(WakeUp);
                PrepareCallback(() =>
                {
                    if (!CalledAlready)
                    {
                        CalledAlready = true;
                        ReleaseWaitThread();
                    }
                });
            }
            SetWait1();
        }

        public void ChangeWakeUpCount(int Increment, HleThread WakeupThread, bool HandleCallbacks = false)
        {
            var PreviousWakeupCount = Info.WakeupCount;

            Info.WakeupCount += Increment;
            var CurrentWakeupCount = Info.WakeupCount;

            /*
             * Console.Error.WriteLine(
             *      "{0} : ChangeWakeUpCount : {1} -> {2}",
             *      this, PreviousWakeupCount, CurrentWakeupCount
             * );
             */

            var ThreadToSleep = this;

            // Sleep if sleeping decrement.
            if (Increment < 0 && CurrentWakeupCount < 0)
            {
                ThreadToSleep.SetWaitAndPrepareWakeUp(HleThread.WaitType.None, "sceKernelSleepThread", WakeUpCallback =>
                {
                    ThreadToSleep.WakeUpCallback = () =>
                    {
                        WakeUpCallback();
                        WakeUpCallback = null;
                    };
                }, HandleCallbacks: HandleCallbacks);
            }
            // Awake
            else if (Increment > 0 && PreviousWakeupCount < 0 && CurrentWakeupCount >= 0)
            {
                Action[] WakeUpListCopy;
                lock (WakeUpList)
                {
                    WakeUpListCopy = WakeUpList.ToArray();
                    WakeUpList.Clear();
                }

                if (WakeUpCallback != null)
                {
                    WakeUpCallback();
                }
                else
                {
                    Console.Error.WriteLine("Unexpected!");
                }

                foreach (var WakeUp in WakeUpListCopy)
                {
                    WakeUp();
                }
            }

            if (Increment > 0)
            {
                //return;
                Console.Error.WriteLine("Increment > 0 - Wakeup");

                WakeupThread.SetWaitAndPrepareWakeUp(WaitType.None, "sceKernelWakeupThread", WakeUpCallback =>
                {
                    lock (WakeUpList)
                    {
                        WakeUpList.Add(() =>
                        {
                            WakeUpCallback();
                        });
                    }
                }, HandleCallbacks: HandleCallbacks);
                //WakeUpList.Add
            }
        }