//----------------------------------------------------------------------------
//
//  Copyright (C) Intel Corporation, 2011 - 2014 All Rights Reserved.
//
//  File:       UserConsentApi.cs 
//
//  Contents:   Api code for Intel(R) Active Management Technology 
//              (Intel® AMT) User Consent.
//
//  Notes:      This sample application demonstrates various commands of user 
//              consent flow for AMT 6.1 and above FW versions.
//
//----------------------------------------------------------------------------

using System;
using Connection;
using Intel.Management.Wsman;
using System.Threading;
using System.Collections.Generic;
using Utils;
using Common.Utils;


namespace UserConsent
{
    public class UserConsentApi : Connection_setup
    {
        #region ENUMS

        /// <summary>
        /// User input flags.
        /// </summary>
        public enum YesNoFlag
        {
            YES,
            NO
        };

        /// <summary>
        /// System power states.
        /// </summary>
        public enum PowerState
        {
            Other = 1,
            On,
            LightSleep,
            DeepSleep,
            SoftPowerCycle,
            HardOff,
            Hibernate,
            SoftOff,
            HardPowerCycle,
            MasterBusReset,
            DiagnosticInterrupt
        };

        /// <summary>
        /// Indicates the state of OptIn (User Consent).
        /// </summary>
        public enum OptInState
        {
            /// <summary>
            /// OptIn is required for sessions affected by OptInPolicy.
            /// </summary>
            NotStarted,

            /// <summary>
            /// A console has required an optIn code, but it was not displayed to the user yet.
            /// </summary>
            Requested,

            /// <summary>
            /// The optIn code was displayed to the user. 
            /// </summary>
            Displayed,

            /// <summary>
            /// The optIn code was successfully entered by the IT.
            /// </summary>
            Received,

            /// <summary>
            /// Intel AMT had a KVM or Redirection open session.
            /// </summary>
            InSession
        };

        /// <summary>
        /// Indicates the user consent policy.
        /// </summary>
        public enum OptInPolicy : uint
        {
            /// <summary>
            /// The optIn is not required for any of the features.
            /// </summary>
            NONE,

            /// <summary>
            /// The optIn is required only for KVM.
            /// </summary>
            KVM,

            /// <summary>
            /// The optIn is required for all operations.
            /// </summary>
            ALL = UInt32.MaxValue
        }

        /// <summary>
        /// Default screen values.
        /// </summary>
        public enum DefaultScreen
        {
            PrimaryScreen,
            SecondaryScreen
            //to do -- will need to include Third Screen option as well..

        };

        #endregion

        #region CONSTANTS

        private const uint MAX_NUMBER_OF_TRIALS = 3;
        private const uint PT_STATUS_SUCCESS = 0;
        private const uint PT_STATUS_UNSPECIFIED_ERROR = 2;
        private const string STR_UNSPECIFIED_ERROR = "Requested operation is not allowed in Intel AMT system's current state.";

        // OptInService Functions Statuses       
        Dictionary<uint, string> StatusCodes = new Dictionary<uint, string>()
        {
            {0, "PT_STATUS_SUCCESS"},
            {1, "PT_STATUS_INTERNAL_ERROR"},
            {2, "PT_STATUS_INVALID_STATE"},
            {3, "PT_STATUS_BLOCKED"},
            {2066, "PT_STATUS_INVALID_CREDENTIALS"}
        };

        // Yes No questions
        private string ASK_FOR_SWITCH_SCREEN = "Would you like to switch monitors?";
        private string ASK_FOR_SAMPLE_REBOOT = "Would you like to reboot the system?";

        #endregion

        #region PRIVATE_DATA_MEMBERS

        public static CmdLineArguments Params = new CmdLineArguments();
        IWsmanItem returnValue;

        #endregion PRIVATE_DATA_MEMBERS

        #region CONSTRUCTORS
        // Creating the connection to the WSMan Client.
        // 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 UserConsentApi(string ip, string username, string pwd, bool krb, MpsManager proxy, bool acceptSelfSignedCertificate = false)
            : base(ip, username, pwd.ConvertToSecureString(), krb, proxy, acceptSelfSignedCertificate)
        {
        }

        // Convert password to secure string to comply with wsman dll which supports passwords in SecureString
        // format only.
        public UserConsentApi(string ip, string username, string pwd, string clientCert, bool krb, MpsManager proxy, bool acceptSelfSignedCertificate = false)
            : base(ip, username, pwd.ConvertToSecureString(), clientCert, krb, proxy, acceptSelfSignedCertificate)
        {
        }

        #endregion CONSTRUCTORS

        #region PUBLIC_FUNCTIONS

        /// <summary>
        /// Get user consent policy.
        /// </summary>
        /// <returns>The current policy</returns>
        public OptInPolicy GetUserConsentPolicy()
        {
            // Get the IPS_OptInService using the Intel AMT as a reference.
            IManagedReference optInServiceRef = wsmanClient.NewReference("SELECT * FROM IPS_OptInService WHERE Name='Intel(r) AMT OptIn Service'");
            IManagedInstance optInServiceInstance = optInServiceRef.Get();
            IWsmanItem optInRequired = optInServiceInstance.GetProperty("OptInRequired");

            OptInPolicy policy = OptInPolicy.NONE;

            // The optIn is not required for any of the features. (Property does not exist.)   
            if (optInRequired != null)//service.ContainsField("OptInRequired"))
            {
                // Indicates the OptIn (User Consent) Policy for Redirection operations,including KVM and IDER, 
                // or setting of boot options. 
                // This value is Read Only if the system was configured in Client Control Mode and Read-Write 
                // in Admin Control Mode and CanModifyOptInPolicy=true. 
                // The allowed values in Admin Control Mode are: None (opt-in not required for any of the features), 
                // KVM, or All (KVM+IDER+Boot options). Possible values in Client Control Mode: All.
                policy = (OptInPolicy)(Convert.ToUInt64(optInRequired.ToString()));
            }
            return policy;
        }

        /// <summary>
        /// Get user consent state - mainly examines OptInState.
        /// </summary>
        /// <returns>The current state</returns>
        public OptInState GetUserConsentState()
        {
            // Traversing the IPS_OptInService using the Intel AMT as a reference.
            IManagedReference optInServiceRef = wsmanClient.NewReference("SELECT * FROM IPS_OptInService WHERE Name='Intel(r) AMT OptIn Service'");
            IManagedInstance optInServiceInstance = optInServiceRef.Get();
            IWsmanItem optInState = optInServiceInstance.GetProperty("OptInState");

            // Return the optIn state as enum parameter.
            OptInState state = (OptInState)(Convert.ToUInt64(optInState.ToString()));

            return state;
        }

        /// <summary>
        /// Get the system power state.
        /// </summary>
        /// <returns>The current power state</returns>
        public PowerState GetPowerState()
        {
            // Create a reference to the CIM_ComputerSystem instance.
            IManagedReference computerSysRef = wsmanClient.NewReference("SELECT * FROM CIM_ComputerSystem WHERE  Name='ManagedSystem'");
            IManagedReference associatedPowerMgmtRef = wsmanClient.NewReference("CIM_AssociatedPowerManagementService");
            associatedPowerMgmtRef.AddSelector("UserOfService", computerSysRef);

            //Traverse to the CIM_AssociatedPowerManagementService instances that are connected to CIM_ComputerSystem instance.
            int powerState;
            foreach (IWsmanItem associatedPowerMgmtItem in associatedPowerMgmtRef.Enumerate("http://schemas.dmtf.org/wbem/wsman/1/wsman/SelectorFilter", null))
            {
                // For each instance, check if it is associated to the CIM_PowerManagementService instance.
                if (associatedPowerMgmtItem.Object.GetProperty("ServiceProvided").IsA("CIM_PowerManagementService"))
                {
                    IWsmanItem associatedPowerMgmtInstance = associatedPowerMgmtItem;
                    powerState = Convert.ToInt16(associatedPowerMgmtInstance.Object.GetProperty("PowerState").ToString());
                    return (PowerState)(powerState);
                }
            }

            return 0;
        }

        /// <summary>
        /// Getting the user consent status.
        /// </summary>
        public IManagedInstance DisplayUserConsentStatus()
        {
            Console.WriteLine("Getting User Consent Status.");

            IManagedReference optInServiceRef = wsmanClient.NewReference("SELECT * FROM IPS_OptInService WHERE Name='Intel(r) AMT OptIn Service'");
            IManagedInstance optInServiceInstance = optInServiceRef.Get();
            IWsmanItem optInRequired = optInServiceInstance.GetProperty("OptInRequired");
            IWsmanItem optInState = optInServiceInstance.GetProperty("OptInState");
            IWsmanItem optInDisplayTimeout = optInServiceInstance.GetProperty("OptInDisplayTimeout");
            IWsmanItem optInCodeTimeout = optInServiceInstance.GetProperty("OptInCodeTimeout");

            Console.WriteLine("User Consent Policy is: " + (OptInPolicy)(Convert.ToUInt64(optInRequired.ToString())));
            Console.WriteLine("User Consent State is: " + (OptInState)(Convert.ToUInt64(optInState.ToString())));
            Console.WriteLine("User Consent code Timeout is : " + optInCodeTimeout.ToString());
            Console.WriteLine("User Consent Display Timeout is : " + optInDisplayTimeout.ToString());

            return optInServiceInstance;
        }

        /// <summary>
        /// Request an optIn code. (Intel AMT generates code internally.)
        /// </summary>
        public void StartUserConsent()
        {
            Console.WriteLine("Starting User Consent Process...");

            IManagedReference optInServiceRef = wsmanClient.NewReference("SELECT * FROM IPS_OptInService WHERE Name='Intel(r) AMT OptIn Service'");
            IManagedInstance optInServiceInstance = optInServiceRef.Get();
            IWsmanItem optInState = optInServiceInstance.GetProperty("OptInState");

            if (optInState.ToString().Equals("0")) // OptInState = 0 ==> NotStarted
            {
                // Starting the user consent service.
                // Intel AMT generates a random code and displays the consent form to the user.
                IManagedInstance inputObject = optInServiceRef.CreateMethodInput("StartOptIn");
                IManagedInstance outputObject = optInServiceRef.InvokeMethod(inputObject);
                returnValue = outputObject.GetProperty("ReturnValue");

                if (Convert.ToUInt64(returnValue.ToString()) != PT_STATUS_SUCCESS)
                {
                    throw new Exception("Error occurred in StartUserConsent. Intel AMT status code: " + StatusCodes[Convert.ToUInt32(returnValue.ToString())]);
                }

                Params.MessageDisplay_Color("Success.", ConsoleColor.Green);
            }

            if (optInState.ToString().Equals("1")) // OptInState == 1 ==> Requested
            {
                Console.WriteLine("User Consent has been requested.");
            }

            if (optInState.ToString().Equals("3")) // OptInState == 3 ==> Received
            {
                Console.WriteLine("User Consent has been received.");
            }
        }

        /// <summary>
        /// Cancel a previous optIn code request.
        /// </summary>
        public void StopUserConsent()
        {
            Console.WriteLine("Canceling User Consent Process...");

            // Getting the service instance.
            IManagedReference optInServiceRef = wsmanClient.NewReference("SELECT * FROM IPS_OptInService WHERE Name='Intel(r) AMT OptIn Service'");
            IManagedInstance inputObject = optInServiceRef.CreateMethodInput("CancelOptIn");
            IManagedInstance outputObject = optInServiceRef.InvokeMethod(inputObject);
            returnValue = outputObject.GetProperty("ReturnValue");

            if (Convert.ToUInt64(returnValue.ToString()) != PT_STATUS_SUCCESS)
            {
                throw new Exception("Error occurred in StopUserConsent. Intel AMT status code: " + StatusCodes[Convert.ToUInt32(returnValue.ToString())]);
            }

            Params.MessageDisplay_Color("Success.", ConsoleColor.Green);

        }

        /// <summary>
        /// Send the consent code to Intel AMT.
        /// </summary>
        public void SendConsentCode()
        {
            // Count the number of trials to send the consent code.
            uint codeTrials = 0;

            while (codeTrials != MAX_NUMBER_OF_TRIALS)
            {
                uint optInCode;

                // Asking for user consent code to send - waiting for input.
                Console.WriteLine("Please enter user consent code:");
                string strCode = Console.ReadLine();

                // Parsing the user input to uint code (validate the input).
                uint.TryParse(strCode, out optInCode);

                if (optInCode != 0 || uint.Parse(strCode) == 0)
                {
                    // When caller exceeded the number of allowed SendConsent retries, there is no indication that the 
                    // state machine has reset. Therefore we are checking the OptInState, after each SendConsent failure, 
                    // to figure out if it can send an additional retry.

                    // Getting the service instance for getting the user consent state.
                    IManagedReference optInServiceRef = wsmanClient.NewReference("SELECT * FROM IPS_OptInService WHERE Name='Intel(r) AMT OptIn Service'");
                    IManagedInstance optInServiceInstance = optInServiceRef.Get();
                    IWsmanItem OptIn_state = optInServiceInstance.GetProperty("OptInState");

                    if (OptIn_state.ToString().Equals("2")) // OptInState = 2 ==>Displayed
                    {
                        Console.WriteLine("Sending Consent Code.. ");

                        IManagedInstance inputObject = optInServiceRef.CreateMethodInput("SendOptInCode");
                        inputObject.SetProperty("OptInCode", optInCode.ToString());
                        IManagedInstance outputObject = optInServiceRef.InvokeMethod(inputObject);
                        returnValue = outputObject.GetProperty("ReturnValue");

                        if (Convert.ToUInt64(returnValue.ToString()) != PT_STATUS_SUCCESS)
                        {
                            Params.MessageDisplay_Color("Failed to send user consent code. Try again.", ConsoleColor.Red);
                            codeTrials++;
                        }
                        else
                        {
                            Params.MessageDisplay_Color("Success.", ConsoleColor.Green);
                            break;
                        }
                    }
                }

                else
                {
                    throw new InvalidCastException("An illegal value was entered. Please provide a valid Code(six digits).");
                }
            }

            if (Convert.ToUInt64(returnValue.ToString()) != PT_STATUS_SUCCESS)
            {
                Params.MessageDisplay_Color("Maximal number of trials was reached - code is expired.", ConsoleColor.Red);
                throw new Exception("Error occurred in SendConsentCode. Intel AMT status code: " + StatusCodes[Convert.ToUInt32(returnValue.ToString())]);
            }
        }

        /// <summary>
        /// Change the default monitor.
        /// </summary>
        public void SetDefaultMonitor()
        {
            Console.WriteLine("Setting Default Monitor...");

            uint value;
            IManagedReference secIOServiceRef = wsmanClient.NewReference("SELECT * FROM IPS_SecIOService WHERE Name='SecIO'");
            IManagedInstance secIOServiceInstance = secIOServiceRef.Get();
            value = uint.Parse(secIOServiceInstance.GetProperty("DefaultScreen").ToString());

            if (value == 0)
            {
                secIOServiceInstance.SetProperty("DefaultScreen", "1");
            }
            else
            {
                // Starting with Release 8.0, Intel AMT supports up to three screens, so the value can be 0, 1, or 2.
                if (UtilitiesMethods.GetCoreVersion(wsmanClient).CompareTo("8.0.0.0") >= 0)
                {
                    if (value == 1)
                        secIOServiceInstance.SetProperty("DefaultScreen", "2");
                    if (value == 2)
                        secIOServiceInstance.SetProperty("DefaultScreen", "0");
                }
                else
                {
                    secIOServiceInstance.SetProperty("DefaultScreen", "0");
                }
            }

            secIOServiceRef.Put(secIOServiceInstance);
            Params.MessageDisplay_Color("Success.", ConsoleColor.Green);
        }

        /// <summary>
        /// Gets the current default monitor.
        /// </summary>
        public void GetDefaultMonitor()
        {
            IManagedReference secIOServiceRef = wsmanClient.NewReference("SELECT * FROM IPS_SecIOService WHERE Name='SecIO'");
            IManagedInstance secIOServiceInstance = secIOServiceRef.Get();
            Console.WriteLine("The current default monitor: " + secIOServiceInstance.GetProperty("DefaultScreen").ToString());
        }

        /// <summary>
        /// Run full user consent flow.
        /// See the attached diagram (UserConsentFlowDiagram.bmp) that depicts the flow performed by the full user consent flow option. 
        /// </summary>
        public void RunFullUserConsentFlow()
        {
            // -------------------------------------
            // STEP 1: Check the system power state.
            // -------------------------------------
            if (GetPowerState() != (PowerState.On))
            {
                // If system state is Sx - close the program.
                Params.MessageDisplay_Color("This flow does not support the current power state.", ConsoleColor.Red);
                return;
            }

            // -------------------------------------
            // STEP 2: Check the user consent state.
            // -------------------------------------
            DisplayUserConsentStatus();

            // Check the system policy:
            // Policy is "NONE" - indicates that user consent is not required.
            if (GetUserConsentPolicy() == OptInPolicy.NONE)
            {
                Params.MessageDisplay_Color("User consent is not required for any operation", ConsoleColor.Yellow);
                return;
            }

            // Get user consent state.
            OptInState state = GetUserConsentState();

            // Check the system state:          
            if (state != OptInState.NotStarted)
            {
                // The state is received - the code was entered successfully by the IT. 
                if (state == OptInState.Received)
                {
                    Params.MessageDisplay_Color("User consent was already obtained.", ConsoleColor.Yellow);
                    return;
                }
                if (state == OptInState.InSession)
                {
                    Params.MessageDisplay_Color("User Consent is not required. KVM or Redirection session is currently opened.", ConsoleColor.Yellow);
                    return;
                }
                // The state should be displayed (The code was displayed to the user), or requested (The console required an opt-in code)
                else
                {
                    string errorMessage = "Full flow cannot be executed in the current user-consent state. Resetting the state using cancel option.";

                    Params.MessageDisplay_Color(errorMessage, ConsoleColor.Yellow);

                    // Cancel the user consent (reset OptInState to "NotStarted").
                    StopUserConsent();
                }
            }

            // ------- -------------------------------
            // STEP 3: Start the user consent process.
            // ---------------------------------------
            StartUserConsent();

            // The "Requested" state is ambiguous. SW cannot determine, based on this state alone, whether it should
            // initiate a reboot to display MEBx code, or keep waiting for Intel AMT to display Sprite screen.
            // A "Requested" state indicates to SW that a reboot is required for MEBx only after 15 seconds from StartConsent()
            // The Sleep of 15 seconds (15000 milliseconds) is required since Intel AMT FW will only determine 
            // if it can use Sprite screen after a few seconds. 
            Thread.Sleep(15000);

            // ---------------------------
            // STEP 4: Display the Sprite.
            // ---------------------------
            // Intel AMT FW detects whether integrated gfx can be used for consent and prioritizes it over MEBx method.
            // If the state is not "Displayed" - indicates that Discrete gfx are present in the platform
            // and displays the sprite over MEBx.
            // Check user consent state.
            if (GetUserConsentState() != OptInState.Displayed)
            {
                Console.WriteLine("User Consent form will be displayed via MEBx.");
                if ((YesNoFlag)Params.AskYesNo(ASK_FOR_SAMPLE_REBOOT) == YesNoFlag.YES)
                {
                    BootSystem(PowerState.SoftPowerCycle);
                }
            }

            // The DefaultScreen property controls on which screen the Sprite message is displayed. 
            // It is used by the IT to switch between screens if the local user does not see the Consent form. 
            if ((YesNoFlag)Params.AskYesNo(ASK_FOR_SWITCH_SCREEN) == YesNoFlag.YES)
            {
                SetDefaultMonitor();
            }

            // -----------------------------
            // STEP 5: Send the consent code. 
            // ------------------------------
            // Get the user consent code and send it.
            SendConsentCode();

            //Perform the task that required user consent...!

            //Stop the Consent Flow
            StopUserConsent();
        }

        #endregion

        #region UTILS_FUNCTIONS

        /// <summary>
        /// Reboot the system.
        /// </summary>
        public void BootSystem(PowerState requestedPower)
        {
            Console.WriteLine("Booting the system...   ");

            IManagedReference powerManagementRef = wsmanClient.NewReference("SELECT * FROM CIM_PowerManagementService WHERE Name='Intel(r) AMT Power Management Service'");
            IManagedInstance inputObject = powerManagementRef.CreateMethodInput("RequestPowerStateChange");
            inputObject.SetProperty("PowerState", (uint)requestedPower); // 5 = SoftPowerCycle - other options can also be set, based on the value that is being passed.
            /*
             * The supported PowerState values are: 
             * 2 (Power Up), 5 (Power Cycle), 8 (Power Down), 10 (Master Bus Reset) 
             * 
             * ValueMap={2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}
               Values={Power On, Sleep - Light, Sleep - Deep, Power Cycle (Off Soft), Power Off - Hard, Hibernate, Power Off - Soft,
             *          Power Cycle (Off Hard), Master Bus Reset, Diagnostic Interrupt (NMI), Power Off - Soft Graceful, Power Off - Hard Graceful,
             *          Master Bus Reset Graceful, Power Cycle (Off - Soft Graceful), Power Cycle (Off - Hard Graceful)}
             */

            IManagedReference computerSystemRef = wsmanClient.NewReference("SELECT * FROM CIM_ComputerSystem WHERE Name='ManagedSystem'");
            inputObject.SetProperty("ManagedElement", computerSystemRef);
            IManagedInstance outputObject = powerManagementRef.InvokeMethod(inputObject);
            IWsmanItem return_value = outputObject.GetProperty("ReturnValue");

            if (Convert.ToUInt64(return_value.ToString()) != PT_STATUS_SUCCESS)
            {
                throw new Exception("Failed to change power state. Intel AMT status code: " + StatusCodes[Convert.ToUInt32(return_value.ToString())]);
            }

        }
        #endregion
    }
}