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

namespace System.Web.Util {

    using System.Runtime.InteropServices;
    using System.Security.Permissions;
    using System.Threading;

//
// Support for positing of work items to a different thread
//


/// <devdoc>
///    <para>[To be supplied.]</para>
/// </devdoc>
public delegate void WorkItemCallback();


/// <devdoc>
///    <para>[To be supplied.]</para>
/// </devdoc>
public class WorkItem {

    private static bool _useQueueUserWorkItem = true;
    private static WaitCallback _onQueueUserWorkItemCompletion = new WaitCallback(OnQueueUserWorkItemCompletion);


    /// <devdoc>
    ///    <para>[To be supplied.]</para>
    /// </devdoc>

    [SecurityPermission(SecurityAction.Demand, Unrestricted=true)]
    public static void Post(WorkItemCallback callback) {
#if !FEATURE_PAL // ROTORTODO
        if (Environment.OSVersion.Platform != PlatformID.Win32NT)
            throw new PlatformNotSupportedException(SR.GetString(SR.RequiresNT));
#else // !FEATURE_PAL
        throw new NotImplementedException("ROTORTODO");
#endif // !FEATURE_PAL
        PostInternal(callback);
    }

    // assert to disregard the user code up the compressed stack
    [PermissionSet(SecurityAction.Assert, Unrestricted=true)]
    private static void CallCallbackWithAssert(WorkItemCallback callback) {
        callback();
    }

    private static void OnQueueUserWorkItemCompletion(Object state) {
        WorkItemCallback callback = state as WorkItemCallback;

        if (callback != null) {
            CallCallbackWithAssert(callback);
        }
    }

    internal static void PostInternal(WorkItemCallback callback) {
        if (_useQueueUserWorkItem) {
            ThreadPool.QueueUserWorkItem(_onQueueUserWorkItemCompletion, callback);
        }
        else {
            WrappedWorkItemCallback w = new WrappedWorkItemCallback(callback);
            w.Post();
        }
    }
}

internal class WrappedWorkItemCallback {
    private GCHandle         _rootedThis;
    private WorkItemCallback _originalCallback;
    private WorkItemCallback _wrapperCallback;

    internal WrappedWorkItemCallback(WorkItemCallback callback) {
        _originalCallback = callback;
        _wrapperCallback = new WorkItemCallback(this.OnCallback);
    }

    internal void Post() {
        _rootedThis = GCHandle.Alloc(this);

        if (UnsafeNativeMethods.PostThreadPoolWorkItem(_wrapperCallback) != 1) {
            _rootedThis.Free();
            throw new HttpException(SR.GetString(SR.Cannot_post_workitem));
        }
    }

    private void OnCallback() {
        _rootedThis.Free();
        _originalCallback();
    }
}

}