//******************************************************************************************************
//  Events.cs - Gbtc
//
//  Copyright © 2012, Grid Protection Alliance.  All Rights Reserved.
//
//  Licensed to the Grid Protection Alliance (GPA) under one or more contributor license agreements. See
//  the NOTICE file distributed with this work for additional information regarding copyright ownership.
//  The GPA licenses this file to you under the MIT License (MIT), the "License"; you may
//  not use this file except in compliance with the License. You may obtain a copy of the License at:
//
//      http://www.opensource.org/licenses/MIT
//
//  Unless agreed to in writing, the subject software distributed under the License is distributed on an
//  "AS-IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. Refer to the
//  License for the specific language governing permissions and limitations.
//
//  Code Modification History:
//  ----------------------------------------------------------------------------------------------------
//  12/28/2006 - Pinal C. Patel
//       Generated original version of source code.
//  08/31/2007 - Darrell Zuercher
//       Edited code comments.
//  09/15/2008 - J. Ritchie Carroll
//       Converted to C#.
//  09/29/2008 - Pinal C. Patel
//       Entered code comments.
//  09/14/2009 - Stephen C. Wills
//       Added new header and license agreement.
//  09/22/2011 - J. Ritchie Carroll
//       Added Mono implementation exception regions.
//  12/14/2012 - Starlynn Danyelle Gilliam
//       Modified Header.
//
//******************************************************************************************************

using System;
using System.ComponentModel;
using System.Runtime.InteropServices;

namespace GSF.Console
{
    /// <summary>
    /// Defines a set of consumable events that can be raised by a console application.
    /// </summary>
    /// <remarks>
    /// Note that no events will be raised by this class when running under Mono deployments, the class
    /// remains available in the Mono build as a stub to allow existing code to still compile and run.
    /// </remarks>
    /// <example>
    /// This example shows how to subscribe to console application events:
    /// <code>
    /// using System;
    /// using GSF.Console;
    ///
    /// class Program
    /// {
    ///     static void Main(string[] args)
    ///     {
    ///         // Subscribe to console events.
    ///         Events.CancelKeyPress += Events_CancelKeyPress;
    ///         Events.ConsoleClosing += Events_ConsoleClosing;
    ///         Events.EnableRaisingEvents();
    ///        
    ///         Console.ReadLine();
    ///     }
    ///    
    ///     static void Events_CancelKeyPress(object sender, System.ComponentModel.CancelEventArgs e)
    ///     {
    ///         // Abort processing.
    ///     }
    ///    
    ///     static void Events_ConsoleClosing(object sender, System.ComponentModel.CancelEventArgs e)
    ///     {
    ///         // Put clean-up code.
    ///     }
    /// }
    /// </code>
    /// </example>
    public static class Events
    {
        private enum ConsoleEventType
        {
            CancelKeyPress = 0,
            BreakKeyPress = 1,
            ConsoleClosing = 2,
            UserLoggingOff = 5,
            SystemShutdown = 6
        }

        private delegate bool ConsoleWindowEventHandler(ConsoleEventType controlType);
        private static ConsoleWindowEventHandler s_handler;

#if !MONO
        // TODO: See if there a standard POSIX way to pickup similar events
        [DllImport("kernel32.dll", EntryPoint = "SetConsoleCtrlHandler")]
        [return: MarshalAs(UnmanagedType.Bool)]
        private static extern bool SetConsoleWindowEventRaising(ConsoleWindowEventHandler handler, [MarshalAs(UnmanagedType.Bool)] bool enable);
#endif

        /// <summary>
        /// Occurs when CTRL+C signal is received from keyboard input.
        /// </summary>
        /// <remarks>
        /// <see cref="EnableRaisingEvents"/> method must be called to enable event publication.
        /// </remarks>
        public static event EventHandler<CancelEventArgs> CancelKeyPress;

        /// <summary>
        /// Occurs when CTRL+BREAK signal is received from keyboard input.
        /// </summary>
        /// <remarks>
        /// <see cref="EnableRaisingEvents"/> method must be called to enable event publication.
        /// </remarks>
        public static event EventHandler<CancelEventArgs> BreakKeyPress;

        /// <summary>
        /// Occurs when the user closes the console application window.
        /// </summary>
        /// <remarks>
        /// <see cref="EnableRaisingEvents"/> method must be called to enable event publication.
        /// </remarks>
        public static event EventHandler<CancelEventArgs> ConsoleClosing;

        /// <summary>
        /// Occurs when the user is logging off.
        /// </summary>
        /// <remarks>
        /// <see cref="EnableRaisingEvents"/> method must be called to enable event publication.
        /// </remarks>
        public static event EventHandler UserLoggingOff;

        /// <summary>
        /// Occurs when the system is shutting down.
        /// </summary>
        /// <remarks>
        /// <see cref="EnableRaisingEvents"/> method must be called to enable event publication.
        /// </remarks>
        public static event EventHandler SystemShutdown;

        /// <summary>
        /// Enables the raising of console application <see cref="Events"/>. Prior to calling this method, handlers 
        /// must be defined for the <see cref="Events"/> raised by a console application.
        /// </summary>
        /// <remarks>
        /// This method is currently ignored under Mono deployments.
        /// </remarks>
        public static void EnableRaisingEvents()
        {
            s_handler = HandleConsoleWindowEvents;
#if !MONO

            // Member variable is used here so that the delegate is not garbage collected by the time it is called
            // by WIN API when any of the control events take place.
            // http://forums.microsoft.com/MSDN/ShowPost.aspx?PostID=996045&SiteID=1
            SetConsoleWindowEventRaising(s_handler, true);
#endif
        }

        /// <summary>
        /// Enables the raising of console application <see cref="Events"/>. 
        /// </summary>
        /// <remarks>
        /// This method is currently ignored under Mono deployments.
        /// </remarks>
        public static void DisableRaisingEvents()
        {
            s_handler = HandleConsoleWindowEvents;
#if !MONO
            SetConsoleWindowEventRaising(s_handler, false);
#endif
        }

        /// <summary>
        /// Delegate method that gets called when console application events occur.
        /// </summary>
        private static bool HandleConsoleWindowEvents(ConsoleEventType controlType)
        {
            // ms-help://MS.VSCC.v80/MS.MSDN.v80/MS.WIN32COM.v10.en/dllproc/base/handlerroutine.htm

            // When this function does not return True, the default handler is called and the default action takes
            // place.
            switch (controlType)
            {
                case ConsoleEventType.CancelKeyPress:
                    CancelEventArgs ctrlCKeyPressEventData = new CancelEventArgs();

                    if ((object)CancelKeyPress != null)
                        CancelKeyPress(null, ctrlCKeyPressEventData);

                    if (ctrlCKeyPressEventData.Cancel)
                        return true;

                    break;
                case ConsoleEventType.BreakKeyPress:
                    CancelEventArgs ctrlBreakKeyPressEventData = new CancelEventArgs();

                    if ((object)BreakKeyPress != null)
                        BreakKeyPress(null, ctrlBreakKeyPressEventData);

                    if (ctrlBreakKeyPressEventData.Cancel)
                        return true;

                    break;
                case ConsoleEventType.ConsoleClosing:
                    CancelEventArgs consoleClosingEventData = new CancelEventArgs();

                    if ((object)ConsoleClosing != null)
                        ConsoleClosing(null, consoleClosingEventData);

                    if (consoleClosingEventData.Cancel)
                        return true;

                    break;
                case ConsoleEventType.UserLoggingOff:
                    if ((object)UserLoggingOff != null)
                        UserLoggingOff(null, EventArgs.Empty);

                    break;
                case ConsoleEventType.SystemShutdown:
                    if ((object)SystemShutdown != null)
                        SystemShutdown(null, EventArgs.Empty);

                    break;
            }

            return false;
        }
    }
}