using System;
using System.Net;
using System.Threading;
using System.Collections.Specialized;
using ExtremeSwank.Authentication.OpenID.Persistence;

namespace ExtremeSwank.Authentication.OpenID
{
    /// <summary>
    /// Provides OpenID client support for desktop applications.
    /// </summary>
    /// <remarks>
    /// <para>
    /// The user's web browser will need to be launched to perform authentication.
    /// All data will be passed back to the application through an embedded web server that will
    /// only start as needed to receive the authentication response.
    /// </para>
    /// <para>
    /// Use BeginAuthentication() to asynchronously start
    /// the temporary HTTP server and return the redirect URL.  This URL should be passed to the client host
    /// and launched in its web browser.  Use GetAuthenticationResponse() to wait for the authentication
    /// response, or subscribe to the available events if blocking is not desired.
    /// </para>
    /// <para>
    /// In either case, the HTTP server will be closed if the timeout has expired.
    /// </para>
    /// </remarks>
    public class OpenIDDesktopConsumer
    {
        #region Fields and Properties

        HttpListener listener;
        OpenIDConsumer openid;
        bool responsereceived;
        bool authSuccessful;
        Errors _ErrorState;
        int _Timeout;
        string _Identity;
        int _Port;
        bool _UseRandomPort;
        string _Hostname;
        DateTime startTime;
        ISessionPersistence _SessionManager;
        IAssociationPersistence _AssociationManager;
        string _DirectedOpenIDServer;
        bool _ReturnEmptyHTML = false;

        /// <summary>
        /// Generates a URL prefix that will be used to initialize
        /// the temporary HTTP server.
        /// </summary>
        string Prefix
        {
            get { return "http://*:" + _Port + "/"; }
        }

        /// <summary>
        /// The OpenIDConsumer object used for processing.
        /// </summary>
        public OpenIDConsumer Consumer
        {
            get { return openid; }
        }

        /// <summary>
        /// Current error status.
        /// </summary>
        public Errors Error
        {
            get { return _ErrorState; }
        }

        /// <summary>
        ///	The temporary HTTP server's result HTML is original(false) or non-script version(true).
        /// </summary>
        public bool ReturnEmptyHTML
        {
            get { return _ReturnEmptyHTML; }
            set { _ReturnEmptyHTML = value; }
        }

        #endregion

        #region Constructors

        /// <summary>
        /// Create a new instance of OpenIDDesktopConsumer.
        /// </summary>
        /// <param name="identity">The OpenID Identity to authenticate.</param>
        /// <param name="timeout">The amount of time to wait for a response back from the OpenID Provider.</param>
        /// <param name="hostname">The hostname that will be used for the return URL.</param>
        /// <param name="port">The port number that should be used to receive the authentication response from the User's web browser, if random ports are not desired.</param>
        public OpenIDDesktopConsumer(string identity, int timeout, string hostname, int port)
        {
            _UseRandomPort = false;
            Init(identity);
            _Hostname = hostname;
            _Timeout = timeout;
            _Port = port;
        }

        /// <summary>
        /// Create a new instance of OpenIDDesktopConsumer.
        /// </summary>
        /// <param name="identity">The OpenID Identity to authenticate.</param>
        /// <param name="timeout">The amount of time to wait for a response back from the OpenID Provider.</param>
        /// <param name="hostname">The hostname that will be used for the return URL.</param>
        public OpenIDDesktopConsumer(string identity, int timeout, string hostname)
        {
            _UseRandomPort = true;
            Init(identity);
            _Hostname = hostname;
            _Timeout = timeout;
        }

        /// <summary>
        /// Create a new instance of OpenIDDesktopConsumer.
        /// </summary>
        /// <param name="identity">The OpenID Identity to authenticate.</param>
        /// <param name="timeout">The amount of time to wait for a response back from the OpenID Provider.</param>
        public OpenIDDesktopConsumer(string identity, int timeout)
        {
            _UseRandomPort = true;
            Init(identity);
            _Timeout = timeout;
        }

        #endregion

        #region Public Methods

        /// <summary>
        /// Start listening for an authentication response, and return the redirect URL that the web browser
        /// will be pointed to.
        /// </summary>
        /// <returns>The redirect URL for the remote web browser.</returns>
        public string BeginAuthentication()
        {
            NonblockingListener();
            string url = openid.BeginAuth(false, false);
            if (String.IsNullOrEmpty(url))
            {
                _ErrorState = openid.GetError();
                CancelAuthentication();
            }
            else
            {
                AuthenticationTimer at = new AuthenticationTimer(WaitForResponse);
                at.BeginInvoke(null, null);
            }
            return url;
        }

        /// <summary>
        /// Stop listening for the authentication response.
        /// </summary>
        public void CancelAuthentication()
        {
            if (listener != null)
            {
                listener.Abort();
                listener = null;
            }
        }

        /// <summary>
        /// Wait until an authentication response has been received, and return the result.
        /// </summary>
        /// <returns>True if succeeded, false if not.</returns>
        public bool GetAuthenticationResponse()
        {
            return BlockWaitForResponse();
        }

        /// <summary>
        /// Enable Stateful authentication using supplied persistence objects.
        /// </summary>
        /// <param name="assocmgr">IAssociationPersistence object to use when persisting associations.</param>
        /// <param name="sessionmgr">ISessionPersistence object to use when persisting per-user data.</param>
        public void EnableStatefulMode(IAssociationPersistence assocmgr, ISessionPersistence sessionmgr)
        {
            _AssociationManager = assocmgr;
            _SessionManager = sessionmgr;
            openid = GetConsumer(new NameValueCollection());
        }

        /// <summary>
        /// Enable Stateful authentication using default (volatile) persistence objects.
        /// </summary>
        /// <remarks>
        /// Uses <see cref="SingularAssociationManager"/> and <see cref="SingularSessionManager"/>
        /// objects.  These are volatile, and all contained data will be destroyed when 
        /// the <see cref="OpenIDDesktopConsumer"/> object is disposed.
        /// </remarks>
        public void EnableStatefulMode()
        {
            _AssociationManager = new SingularAssociationManager();
            _SessionManager = new SingularSessionManager();
            openid = GetConsumer(new NameValueCollection());
        }

        /// <summary>
        /// Enable Directed Identity mode for a specific OpenID Provider.
        /// </summary>
        /// <remarks>
        /// Consumer will only authenticate with the supplied provider URL,
        /// and will accept the OpenID returned in the authentication response.
        /// </remarks>
        /// <param name="openidserver">URL to the desired OpenID server</param>
        public void EnableDirectedIdentity(string openidserver)
        {
            _DirectedOpenIDServer = openidserver;
            openid.UseDirectedIdentity = true;
            openid.OpenIDServer = openidserver;
        }

        #endregion

        #region Private Methods and Properties

        /// <summary>
        /// Shared initialization method used by all constructors.
        /// </summary>
        /// <param name="identity">OpenID Identity to authenticate.</param>
        void Init(string identity)
        {
            GenerateRandomPort();
            authSuccessful = false;
            responsereceived = false;
            _Identity = identity;
            _Hostname = System.Environment.MachineName;
            openid = GetConsumer(new NameValueCollection());
        }

        /// <summary>
        /// Create a new OpenIDConsumer object with settings appropriate for this class.
        /// </summary>
        /// <param name="arguments">The <see cref="NameValueCollection"/> containing the received arguments.</param>
        /// <returns>The created OpenIDConsumer object.</returns>
        OpenIDConsumer GetConsumer(NameValueCollection arguments)
        {
            openid = new OpenIDConsumer(arguments, _AssociationManager, _SessionManager);
            openid.Identity = _Identity;
            if (!String.IsNullOrEmpty(_DirectedOpenIDServer))
            {
                openid.UseDirectedIdentity = true;
                openid.OpenIDServer = _DirectedOpenIDServer;
            }
            SetConsumerURLs();

            return openid;
        }

        /// <summary>
        /// Updates the <see cref="OpenIDConsumer"/> object with the
        /// correct TrustRoot and RetunURL values.
        /// </summary>
        void SetConsumerURLs()
        {
            if (openid != null)
            {
                openid.TrustRoot = "http://" + _Hostname.ToLower() + ":" + _Port + "/";
                openid.ReturnURL = openid.TrustRoot + "return";
            }
        }

        /// <summary>
        /// If a port was not specified in the constructor, generate a
        /// random port number between 1024 and 5000.
        /// </summary>
        void GenerateRandomPort()
        {
            if (_UseRandomPort)
            {
                Random r = new Random(DateTime.Now.Second);
                _Port = r.Next(1024, 5000);
                SetConsumerURLs();
            }
        }

        /// <summary>
        /// Intended to be called asynchronously.  Check every second to see if the user's authentication
        /// response has been received.  If timeout occurs, automatically close HTTP server.
        /// </summary>
        /// <returns>True if a response has been received, false if timed out.</returns>
        bool WaitForResponse()
        {
            while (true)
            {
                if (responsereceived) { break; }
                if (DateTime.Now > startTime.AddSeconds(_Timeout))
                {
                    _ErrorState = Errors.SessionTimeout;
                    authSuccessful = false;
                    CancelAuthentication();
                    if (AuthenticationResponseTimedOut != null) { AuthenticationResponseTimedOut.Invoke(this, new EventArgs()); }
                    break;
                }
                Thread.Sleep(1000);
            }
            return authSuccessful;
        }

        /// <summary>
        /// Intended to be called synchronously.  Check every second to see if the user's authentication
        /// response has been received.  Will wait until the automatically called asynchronous WaitForResponse()
        /// function has returned.
        /// </summary>
        /// <returns></returns>
        bool BlockWaitForResponse()
        {
            while (true)
            {
                if (responsereceived) { break; }
                if (listener == null) { break; }
                if (!listener.IsListening) { break; }
                Thread.Sleep(1000);
            }
            return authSuccessful;
        }

        /// <summary>
        /// Start the temporary HTTP server, and register
        /// the callback method.
        /// </summary>
        void NonblockingListener()
        {
            bool success = false;
            int attempts = 0;
            IAsyncResult result;
            while (!success)
            {
                try
                {
                    listener = new HttpListener();
                    listener.Prefixes.Add(Prefix);
                    listener.Start();
                    startTime = DateTime.Now;
                    success = true;
                    result = listener.BeginGetContext(new AsyncCallback(ListenerCallback), listener);
                }
                catch
                {
                    startTime = new DateTime();
                    GenerateRandomPort();
                    success = false;
                }
                attempts++;
                if (attempts >= 5)
                {
                    throw new Exception("Could not open HTTP listening port after 5 attempts.  Ensure the process is running with Administrator privileges.");
                }
            }

        }

        #endregion

        #region Private Event Callbacks

        /// <summary>
        /// The callback method for the temporary HTTP server.
        /// </summary>
        /// <param name="result">The <see cref="IAsyncResult"/> object representing the active <see cref="HttpListener"/>.</param>
        void ListenerCallback(IAsyncResult result)
        {
            HttpListener listener = (HttpListener)result.AsyncState;

            try
            {
                // Call EndGetContext to complete the asynchronous operation.
                HttpListenerContext context = listener.EndGetContext(result);
                HttpListenerRequest request = context.Request;

#if true
                // Create "request.QueryString" as UTF-8
                NameValueCollection queryString = new NameValueCollection();
                foreach (string query in request.Url.Query.Substring(1).Split('&'))
                {
                    int pos = query.IndexOf('=');
                    if (pos > 0)
                    {
                        string key = Uri.UnescapeDataString(query.Substring(0, pos));
                        string value = Uri.UnescapeDataString(query.Substring(pos + 1));
                        queryString.Add(key, value);
                    }
                    else
                    {
                        queryString.Add(null, Uri.UnescapeDataString(query.Substring(pos + 1)));
                    }
                }
#else
                openid = GetConsumer(request.QueryString);
#endif
                openid = GetConsumer(queryString);
                openid.ValidationSucceeded += new EventHandler(openid_ValidationSucceeded);
                openid.ReceivedCancelResponse += new EventHandler(openid_ReceivedCancelResponse);
                openid.ValidationFailed += new EventHandler(openid_ValidationFailed);
                openid.HandleResponses();

                // Obtain a response object.
                HttpListenerResponse response = context.Response;
                // Construct a response.
                string responseString;
                if (_ReturnEmptyHTML)
                {
                    responseString = "<HTML><HEAD><TITLE></TITLE><BODY></BODY></HTML>";
                }
                else
                {
                    responseString = "<HTML><BODY onLoad=\"javascript:window.close();\">Please close this browser window.</BODY></HTML>";
                }
                byte[] buffer = System.Text.Encoding.UTF8.GetBytes(responseString);
                // Get a response stream and write the response to it.
                response.ContentLength64 = buffer.Length;
                System.IO.Stream output = response.OutputStream;
                output.Write(buffer, 0, buffer.Length);
                // You must close the output stream.
                output.Close();
                responsereceived = true;
                listener.Close();
                if (AuthenticationResponseReceived != null)
                {
                    AuthenticationResponseReceived.Invoke(this, new EventArgs());
                }
            }
            catch
            {
            }
        }

        /// <summary>
        /// Callback method for when OpenIDConsumer invokes its <see cref="OpenIDConsumer.ReceivedCancelResponse"/> event.
        /// </summary>
        /// <param name="sender">The OpenIDConsumer object invoking the event.</param>
        /// <param name="e">Event arguments.</param>
        void openid_ReceivedCancelResponse(object sender, EventArgs e)
        {
            _ErrorState = Errors.RequestCancelled;
            if (AuthenticationCancelled != null) { AuthenticationCancelled.Invoke(this, new EventArgs()); }
        }

        /// <summary>
        /// Callback method for when OpenIDConsumer invokes its <see cref="OpenIDConsumer.ValidationSucceeded"/> event.
        /// </summary>
        /// <param name="sender">The OpenIDConsumer object invoking the event.</param>
        /// <param name="e">Event arguments.</param>
        void openid_ValidationSucceeded(object sender, EventArgs e)
        {
            authSuccessful = true;
            if (AuthenticationSuccessful != null) { AuthenticationSuccessful.Invoke(this, new EventArgs()); }
        }

        /// <summary>
        /// Callback method for when OpenIDConsumer invokes its <see cref="OpenIDConsumer.ValidationFailed"/> event.
        /// </summary>
        /// <param name="sender">The OpenIDConsumer object invoking the event.</param>
        /// <param name="e">Event arguments.</param>
        void openid_ValidationFailed(object sender, EventArgs e)
        {
            if (AuthenticationFailed != null) { AuthenticationFailed.Invoke(this, new EventArgs()); }
        }

        /// <summary>
        /// Delegate used for the asynchronous timeout checker.
        /// </summary>
        /// <returns>Value not used.</returns>
        delegate bool AuthenticationTimer();

        #endregion

        #region Public Events

        /// <summary>
        /// Authentication response has been received.
        /// </summary>
        public event EventHandler AuthenticationResponseReceived;

        /// <summary>
        /// Authentication response has timed out.
        /// </summary>
        public event EventHandler AuthenticationResponseTimedOut;

        /// <summary>
        /// Authentication was successful.
        /// </summary>
        public event EventHandler AuthenticationSuccessful;

        /// <summary>
        /// Authentication failed.
        /// </summary>
        public event EventHandler AuthenticationFailed;

        /// <summary>
        /// Authentication was cancelled at the OpenID Provider.
        /// </summary>
        public event EventHandler AuthenticationCancelled;

        #endregion

    }
}