//------------------------------------------------------------------------------
// <copyright file="WebServiceHandler.cs" company="Microsoft">
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>                                                                
//------------------------------------------------------------------------------

namespace System.Web.Services.Protocols {

    using System.Diagnostics;
    using System;
    using System.Runtime.InteropServices;
    using System.Reflection;
    using System.IO;
    using System.Collections;
    using System.Web;
    using System.Web.SessionState;
    using System.Web.Services.Interop;
    using System.Configuration;
    using Microsoft.Win32;
    using System.Threading;
    using System.Text;
    using System.Web.UI;
    using System.Web.Util;
    using System.Web.UI.WebControls;
    using System.ComponentModel; // for CompModSwitches
    using System.EnterpriseServices;
    using System.Runtime.Remoting.Messaging;
    using System.Web.Services.Diagnostics;

    internal class WebServiceHandler {
        ServerProtocol protocol;
        Exception exception;
        AsyncCallback asyncCallback;
        ManualResetEvent asyncBeginComplete;
        int asyncCallbackCalls;
        bool wroteException;
        object[] parameters = null;

        internal WebServiceHandler(ServerProtocol protocol) {
            this.protocol = protocol;
        }

        // Flush the trace file after each request so that the trace output makes it to the disk.
        static void TraceFlush() {
            Debug.Flush();
        }

        void PrepareContext() {
            this.exception = null;
            this.wroteException = false;
            this.asyncCallback = null;
            this.asyncBeginComplete = new ManualResetEvent(false);
            this.asyncCallbackCalls = 0;
            if (protocol.IsOneWay)
                return;
            HttpContext context = protocol.Context;
            if (context == null) return; // context is null in non-network case

            // we want the default to be no caching on the client
            int cacheDuration = protocol.MethodAttribute.CacheDuration;
            if (cacheDuration > 0) {
                context.Response.Cache.SetCacheability(HttpCacheability.Server);
                context.Response.Cache.SetExpires(DateTime.Now.AddSeconds(cacheDuration));
                context.Response.Cache.SetSlidingExpiration(false);
                // with soap 1.2 the action is a param in the content-type
                context.Response.Cache.VaryByHeaders["Content-type"] = true;
                context.Response.Cache.VaryByHeaders["SOAPAction"] = true;
                context.Response.Cache.VaryByParams["*"] = true;
            }
            else {
                context.Response.Cache.SetNoServerCaching();
                context.Response.Cache.SetMaxAge(TimeSpan.Zero);
            }
            context.Response.BufferOutput = protocol.MethodAttribute.BufferResponse;
            context.Response.ContentType = null;

        }

        void WriteException(Exception e) {
            if (this.wroteException) return;

            if (CompModSwitches.Remote.TraceVerbose) Debug.WriteLine("Server Exception: " + e.ToString());
            if (e is TargetInvocationException) {
                if (CompModSwitches.Remote.TraceVerbose) Debug.WriteLine("TargetInvocationException caught.");
                e = e.InnerException;
            }

            this.wroteException = protocol.WriteException(e, protocol.Response.OutputStream);
            if (!this.wroteException)
                throw e;
        }

        void Invoke() {
            PrepareContext();
            protocol.CreateServerInstance();

            string stringBuffer;
#if !MONO
            RemoteDebugger debugger = null;
            if (!protocol.IsOneWay && RemoteDebugger.IsServerCallInEnabled(protocol, out stringBuffer)) {
                debugger = new RemoteDebugger();
                debugger.NotifyServerCallEnter(protocol, stringBuffer);
            }
#endif
            try {
                TraceMethod caller = Tracing.On ? new TraceMethod(this, "Invoke") : null;
                TraceMethod userMethod = Tracing.On ? new TraceMethod(protocol.Target, protocol.MethodInfo.Name, this.parameters) : null;
                if (Tracing.On) Tracing.Enter(protocol.MethodInfo.ToString(), caller, userMethod);
                object[] returnValues = protocol.MethodInfo.Invoke(protocol.Target, this.parameters);
                if (Tracing.On) Tracing.Exit(protocol.MethodInfo.ToString(), caller);
                WriteReturns(returnValues);
            }
            catch (Exception e) {
                if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException) {
                    throw;
                }
                if (Tracing.On) Tracing.ExceptionCatch(TraceEventType.Error, this, "Invoke", e);
                if (!protocol.IsOneWay) {
                    WriteException(e);
                    throw;
                }
            }
            finally {
                protocol.DisposeServerInstance();
#if !MONO
                if (debugger != null)
                    debugger.NotifyServerCallExit(protocol.Response);
#endif
            }
        }

        // By keeping this in a separate method we avoid jitting system.enterpriseservices.dll in cases
        // where transactions are not used.
        void InvokeTransacted() {
            Transactions.InvokeTransacted(new TransactedCallback(this.Invoke), protocol.MethodAttribute.TransactionOption);
        }

        void ThrowInitException() {
            HandleOneWayException(new Exception(Res.GetString(Res.WebConfigExtensionError), protocol.OnewayInitException), "ThrowInitException");
        }

        void HandleOneWayException(Exception e, string method) {
            if (Tracing.On) Tracing.ExceptionCatch(TraceEventType.Error, this, string.IsNullOrEmpty(method) ? "HandleOneWayException" : method, e);
            // exceptions for one-way calls are dropped because the response is already written
        }

        protected void CoreProcessRequest() {
            try {
                bool transacted = protocol.MethodAttribute.TransactionEnabled;
                if (protocol.IsOneWay) {
                    WorkItemCallback callback = null;
                    TraceMethod callbackMethod = null;
                    if (protocol.OnewayInitException != null) {
                        callback = new WorkItemCallback(this.ThrowInitException);
                        callbackMethod = Tracing.On ? new TraceMethod(this, "ThrowInitException") : null;
                    }
                    else {
                        parameters = protocol.ReadParameters();
                        callback = transacted ? new WorkItemCallback(this.OneWayInvokeTransacted) : new WorkItemCallback(this.OneWayInvoke);
                        callbackMethod = Tracing.On ? transacted ? new TraceMethod(this, "OneWayInvokeTransacted") : new TraceMethod(this, "OneWayInvoke") : null;
                    }

                    if (Tracing.On) Tracing.Information(Res.TracePostWorkItemIn, callbackMethod);
                    WorkItem.Post(callback);
                    if (Tracing.On) Tracing.Information(Res.TracePostWorkItemOut, callbackMethod);

                    protocol.WriteOneWayResponse();
                }
                else if (transacted) {
                    parameters = protocol.ReadParameters();
                    InvokeTransacted();
                }
                else {
                    parameters = protocol.ReadParameters();
                    Invoke();
                }
            }
            catch (Exception e) {
                if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException) {
                    throw;
                }
                if (Tracing.On) Tracing.ExceptionCatch(TraceEventType.Error, this, "CoreProcessRequest", e);
                if (!protocol.IsOneWay)
                    WriteException(e);
            }

            TraceFlush();
        }

        private HttpContext SwitchContext(HttpContext context) {
            PartialTrustHelpers.FailIfInPartialTrustOutsideAspNet();
            HttpContext oldContext = HttpContext.Current;
            HttpContext.Current = context;
            return oldContext;
        }

        private void OneWayInvoke() {
            HttpContext oldContext = null;
            if (protocol.Context != null)
                oldContext = SwitchContext(protocol.Context);

            try {
                Invoke();
            }
            catch (Exception e) {
                HandleOneWayException(e, "OneWayInvoke");
            }
            finally {
                if (oldContext != null)
                    SwitchContext(oldContext);
            }
        }

        private void OneWayInvokeTransacted() {
            HttpContext oldContext = null;
            if (protocol.Context != null)
                oldContext = SwitchContext(protocol.Context);

            try {
                InvokeTransacted();
            }
            catch (Exception e) {
                HandleOneWayException(e, "OneWayInvokeTransacted");
            }
            finally {
                if (oldContext != null)
                    SwitchContext(oldContext);
            }
        }

        private void Callback(IAsyncResult result) {
            if (!result.CompletedSynchronously)
                this.asyncBeginComplete.WaitOne();
            DoCallback(result);
        }

        private void DoCallback(IAsyncResult result) {
            if (this.asyncCallback != null) {
                if (System.Threading.Interlocked.Increment(ref this.asyncCallbackCalls) == 1) {
                    this.asyncCallback(result);
                }
            }
        }

        protected IAsyncResult BeginCoreProcessRequest(AsyncCallback callback, object asyncState) {
            IAsyncResult asyncResult;

            if (protocol.MethodAttribute.TransactionEnabled)
                throw new InvalidOperationException(Res.GetString(Res.WebAsyncTransaction));

            parameters = protocol.ReadParameters();
            if (protocol.IsOneWay) {
                TraceMethod callbackMethod = Tracing.On ? new TraceMethod(this, "OneWayAsyncInvoke") : null;
                if (Tracing.On) Tracing.Information(Res.TracePostWorkItemIn, callbackMethod);
                WorkItem.Post(new WorkItemCallback(this.OneWayAsyncInvoke));
                if (Tracing.On) Tracing.Information(Res.TracePostWorkItemOut, callbackMethod);
                asyncResult = new CompletedAsyncResult(asyncState, true);
                if (callback != null)
                    callback(asyncResult);
            }
            else
                asyncResult = BeginInvoke(callback, asyncState);
            return asyncResult;
        }

        private void OneWayAsyncInvoke() {
            if (protocol.OnewayInitException != null)
                HandleOneWayException(new Exception(Res.GetString(Res.WebConfigExtensionError), protocol.OnewayInitException), "OneWayAsyncInvoke");
            else {
                HttpContext oldContext = null;
                if (protocol.Context != null)
                    oldContext = SwitchContext(protocol.Context);

                try {
                    BeginInvoke(new AsyncCallback(this.OneWayCallback), null);
                }
                catch (Exception e) {
                    HandleOneWayException(e, "OneWayAsyncInvoke");
                }
                finally {
                    if (oldContext != null)
                        SwitchContext(oldContext);
                }
            }
        }

        private IAsyncResult BeginInvoke(AsyncCallback callback, object asyncState) {
            IAsyncResult asyncResult;
            try {
                PrepareContext();
                protocol.CreateServerInstance();
                this.asyncCallback = callback;

                TraceMethod caller = Tracing.On ? new TraceMethod(this, "BeginInvoke") : null;
                TraceMethod userMethod = Tracing.On ? new TraceMethod(protocol.Target, protocol.MethodInfo.Name, this.parameters) : null;
                if (Tracing.On) Tracing.Enter(protocol.MethodInfo.ToString(), caller, userMethod);

                asyncResult = protocol.MethodInfo.BeginInvoke(protocol.Target, this.parameters, new AsyncCallback(this.Callback), asyncState);

                if (Tracing.On) Tracing.Enter(protocol.MethodInfo.ToString(), caller);

                if (asyncResult == null) throw new InvalidOperationException(Res.GetString(Res.WebNullAsyncResultInBegin));
            }
            catch (Exception e) {
                if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException) {
                    throw;
                }
                if (Tracing.On) Tracing.ExceptionCatch(TraceEventType.Error, this, "BeginInvoke", e);
                // save off the exception and throw it in EndCoreProcessRequest
                exception = e;
                asyncResult = new CompletedAsyncResult(asyncState, true);
                this.asyncCallback = callback;
                this.DoCallback(asyncResult);
            }
            this.asyncBeginComplete.Set();
            TraceFlush();
            return asyncResult;
        }

        private void OneWayCallback(IAsyncResult asyncResult) {
            EndInvoke(asyncResult);
        }

        protected void EndCoreProcessRequest(IAsyncResult asyncResult) {
            if (asyncResult == null) return;

            if (protocol.IsOneWay)
                protocol.WriteOneWayResponse();
            else
                EndInvoke(asyncResult);
        }

        private void EndInvoke(IAsyncResult asyncResult) {
            try {
                if (exception != null)
                    throw (exception);
                object[] returnValues = protocol.MethodInfo.EndInvoke(protocol.Target, asyncResult);
                WriteReturns(returnValues);
            }
            catch (Exception e) {
                if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException) {
                    throw;
                }
                if (Tracing.On) Tracing.ExceptionCatch(TraceEventType.Error, this, "EndInvoke", e);
                if (!protocol.IsOneWay)
                    WriteException(e);
            }
            finally {
                protocol.DisposeServerInstance();
            }
            TraceFlush();
        }

        void WriteReturns(object[] returnValues) {
            if (protocol.IsOneWay) return;

            // By default ASP.NET will fully buffer the response. If BufferResponse=false
            // then we still want to do partial buffering since each write is a named
            // pipe call over to inetinfo.
            bool fullyBuffered = protocol.MethodAttribute.BufferResponse;
            Stream outputStream = protocol.Response.OutputStream;
            if (!fullyBuffered) {
                outputStream = new BufferedResponseStream(outputStream, 16 * 1024);
                //#if DEBUG
                ((BufferedResponseStream)outputStream).FlushEnabled = false;
                //#endif
            }
            protocol.WriteReturns(returnValues, outputStream);
            // This will flush the buffered stream and the underlying stream. Its important
            // that it flushes the Response.OutputStream because we always want BufferResponse=false
            // to mean we are writing back a chunked response. This gives a consistent
            // behavior to the client, independent of the size of the partial buffering.
            if (!fullyBuffered) {
                //#if DEBUG
                ((BufferedResponseStream)outputStream).FlushEnabled = true;
                //#endif
                outputStream.Flush();
            }
        }
    }

    internal class SyncSessionlessHandler : WebServiceHandler, IHttpHandler {

        internal SyncSessionlessHandler(ServerProtocol protocol) : base(protocol) { }

        public bool IsReusable {
            get { return false; }
        }

        public void ProcessRequest(HttpContext context) {
            TraceMethod method = Tracing.On ? new TraceMethod(this, "ProcessRequest") : null;
            if (Tracing.On) Tracing.Enter("IHttpHandler.ProcessRequest", method, Tracing.Details(context.Request));

            CoreProcessRequest();

            if (Tracing.On) Tracing.Exit("IHttpHandler.ProcessRequest", method);
        }
    }

    internal class SyncSessionHandler : SyncSessionlessHandler, IRequiresSessionState {
        internal SyncSessionHandler(ServerProtocol protocol) : base(protocol) { }
    }

    internal class AsyncSessionlessHandler : SyncSessionlessHandler, IHttpAsyncHandler {

        internal AsyncSessionlessHandler(ServerProtocol protocol) : base(protocol) { }

        public IAsyncResult BeginProcessRequest(HttpContext context, AsyncCallback callback, object asyncState) {
            TraceMethod method = Tracing.On ? new TraceMethod(this, "BeginProcessRequest") : null;
            if (Tracing.On) Tracing.Enter("IHttpAsyncHandler.BeginProcessRequest", method, Tracing.Details(context.Request));

            IAsyncResult result = BeginCoreProcessRequest(callback, asyncState);

            if (Tracing.On) Tracing.Exit("IHttpAsyncHandler.BeginProcessRequest", method);

            return result;
        }

        public void EndProcessRequest(IAsyncResult asyncResult) {
            TraceMethod method = Tracing.On ? new TraceMethod(this, "EndProcessRequest") : null;
            if (Tracing.On) Tracing.Enter("IHttpAsyncHandler.EndProcessRequest", method);

            EndCoreProcessRequest(asyncResult);

            if (Tracing.On) Tracing.Exit("IHttpAsyncHandler.EndProcessRequest", method);
        }
    }

    internal class AsyncSessionHandler : AsyncSessionlessHandler, IRequiresSessionState {
        internal AsyncSessionHandler(ServerProtocol protocol) : base(protocol) { }
    }

    class CompletedAsyncResult : IAsyncResult {
        object asyncState;
        bool completedSynchronously;

        internal CompletedAsyncResult(object asyncState, bool completedSynchronously) {
            this.asyncState = asyncState;
            this.completedSynchronously = completedSynchronously;
        }

        public object AsyncState { get { return asyncState; } }
        public bool CompletedSynchronously { get { return completedSynchronously; } }
        public bool IsCompleted { get { return true; } }
        public WaitHandle AsyncWaitHandle { get { return null; } }
    }
}