/*######################################
# Duck SecurityThread - Version 1     #
# Not for release and renaming         #
# Breakz0ne did coded this, none else  #
########################################*/

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Threading;

namespace DuckEmulator.Security
{
    /// <summary>
    /// Status where the Task is on.
    /// </summary>
    enum ThreadState
    {
        Null = 0,
        Filled = 1,
        Running = 2,
        Waiting = 3,
        Disposed = 4
    }

    class SecurityThread
    {
        protected Task fTask;
        protected ThreadState fState = ThreadState.Null;

        /// <summary>
        /// State of Task
        /// </summary>
        internal Boolean Alive
        {
            get { return (fTask != null); }
        }

        /// <summary>
        /// Needs for collecting
        /// </summary>
        /// <returns>Generation</returns>
        private int Serialize()
        {
            return GC.GetGeneration(fTask);
        }

        /// <summary>
        /// 3 Types of creating an Thread
        /// </summary>
        internal SecurityThread()
        {
            fTask = null;
        }

        internal SecurityThread(Action A)
        {
            Parse(A, TaskCreationOptions.None);
        }

        internal SecurityThread(Action A, TaskCreationOptions e)
        {
            Parse(A, e);
        }

        /// <summary>
        /// Initializes the Task
        /// </summary>
        /// <param name="Action">delegate() void</param>
        /// <param name="Opt">Addiontionals</param>
        internal void Parse(Action Action, TaskCreationOptions Opt)
        {
            fState = ThreadState.Filled;
            fTask = new Task(Action, CancellationToken.None, Opt);
        }

        /// <summary>
        /// Starts / releases the void();
        /// </summary>
        internal void Release()
        {
            if (GetState() == ThreadState.Disposed)
            {
                return;
            }

            if (GetTask().Status == TaskStatus.Running)
            {
                Synchronize();
                return;
            }

            try
            {
                GetTask().Start();
            }
            catch ( Exception e )
            {
                throw new SecurityException("SecurityTask could not be started. Errorcode: " + e.Message);
            }
        }

        /// <summary>
        /// Run it smoothly
        /// </summary>
        internal void Synchronize()
        {
            if (!Alive)
            {
                return;
            }

            GetTask().RunSynchronously(TaskScheduler.FromCurrentSynchronizationContext());
        }

        /// <summary>
        /// Let them wait for * sec
        /// </summary>
        /// <param name="Sec">Seconds for waiting</param>
        internal void Sleep(int Milisec)
        {
            if (!Alive)
            {
                return;
            }

            if (Milisec < 0)
            {
                Milisec = 10;
            }

            fState = ThreadState.Waiting;

            GetTask().Wait(Milisec, CancellationToken.None);

            fState = ThreadState.Running;
        }

        internal void WaitForDispose()
        {
            if (!Alive)
            {
                return;
            }

            fState = ThreadState.Waiting;

            GetTask().Wait(CancellationToken.None);

            Dispose();
        }

        /// <summary>
        /// Let it keep alive
        /// </summary>
        internal void KeepAlive()
        {
            GC.KeepAlive(GetTask());
        }

        /// <summary>
        /// Optimize
        /// </summary>
        internal void Optimize()
        {
            GC.Collect(Serialize(), GCCollectionMode.Optimized);
        }

        /// <summary>
        /// Restore to defaults
        /// </summary>
        internal void Restore()
        {
            GC.Collect(Serialize(), GCCollectionMode.Default);
        }

        /// <summary>
        /// Forces the collection
        /// </summary>
        internal void Force()
        {
            GC.Collect(Serialize(), GCCollectionMode.Forced);
        }

        /// <summary>
        /// Requests system for final end;
        /// </summary>
        internal void Finialize()
        {
            if (!Alive)
            {
                return;
            }

            GC.SuppressFinalize(GetTask());
        }

        /// <summary>
        /// Returns the Main-Task where this is runnin' on.
        /// </summary>
        /// <returns></returns>
        internal Task GetTask()
        {
            return this.fTask;
        }

        /// <summary>
        /// Returns the State of the Task
        /// </summary>
        /// <returns></returns>
        internal ThreadState GetState()
        {
            return this.fState;
        }

        /// <summary>
        /// Dispose main Task
        /// </summary>
        internal void Dispose()
        {
            fTask = null;
            fState = ThreadState.Disposed;
        }
    }
}