//----------------------------------------------------------------------------
//
// Copyright (c) Intel Corporation, 2011 - 2015  All Rights Reserved.
//
//  File:       AlarmClockApi.cs 
//
//  Contents:   Api code for Intel(R) Active Management Technology
//              (Intel® AMT) AlarmClock Sample.
//
//  Notes:      This sample demonstrates how to use some of the features and
//              capabilities provided by the AlarmClock service of Intel® AMT,
//              over WS-Management.
//
//----------------------------------------------------------------------------

using System;
using Intel.Management.Wsman;
using System.Globalization;
using System.Text;
using System.Xml;
using Connection;
using Common.Utils;

namespace AlarmClock
{
    #region DateTimeInterval_Class
    /// <summary>
    /// Describe the interval (days, hours and minutes - because the other arguments must be 0).
    /// </summary>
    public class DateTimeInterval
    {
        int days;
        public int Days
        {
            get { return days; }
            set
            {
                if (value < 0)
                    throw new Exception("Days must be >=0");
                days = value;
            }
        }
        int hours;
        public int Hours
        {
            get { return hours; }
            set
            {
                if (value < 0 || value > 23)
                    throw new Exception("Hours must be between 0-23");
                hours = value;
            }
        }
        int minutes;
        public int Minutes
        {
            get { return minutes; }
            set
            {
                if (value < 0 || value > 59)
                    throw new Exception("Minutes must be between 0-59");
                minutes = value;
            }
        }

        public DateTimeInterval(int days, int hours, int minutes)
        {
            Days = days;
            Hours = hours;
            Minutes = minutes;
        }
    }
    //end class DateTimeInterval

    #endregion


    public class AlarmClock_Api : Connection.Connection_setup
    {
        #region CONSTS
        public const string SAMPLE_ALARM_NAME = "SampleAlarmName";
        #endregion

        #region DATA_MEMBERS

        private static DateTime NextAMTAlarmTime = DateTime.Now.AddDays(2);

        #endregion

        #region CONSTRUCTORS
        // Inheriting Connection details from Connection_setup class.
        // Convert password to secure string to comply with wsman dll which supports passwords in SecureString
        // format only.
        public AlarmClock_Api(string ip, string username, string pwd, bool krb, MpsManager proxy, bool acceptSelfSignedCertificate = false)
            : base(ip, username, pwd.ConvertToSecureString(), krb, proxy, acceptSelfSignedCertificate)
        {
            NextAMTAlarmTime = NextAMTAlarmTime.AddSeconds(60 - NextAMTAlarmTime.Second);// the seconds must be 0.
        }

        // Convert password to secure string to comply with wsman dll which supports passwords in SecureString
        // format only.
        public AlarmClock_Api(string ip, string username, string pwd, string secure, bool krb, MpsManager proxy, bool acceptSelfSignedCertificate = false)
            : base(ip, username, pwd.ConvertToSecureString(), secure, krb, proxy, acceptSelfSignedCertificate)
        {
            NextAMTAlarmTime = NextAMTAlarmTime.AddSeconds(60 - NextAMTAlarmTime.Second);// the seconds must be 0.
        }

        #endregion CONSTRUCTORS

        #region PRIVATE_fUNCTIONS

        /// <summary>
        /// Return alarm time to turn the host computer system on
        /// Details obtained from the User... 
        /// </summary>
        /// <returns></returns>
        public DateTime getAlarmTime()
        {
            Console.WriteLine("Enter date and time to turn on the host:\n---------------------------------------");

            // Date
            Console.WriteLine("Enter date in format: MM/DD/YYYY ");
            string date = Console.ReadLine();

            // Time
            Console.WriteLine("Enter time in format: HH:MM");
            string time = Console.ReadLine();
            //time = string.Join(date,time);

            //Ensure that the second is 00 - as Intel AMT seconds must be 0.
            IFormatProvider format = new CultureInfo("en-US");
            DateTime nextAMTAlarmTime;
            bool parseResult = DateTime.TryParseExact(date + " " + time, "MM/dd/yyyy HH:mm", format, DateTimeStyles.None, out nextAMTAlarmTime);

            if (!parseResult)
                throw new FormatException(" Unable to convert " + date + " " + time + " to a date and time.");

            Console.WriteLine("Entered Date time is as follows:{0}", nextAMTAlarmTime.ToString("s", CultureInfo.CreateSpecificCulture("en-US")));

            /*
             *  s Format Specifier      en-US Culture                      2008-10-01T17:04:32
             *  u Format Specifier      en-US Culture                     2008-10-01 17:04:32Z
             *  o Format Specifier      en-US Culture              2008-10-01T17:04:32.0000000
             *  d Format Specifier      en-US Culture                                10/1/2008
             *  D Format Specifier      en-US Culture              Wednesday, October 01, 2008
             *  f Format Specifier      en-US Culture      Wednesday, October 01, 2008 5:04 PM
             *  g Format Specifier      en-US Culture                        10/1/2008 5:04 PM
             *  m Format Specifier      en-US Culture                               October 01
             * */
            Console.ReadLine();
            return nextAMTAlarmTime;
        }

        /// <summary>
        /// Return the alarm time interval (How often the wake on happened).
        /// </summary>
        public DateTimeInterval getIntervalTime()
        {
            bool parseResult = true;
            DateTimeInterval dt = null;

            // Just days can be set for interval, 
            // for example: to set the alarm clock interval for 3 monthes set the days to - 90
            Console.WriteLine("Enter schedule interval to wake-on:\n-----------------------------------");
            Console.WriteLine("Enter required interval for: days, hours, minutes");
            Console.WriteLine("Example: 1,1,7 = interval of 1 day 1 hour and 7 minutes.\n");

            do
            {
                try
                {
                    // Get interval arguments.
                    string date = Console.ReadLine();
                    string[] str = date.Split(',');

                    if (str.Length != 3)
                        throw new Exception("Input string was not in a correct format.");
                    dt = new DateTimeInterval(Convert.ToInt32(str[0]),
                                              Convert.ToInt32(str[1]),
                                              Convert.ToInt32(str[2]));
                    parseResult = true;
                }
                catch (Exception e)
                {
                    if (e.Message != null)
                        Console.WriteLine(e.Message + " Try again!");
                    else
                        Console.WriteLine("Error in interval. Try again!");
                    parseResult = false;
                }
            }
            while (!parseResult);

            Console.WriteLine("Date time interval as entered by user is :{0}", dt);
            return dt;
        }

        /// <summary>
        /// Build AlarmTemplate object as the FW expects to receive it.
        /// </summary>
        /// <param name="StartTime">The time to be set</param>
        /// <param name="Interval">The interval</param>
        /// <param name="TimeZoneInfo">Time Zone</param>
        /// <param name="AlarmName">Alarm Name</param>
        /// <returns>StringBuilder, represents the AlarmTemplate property.</returns>
        private StringBuilder BuildAlarmTemplate(string StartTime, TimeSpan Interval, string AlarmName)
        {
            StringBuilder builder = new StringBuilder();

            // Create AlarmTemplate XML format.
            builder.Append("<d:AlarmTemplate");
            builder.Append(" xmlns:d=\"http://intel.com/wbem/wscim/1/amt-schema/1/AMT_AlarmClockService\"");
            builder.Append(" xmlns:s=\"http://intel.com/wbem/wscim/1/ips-schema/1/IPS_AlarmClockOccurrence\">");

            // Set properties to AlarmClock by the alarmClock instance properties:

            // Create InstanceID string by XmlElement type, to escape special characters: '&', ''', '"', '>'.
            XmlDocument doc = new XmlDocument();
            XmlElement element = doc.CreateElement("aaaa");
            element.InnerText = AlarmName;
            builder.Append("<s:InstanceID>" + element.InnerXml + "</s:InstanceID>");

            // Create DateTime object to set StartTime property.
            IManagedInstance dateTime = wsmanClient.NewInstance("Datetime");
            dateTime.Text = StartTime;
            builder.Append("<s:StartTime>");
            builder.Append(dateTime.Xml);
            builder.Append("</s:StartTime>");

            // If specified interval, create Interval object to set Interval property. 
            if (Interval.TotalMilliseconds != 0)
                if (Interval != null)
                {
                    IManagedInstance interval = wsmanClient.NewInstance("Interval");
                    interval.Text = "P" + Interval.Days + "DT" + Interval.Hours + "H" + Interval.Minutes + "M";
                    builder.Append("<s:Interval>");
                    builder.Append(interval.Xml);
                    builder.Append("</s:Interval>");
                }

            builder.Append("<s:DeleteOnCompletion>");
            builder.Append("true");
            builder.Append("</s:DeleteOnCompletion>");

            builder.Append("</d:AlarmTemplate>");

            return builder;

        }

        /// <summary>
        /// Displays the internal time of the Intel AMT.
        /// </summary>
        private void DisplayInternalAMTTime()
        {
            Console.WriteLine("-------- Intel(R) AMT TIME SYNC FUNC CALL --------");

            IManagedReference amtsyncRef = wsmanClient.NewReference("SELECT * FROM AMT_TimeSynchronizationService WHERE Name='Intel(r) AMT Time Synchronization Service'");
            IManagedInstance amtsyncInstance = amtsyncRef.Get();

            IManagedInstance timeSync = amtsyncRef.CreateMethodInput("GetLowAccuracyTimeSynch");
            IManagedInstance outputobject = amtsyncRef.InvokeMethod(timeSync);

            IWsmanItem returnvalue = outputobject.GetProperty("ReturnValue");
            if (returnvalue.ToString().CompareTo("0") == 0)
            {
                IWsmanItem ta0 = outputobject.GetProperty("Ta0");
                Console.WriteLine(" Internal Intel(R) AMT Time is: {0}", ta0.ToString());
                DateTime dt = DateTime.Now;
                string t = dt.ToString("T");
                Console.WriteLine(t);
            }
        }

        /// <summary>
        /// Run API Test.
        /// Intel AMT versions earlier than 8.0.
        /// </summary>    
        private void RunAPITestEarlierVersions()
        {
            IManagedReference alarmClockServiceRef = wsmanClient.NewReference("SELECT * FROM AMT_AlarmClockService WHERE Name='Intel(r) AMT Alarm Clock Service'");
            IManagedInstance alarmClockServiceInstance = alarmClockServiceRef.Get();

            //Keep the current values of the alarm clock.
            IManagedInstance nextAlarmTime = wsmanClient.NewInstance("Datetime");
            IManagedInstance amtAlarmClockInterval = wsmanClient.NewInstance("Datetime");

            if (alarmClockServiceInstance.GetProperty("NextAMTAlarmTime").IsNull.Equals(false))
            {
                nextAlarmTime.Text = alarmClockServiceInstance.GetProperty("NextAMTAlarmTime").ToString();
            }

            if (alarmClockServiceInstance.GetProperty("AMTAlarmClockInterval").IsNull.Equals(false))
            {
                amtAlarmClockInterval.Text = alarmClockServiceInstance.GetProperty("AMTAlarmClockInterval").ToString();
            }

            //Execute a single wake on.
            SingleWakeOn(NextAMTAlarmTime);

            //Dispay the wake on information.
            WakeOnInfo();

            //Disable the alarm clock.
            DisableWakeOn();

            //Return the system to its previous state.
            Console.WriteLine(" Return the Alarm Clock to its Previous State... ");
            if (nextAlarmTime.Text.Equals(null))// != null)
            {
                alarmClockServiceInstance.SetProperty("NextAMTAlarmTime", nextAlarmTime);
            }

            if (amtAlarmClockInterval.Text.Equals(null))// != null)
            {
                alarmClockServiceInstance.SetProperty("AMTAlarmClockInterval", amtAlarmClockInterval);
            }

            alarmClockServiceRef.Put(alarmClockServiceInstance);

            Console.ForegroundColor = ConsoleColor.Green;
            Console.WriteLine("Success");
            Console.ForegroundColor = ConsoleColor.Gray;

            DisplayInternalAMTTime();
        }

        /// <summary>
        /// Run API Test.
        /// Intel AMT versions 8.0 and later.
        /// </summary>    
        private void RunAPITestLaterVersions()
        {
            //Execute a single wake on.
            SingleWakeOnLaterVersions(NextAMTAlarmTime);

            //Dispay the wake on information.
            WakeOnInfoLaterVersions();

            //Disable the alarm clock.
            DeleteAlarmLaterVersions(SAMPLE_ALARM_NAME);


            Console.ForegroundColor = ConsoleColor.Green;
            Console.WriteLine("Success");
            Console.ForegroundColor = ConsoleColor.Gray;

            DisplayInternalAMTTime();
        }

        /// <summary>
        /// Display settings of all alarms.
        /// Intel AMT versions earlier than 8.0.
        /// </summary>
        private void WakeOnInfoEarlierVersions()
        {
            IManagedReference alarmClockServiceRef = wsmanClient.NewReference("SELECT * FROM AMT_AlarmClockService WHERE Name='Intel(r) AMT Alarm Clock Service'");
            IManagedInstance alarmClockServiceInstance = alarmClockServiceRef.Get();

            IWsmanItem nextAMTAlarmTime = alarmClockServiceInstance.GetProperty("NextAMTAlarmTime");

            //Check if the received object contains values for the fields NextAMTAlarmTime and AMTAlarmClockInterval 
            //else Alarmclock is already disabled... 
            if (nextAMTAlarmTime.IsNull.Equals(true))
            {
                Console.WriteLine("Alaram Clock is already disabled");
                return;
            }

            else //if(nextAlaramClockTime.Object.Text !=null)
            {
                IWsmanItem amtAlarmClockInterval = alarmClockServiceInstance.GetProperty("AMTAlarmClockInterval");

                //Return time to the En-US format.
                nextAMTAlarmTime.Object.Text = nextAMTAlarmTime.Object.Text.Replace("Z", " ");
                DateTime dt = DateTime.Parse(nextAMTAlarmTime.Object.Text, new CultureInfo("en-US", true));

                Console.WriteLine("The alarm clock will be activated at: {0} \n", dt);// nextAMTAlarmTime.Object.Text);

                //Display details fo the AlarmClock Interval - if periodic wake on has been set.
                if (amtAlarmClockInterval.IsNull.Equals(false))
                {
                    Console.WriteLine("The Alarm Clock will also be activated in subsequent intervals of :\n");
                    Console.WriteLine(" current clock time set is:{0}", amtAlarmClockInterval.Object.Text);
                    //display intervals of days,hrs,mins...

                }
            }
        }

        /// <summary>
        /// Display settings of all alarms.
        /// Intel AMT versions 8.0 and later.
        /// </summary>
        private void WakeOnInfoLaterVersions()
        {
            try
            {
                IWsmanEnumeration AMTAlarmClocks = wsmanClient.NewReference("IPS_AlarmClockOccurrence").Enumerate(null, null);
                foreach (IWsmanItem AMTAlarmClock in AMTAlarmClocks)
                {
                    Console.WriteLine("\nAlarm Clock Name:            {0}", AMTAlarmClock.Object.GetProperty("InstanceID"));
                    Console.WriteLine("Alarm Clock Start Time:      {0}", AMTAlarmClock.Object.GetProperty("StartTime").Object.Text);
                    if (AMTAlarmClock.Object.GetProperty("Interval").IsNull == false)
                    {
                        Console.WriteLine("Alarm Clock Interval:        {0}", AMTAlarmClock.Object.GetProperty("Interval").Object.Text);
                    }
                    Console.WriteLine("Alarm Clock Delete Option:   {0}", AMTAlarmClock.Object.GetProperty("DeleteOnCompletion").ToString() == "true" ? "Auto Delete On Completion" : "Manual Delete");
                }
            }
            catch (Exception e)
            {
                throw new Exception("Failed to get all alarms. " + e.Message);
            }

        }

        /// <summary>
        /// Disables the alarm clock.
        /// Intel AMT versions earlier than 8.0.
        /// </summary>
        private void DisableWakeOnEarlierVersions()
        {
            IManagedReference alarmClockServiceRef = wsmanClient.NewReference("SELECT * FROM AMT_AlarmClockService WHERE Name='Intel(r) AMT Alarm Clock Service'");
            IManagedInstance alarmClockServiceInstance = alarmClockServiceRef.Get();
            IWsmanItem nextAlaramClockTime = alarmClockServiceInstance.GetProperty("NextAMTAlarmTime");
            IWsmanItem nextAlarmClockInterval = alarmClockServiceInstance.GetProperty("AMTAlarmClockInterval");

            //Check if the received object contains values for the fields NextAMTAlarmTime and AMTAlarmClockInterval 
            //else Alarmclock is already disabled... 
            if (nextAlaramClockTime.IsNull.Equals(true))
            {
                Console.WriteLine("Alaram Clock is already disabled");
                return;
            }

            alarmClockServiceInstance.RemoveProperty("NextAMTAlarmTime");

            if (nextAlarmClockInterval.IsNull.Equals(false))
            {
                alarmClockServiceInstance.RemoveProperty("AMTAlarmClockInterval");
            }

            //Update object using the Put functionality.
            alarmClockServiceRef.Put(alarmClockServiceInstance);

            Console.WriteLine("The Alarm Clock has now been disabled. \n");
        }

        /// <summary>
        /// Deletes an alarm clock.
        /// Intel AMT versions 8.0 and later.
        /// </summary>
        /// <param name="alarmName">The alarm to delete</param>
        private void DeleteAlarmLaterVersions(string alarmName)
        {
            IManagedReference alarmClockOccurrenceRef = wsmanClient.NewReference(string.Format("SELECT * FROM IPS_AlarmClockOccurrence WHERE InstanceID='{0}'", alarmName));
            if (alarmClockOccurrenceRef.Enumerate("http://schemas.dmtf.org/wbem/wsman/1/wsman/SelectorFilter", null).HasNext == true)
            {
                try
                {
                    alarmClockOccurrenceRef.Delete();
                }
                catch (Exception e)
                {
                    throw new Exception(e.Message);
                }
            }
        }

        /// <summary>
        /// Configure a periodic wake on.
        /// Intel AMT versions earlier than 8.0.
        /// </summary>
        private void PeriodicWakeOnEarlierVersions(DateTime nextAMTAlarmTime, DateTimeInterval AlarmClockInterval)
        {
            string NewAlarmTime = String.Concat(nextAMTAlarmTime.ToString("s", CultureInfo.CreateSpecificCulture("en-US")), "Z");
            Console.WriteLine("Intel AMT Format: {0}", NewAlarmTime);

            //Setting the DateTime to the user specified date and time...
            IManagedInstance nextAlarmTime = wsmanClient.NewInstance("Datetime");
            nextAlarmTime.Text = NewAlarmTime;

            //Set the Intel AMT AlarmClock Interval.
            //The AMTAlarmClockInterval format is PdDThHmM:
            //To define a one-day interval: “P1D”
            //To define an interval of three hours,15 mins: “PT3H15M”

            //Need to convert user input format to Intel AMT format.
            IManagedInstance amtAlarmClockInterval = wsmanClient.NewInstance("Interval");
            //    amtAlarmClockInterval.Text = "P1DT5H15M";
            amtAlarmClockInterval.Text = "P" + AlarmClockInterval.Days + "DT" + AlarmClockInterval.Hours + "H" + AlarmClockInterval.Minutes + "M";

            //Create Service reference to AMT_AlarmClockService
            IManagedReference alarmClockServiceRef = wsmanClient.NewReference("SELECT * FROM AMT_AlarmClockService WHERE Name='Intel(r) AMT Alarm Clock Service'");
            IManagedInstance alarmClockServiceInstance = alarmClockServiceRef.Get();

            //Set values
            alarmClockServiceInstance.SetProperty("NextAMTAlarmTime", nextAlarmTime);
            alarmClockServiceInstance.SetProperty("AMTAlarmClockInterval", amtAlarmClockInterval);

            //Set values by sending AMT_AlarmClockService.Put()
            alarmClockServiceRef.Put(alarmClockServiceInstance);

            Console.WriteLine("The alarm clock will activate periodically.\n");
        }

        /// <summary>
        /// Configure a periodic wake on.
        /// Intel AMT versions 8.0 and later.
        /// </summary>
        public void PeriodicWakeOnLaterVersions(DateTime nextAMTAlarmTime, DateTimeInterval AlarmClockInterval)
        {
            //To check the format of the string - "yy-mm-ddThh:mm:00Z"
            string newAlarmTime = String.Concat(nextAMTAlarmTime.ToString("s", CultureInfo.CreateSpecificCulture("en-US")), "Z");
            Console.WriteLine("Intel(R) AMT Format: {0}", newAlarmTime);

            IManagedReference AlarmClockServiceRef = wsmanClient.NewReference("SELECT * FROM AMT_AlarmClockService WHERE Name='Intel(r) AMT Alarm Clock Service'");
            IManagedInstance addAlarmInput = AlarmClockServiceRef.CreateMethodInput("AddAlarm");

            // Set AlarmTemplate property with all definitions of the alarm.
            // The alarm name must not exist already in the Intel AMT.
            IManagedInstance templateObj = wsmanClient.NewInstance(BuildAlarmTemplate(newAlarmTime, new TimeSpan(AlarmClockInterval.Days, AlarmClockInterval.Hours, AlarmClockInterval.Minutes, 0), SAMPLE_ALARM_NAME).ToString());
            addAlarmInput.SetProperty(null, templateObj);
            IManagedInstance returnValue;
            try
            {
                returnValue = AlarmClockServiceRef.InvokeMethod(addAlarmInput);
            }
            catch (Exception e)
            {
                throw new Exception("Failed to create alarm. Ensure all AlarmClock properties are valid.");
            }
            if (returnValue.GetProperty("ReturnValue").ToString() != "0")
            {
                uint PT_STATUS;
                if (uint.TryParse(returnValue.GetProperty("ReturnValue").ToString(), out PT_STATUS))
                {
                    throw new Exception("Failed to create alarm. Return Value = " + returnValue);
                }
            }

            Console.WriteLine("The alarm clock will activate periodically.\n");

        }

        /// <summary>
        /// Configure a single wake on.
        /// Intel AMT versions earlier than 8.0.
        /// </summary>
        private void SingleWakeOnEarlierVersions(DateTime nextAMTAlarmTime)
        {
            //To check the format of the string - "yy-mm-ddThh:mm:00Z"
            string NewAlarmTime = String.Concat(nextAMTAlarmTime.ToString("s", CultureInfo.CreateSpecificCulture("en-US")), "Z");
            Console.WriteLine("Intel AMT Format: {0}", NewAlarmTime);

            IManagedInstance nextAlarmTime = wsmanClient.NewInstance("Datetime");
            nextAlarmTime.Text = NewAlarmTime;

            IManagedReference alarmClockServiceRef = wsmanClient.NewReference("SELECT * FROM AMT_AlarmClockService WHERE Name='Intel(r) AMT Alarm Clock Service'");
            IManagedInstance alarmClockServiceInstance = alarmClockServiceRef.Get();

            //Set property nextAMTAlarmTime.
            alarmClockServiceInstance.SetProperty("NextAMTAlarmTime", nextAlarmTime);
            alarmClockServiceInstance.SetProperty("AMTAlarmClockInterval", null);


            alarmClockServiceRef.Put(alarmClockServiceInstance);

            Console.WriteLine("The Alarm Clock will be activated just once. \n");
        }

        /// <summary>
        /// Configure a single wake on.
        /// Intel AMT versions 8.0 and later.
        /// </summary>
        private void SingleWakeOnLaterVersions(DateTime nextAMTAlarmTime)
        {
            //To check the format of the string - "yy-mm-ddThh:mm:00Z"

            string newAlarmTime = String.Concat(nextAMTAlarmTime.ToString("s"), "Z");
            Console.WriteLine("AMT Format: {0}", newAlarmTime);

            IManagedReference AlarmClockServiceRef = wsmanClient.NewReference("SELECT * FROM AMT_AlarmClockService WHERE Name='Intel(r) AMT Alarm Clock Service'");
            IManagedInstance addAlarmInput = AlarmClockServiceRef.CreateMethodInput("AddAlarm");

            // Set AlarmTemplate property with all the definitions of the alarm.
            // The alarm name must not exist already in the Intel AMT.
            IManagedInstance templateObj = wsmanClient.NewInstance(BuildAlarmTemplate(newAlarmTime, new TimeSpan(0), SAMPLE_ALARM_NAME).ToString());
            addAlarmInput.SetProperty(null, templateObj);
            IManagedInstance returnValue;
            try
            {
                returnValue = AlarmClockServiceRef.InvokeMethod(addAlarmInput);
            }
            catch (Exception e)
            {
                throw new Exception("Failed to create alarm. Ensure all AlarmClock properties are valid. ");
            }
            if (returnValue.GetProperty("ReturnValue").ToString() != "0")
            {
                uint PT_STATUS;
                if (uint.TryParse(returnValue.GetProperty("ReturnValue").ToString(), out PT_STATUS))
                {
                    throw new Exception("Failed to create alarm. Return Value = " + returnValue);
                }
            }

            Console.WriteLine("The New Alarm Clock will be activated just once. \n");

        }

        #endregion

        #region PUBLIC_FUNCTIONS

        /// <summary>
        /// Configure a single wake on.
        /// </summary>
        public void SingleWakeOn(DateTime nextAMTAlarmTime)
        {
            if (UtilitiesMethods.CompareVersions(UtilitiesMethods.GetCoreVersion(wsmanClient), "8.0") < 0)
            {
                SingleWakeOnEarlierVersions(nextAMTAlarmTime);
            }
            else
            {
                SingleWakeOnLaterVersions(nextAMTAlarmTime);
            }
        }

        /// <summary>
        /// Configure a periodic wake on.
        /// </summary>
        public void PeriodicWakeOn(DateTime nextAMTAlarmTime, DateTimeInterval AlarmClockInterval)
        {
            if (UtilitiesMethods.CompareVersions(UtilitiesMethods.GetCoreVersion(wsmanClient), "8.0") < 0)
            {
                PeriodicWakeOnEarlierVersions(nextAMTAlarmTime, AlarmClockInterval);
            }
            else
            {
                PeriodicWakeOnLaterVersions(nextAMTAlarmTime, AlarmClockInterval);
            }
        }

        /// <summary>
        /// Disables or deletes an alarm clock.
        /// </summary>
        public void DisableWakeOn()
        {
            if (UtilitiesMethods.CompareVersions(UtilitiesMethods.GetCoreVersion(wsmanClient), "8.0") < 0)
            {
                DisableWakeOnEarlierVersions();
            }
            else
            {
                DeleteAlarmLaterVersions(SAMPLE_ALARM_NAME);
            }
        }

        /// <summary>
        /// Display the alarm clock settings.
        /// </summary>
        public void WakeOnInfo()
        {
            if (UtilitiesMethods.CompareVersions(UtilitiesMethods.GetCoreVersion(wsmanClient), "8.0") < 0)
            {
                WakeOnInfoEarlierVersions();
            }
            else
            {
                WakeOnInfoLaterVersions();
            }
        }

        /// <summary>
        /// Run API Test.
        /// </summary>    
        public void RunAPITest()
        {
            if (UtilitiesMethods.CompareVersions(UtilitiesMethods.GetCoreVersion(wsmanClient), "8.0") < 0)
            {
                RunAPITestEarlierVersions();
            }
            else
            {
                RunAPITestLaterVersions();
            }
        }

        #endregion PUBLIC_FUNCTIONS
    }
}