// ****************************************************************************
// Copyright (C)  Microsoft Corporation.  All rights reserved.
//
// CONTENTS
//     Value-add wrapper on top of standard CLR monitor
// 

using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Globalization;
using System.Xml;
using System.Reflection;
using System.Threading;
using System.Diagnostics;
using System.Transactions;

using System.Workflow.Runtime.Hosting;

namespace System.Workflow.Runtime
{
    internal static class LockFactory
    {
        internal static InstanceLock CreateWorkflowExecutorLock(Guid id)
        {
            return new InstanceLock(id, "Workflow Executor Lock: " + id.ToString(), 50, LockPriorityOperator.GreaterThanOrReentrant);
        }

        internal static InstanceLock CreateWorkflowSchedulerLock(Guid id)
        {
            return new InstanceLock(id, "Workflow Scheduler Lock: " + id.ToString(), 40, LockPriorityOperator.GreaterThan);
        }

        internal static InstanceLock CreateWorkflowMessageDeliveryLock(Guid id)
        {
            return new InstanceLock(id, "Workflow Message Delivery Lock: " + id.ToString(), 35, LockPriorityOperator.GreaterThanOrReentrant);
        }
    }

    internal enum LockPriorityOperator
    {
        GreaterThan,
        GreaterThanOrReentrant,
    }

    internal sealed class InstanceLock 
    {
        #region Static Data/Methods

        [ThreadStaticAttribute()]
        private static List<InstanceLock> t_heldLocks = null;

        [Conditional("DEBUG")]
        internal static void AssertNoLocksHeld()
        {
#if DEBUG
            System.Diagnostics.Debug.Assert(HeldLocks.Count == 0, "No locks should be held.");
#endif
        }

        [Conditional("DEBUG")]
        internal static void AssertIsLocked(InstanceLock theLock)
        {
#if DEBUG
            System.Diagnostics.Debug.Assert(HeldLocks.Contains(theLock), "Lock should be held.");
#endif
        }

        private static List<InstanceLock> HeldLocks
        {
            get
            {
                List<InstanceLock> tLocks = InstanceLock.t_heldLocks;
                if (tLocks == null)
                {
                    InstanceLock.t_heldLocks = new List<InstanceLock>();
                    tLocks = InstanceLock.t_heldLocks;
                }
                return tLocks;
            }
        }

        #endregion Static Data/Methods

        private Guid m_instanceId;
        private String m_name;
        private int m_priority;
        private LockPriorityOperator m_operator;

        internal int Priority
        {
            get
            {
                return this.m_priority;
            }
        }

        internal LockPriorityOperator Operator
        {
            get
            {
                return this.m_operator;
            }
        }

        internal InstanceLock(Guid id, String name, int priority, LockPriorityOperator lockOperator)
        {
            this.m_instanceId = id;
            this.m_name = name;
            this.m_priority = priority;
            this.m_operator = lockOperator;
        }

        internal Guid InstanceId
        {
            get
            {
                return this.m_instanceId;
            }
        }

        internal InstanceLockGuard Enter()
        {
            return new InstanceLockGuard(this);
        }

        internal bool TryEnter()
        {
            InstanceLockGuard.EnforceGuard(this);

            bool lockHeld = false;
            bool success = false;
            try
            {
                Monitor.TryEnter(this, ref lockHeld);

                if (lockHeld)
                {
                    HeldLocks.Add(this);
                    success = true;
                }
            }
            finally
            {
                if (lockHeld && !success)
                {
                    Monitor.Exit(this);
                }
            }
            return success;
        }

        internal void Exit()
        {
            try
            {
                HeldLocks.Remove(this);
            }
            finally
            {
                Monitor.Exit(this);
            }
        }

        internal struct InstanceLockGuard : IDisposable
        {
            readonly InstanceLock m_lock;

            internal static void EnforceGuard(InstanceLock theLock)
            {
                foreach (InstanceLock heldLock in HeldLocks)
                {
                    switch (theLock.Operator)
                    {
                        case LockPriorityOperator.GreaterThan:
                            if (heldLock.InstanceId == theLock.InstanceId && heldLock.Priority <= theLock.Priority)
                                throw new InvalidOperationException(ExecutionStringManager.InstanceOperationNotValidinWorkflowThread);
                            break;

                        case LockPriorityOperator.GreaterThanOrReentrant:
                            // the checks here assume that locks have unique priorities
                            if (heldLock.InstanceId == theLock.InstanceId && heldLock.Priority < theLock.Priority)
                                throw new InvalidOperationException(ExecutionStringManager.InstanceOperationNotValidinWorkflowThread);
                            break;

                        default:
                            System.Diagnostics.Debug.Assert(false, "Unrecognized lock operator");
                            break;
                    }
                }
            }

            internal InstanceLockGuard(InstanceLock theLock)
            {
                this.m_lock = theLock;

                // Note: the following operations are logically atomic, but since the
                // list we are using is thread local there is no need to take a lock.

                EnforceGuard(theLock);

                try
                {
                }
                finally
                {
                    bool success = false;
#pragma warning disable 0618
//@
                    Monitor.Enter(this.m_lock);
#pragma warning restore 0618
                    try
                    {
                        HeldLocks.Add(this.m_lock);
                        success = true;
                    }
                    finally
                    {
                        if (!success)
                        {
                            Monitor.Exit(this.m_lock);
                        }
                    }
                }
            }

            internal void Pulse()
            {
                Monitor.Pulse(this.m_lock);
            }

            internal void Wait()
            {
                Monitor.Wait(this.m_lock);
            }

            public void Dispose()
            {
                // Note: the following operations are logically atomic, but since the
                // list we are using is thread local there is no need to take a lock.
                try
                {
                    HeldLocks.Remove(this.m_lock);
                }
                finally
                {
                    Monitor.Exit(this.m_lock);
                }
            }
        }
    }

    internal sealed class SchedulerLockGuard : IDisposable
    {
        private InstanceLock.InstanceLockGuard lg;
        private WorkflowExecutor workflowExec;

        internal SchedulerLockGuard(InstanceLock il, WorkflowExecutor w)
        {
            lg = il.Enter();
            workflowExec = w;
        }

        private static void FireEvents(List<SchedulerLockGuardInfo> eventList, WorkflowExecutor workflowExec)
        {
            if (!workflowExec.IsInstanceValid && (workflowExec.WorkflowStatus == WorkflowStatus.Completed || workflowExec.WorkflowStatus == WorkflowStatus.Terminated))
            {
                // The workflow is dead, let the instance have a hard ref to the corpse for support of the query apis.
                workflowExec.WorkflowInstance.DeadWorkflow = workflowExec;
            }
            for (int i = 0; i < eventList.Count; i++)
            {
                SchedulerLockGuardInfo eseg = eventList[i];
                // eseg.EventInfo is non-null only if the event type is Suspended or Terminated
                // If the event type is Suspended, then call FireWorkflowSuspended after casting
                //   the event argument to a String.
                // If the event type is Terminated, then call FireWorkflowTerminated after casting
                //   the event argument to either a String or an Exception.
                switch (eseg.EventType)
                {
                    case WorkflowEventInternal.Suspended:
                        workflowExec.FireWorkflowSuspended((String)eseg.EventInfo);
                        break;
                    case WorkflowEventInternal.Terminated:
                        if ((eseg.EventInfo as System.Exception) != null)
                        {
                            workflowExec.FireWorkflowTerminated((Exception)eseg.EventInfo);
                        }
                        else
                        {
                            workflowExec.FireWorkflowTerminated((String)eseg.EventInfo);
                        }
                        break;
                    default:
                        workflowExec.FireWorkflowExecutionEvent(eseg.Sender, eseg.EventType);
                        break;
                }
            }
        }

        internal static void Exit(InstanceLock il, WorkflowExecutor w)
        {
            List<SchedulerLockGuardInfo> eventList = new List<SchedulerLockGuardInfo>(w.EventsToFireList);
            w.EventsToFireList.Clear();
            il.Exit();
            FireEvents(eventList, w);
        }

        public void Dispose()
        {
            List<SchedulerLockGuardInfo> eventList = new List<SchedulerLockGuardInfo>(workflowExec.EventsToFireList);
            workflowExec.EventsToFireList.Clear();
            lg.Dispose();
            FireEvents(eventList, workflowExec);
        }
    }

    internal sealed class SchedulerLockGuardInfo
    {
        private Object sender;
        private WorkflowEventInternal eventType;
        private object eventInfo;

        internal SchedulerLockGuardInfo(Object _sender, WorkflowEventInternal _eventType)
        {
            sender = _sender;
            eventType = _eventType;
            eventInfo = null;
        }

        internal SchedulerLockGuardInfo(Object _sender, WorkflowEventInternal _eventType, object _eventInfo)
            : this(_sender, _eventType)
        {
            eventInfo = _eventInfo;
        }

        internal Object Sender
        {
            get
            {
                return sender;
            }
        }

        internal WorkflowEventInternal EventType
        {
            get
            {
                return eventType;
            }
        }

        internal Object EventInfo
        {
            get
            {
                return eventInfo;
            }
        }
    }
}