using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Text;
using System.Xml;
using System.Xml.Schema;
using System.IO;
using System.Reflection;
using System.Diagnostics;
using System.Runtime.Serialization;
using System.Security.Permissions;
using System.Globalization;

//using System.Workflow.Activities;
using System.Workflow.ComponentModel;
using System.Workflow.Runtime;
using System.Workflow.Runtime.Hosting;
using Hosting = System.Workflow.Runtime.Hosting;

namespace System.Workflow.Runtime.Tracking
{
    /// <summary>
    /// Contains data that is used to match instance locations.
    /// </summary>
    [Serializable]
    [Obsolete("The System.Workflow.* types are deprecated.  Instead, please use the new types from System.Activities.*")]
    public sealed class WorkflowTrackingLocation
    {
        #region Private Data Members

        private IList<TrackingWorkflowEvent> _events = new List<TrackingWorkflowEvent>();

        #endregion

        #region Constructors

        public WorkflowTrackingLocation()
        {
        }

        public WorkflowTrackingLocation(IList<TrackingWorkflowEvent> events)
        {
            _events = events;
        }
        #endregion

        #region Public Properties

        public IList<TrackingWorkflowEvent> Events
        {
            get { return _events; }
        }

        #endregion

        #region Internal Matching Methods

        internal bool Match(TrackingWorkflowEvent status)
        {
            return _events.Contains(status);
        }

        #endregion
    }

    /// <summary>
    /// Contains data that is used to match activity locations.
    /// </summary>
    [Serializable]
    [Obsolete("The System.Workflow.* types are deprecated.  Instead, please use the new types from System.Activities.*")]
    public sealed class ActivityTrackingLocation
    {
        #region Private Data Members

        private TrackingConditionCollection _conditions = new TrackingConditionCollection();
        private List<ActivityExecutionStatus> _events = new List<ActivityExecutionStatus>();
        private Type _activityType = null;
        private string _activityName = null;
        private bool _trackDerived = false;

        #endregion

        #region Constructors

        public ActivityTrackingLocation()
        {
        }

        public ActivityTrackingLocation(string activityTypeName)
        {
            if (null == activityTypeName)
                throw new ArgumentNullException("activityTypeName");

            _activityName = activityTypeName;
        }

        public ActivityTrackingLocation(Type activityType)
        {
            if (null == activityType)
                throw new ArgumentNullException("activityType");

            _activityType = activityType;
        }

        public ActivityTrackingLocation(string activityTypeName, IEnumerable<ActivityExecutionStatus> executionStatusEvents)
        {
            if (null == activityTypeName)
                throw new ArgumentNullException("activityTypeName");

            if (null == executionStatusEvents)
                throw new ArgumentNullException("executionStatusEvents");

            _activityName = activityTypeName;
            _events.AddRange(executionStatusEvents);
        }

        public ActivityTrackingLocation(Type activityType, IEnumerable<ActivityExecutionStatus> executionStatusEvents)
        {
            if (null == activityType)
                throw new ArgumentNullException("activityType");

            if (null == executionStatusEvents)
                throw new ArgumentNullException("executionStatusEvents");

            _activityType = activityType;
            _events.AddRange(executionStatusEvents);
        }

        public ActivityTrackingLocation(string activityTypeName, bool matchDerivedTypes, IEnumerable<ActivityExecutionStatus> executionStatusEvents)
        {
            if (null == activityTypeName)
                throw new ArgumentNullException("activityTypeName");

            if (null == executionStatusEvents)
                throw new ArgumentNullException("executionStatusEvents");

            _activityName = activityTypeName;
            _trackDerived = matchDerivedTypes;
            _events.AddRange(executionStatusEvents);
        }

        public ActivityTrackingLocation(Type activityType, bool matchDerivedTypes, IEnumerable<ActivityExecutionStatus> executionStatusEvents)
        {
            if (null == activityType)
                throw new ArgumentNullException("activityType");

            if (null == executionStatusEvents)
                throw new ArgumentNullException("executionStatusEvents");

            _activityType = activityType;
            _trackDerived = matchDerivedTypes;
            _events.AddRange(executionStatusEvents);
        }

        #endregion

        #region Public Properties

        public Type ActivityType
        {
            get { return _activityType; }
            set { _activityType = value; }
        }

        public string ActivityTypeName
        {
            get { return _activityName; }
            set { _activityName = value; }
        }

        public bool MatchDerivedTypes
        {
            get { return _trackDerived; }
            set { _trackDerived = value; }
        }

        public IList<ActivityExecutionStatus> ExecutionStatusEvents
        {
            get { return _events; }
        }

        public TrackingConditionCollection Conditions
        {
            get { return _conditions; }
        }

        #endregion

        #region Internal Matching Methods

        internal bool Match(Activity activity, bool typeMatchOnly)
        {
            if (null == activity)
                throw new ArgumentNullException("activity");
            //
            // Matching the type is generally going to be cheaper 
            // so do it first and short circuit if we don't match
            if (!TypeIsMatch(activity))
            {
                return false;
            }
            else
            {
                if (typeMatchOnly)
                {
                    return true;
                }
                else
                {
                    return ConditionsAreMatch(activity);
                }
            }
        }

        #endregion

        #region Private Matching Methods

        private bool TypeIsMatch(Activity activity)
        {
            if (null != _activityType)
                return TypeMatch.IsMatch(activity, _activityType, _trackDerived);
            else
                return TypeMatch.IsMatch(activity, _activityName, _trackDerived);
        }

        private bool ConditionsAreMatch(object obj)
        {
            //
            // If any condition doesn't match the location doesn't match
            foreach (TrackingCondition c in _conditions)
                if (!c.Match(obj))
                    return false;
            //
            // All conditions match
            return true;
        }

        #endregion
    }

    /// <summary>
    /// Contains data that is used to match code locations.
    /// </summary>
    [Serializable]
    [Obsolete("The System.Workflow.* types are deprecated.  Instead, please use the new types from System.Activities.*")]
    public sealed class UserTrackingLocation
    {
        #region Private Data Members

        private string _keyName = null;

        private Type _argType = null;
        private string _argName = null;
        private bool _trackDerivedArgs = false;

        private Type _activityType = null;
        private string _activityName = null;
        private bool _trackDerivedActivities = false;

        private TrackingConditionCollection _conditions = new TrackingConditionCollection();

        #endregion

        #region Constructors

        public UserTrackingLocation()
        {
        }

        public UserTrackingLocation(Type argumentType)
        {
            _argType = argumentType;
        }

        public UserTrackingLocation(Type argumentType, Type activityType)
        {
            _argType = argumentType;
            _activityType = activityType;
        }

        public UserTrackingLocation(Type argumentType, string activityTypeName)
        {
            _argType = argumentType;
            _activityName = activityTypeName;
        }

        public UserTrackingLocation(string argumentTypeName)
        {
            _argName = argumentTypeName;
        }

        public UserTrackingLocation(string argumentTypeName, string activityTypeName)
        {
            _argName = argumentTypeName;
            _activityName = activityTypeName;
        }

        public UserTrackingLocation(string argumentTypeName, Type activityType)
        {
            _argName = argumentTypeName;

            _activityType = activityType;
        }

        #endregion

        #region Public Properties

        public string KeyName
        {
            get { return _keyName; }
            set { _keyName = value; }
        }

        public Type ArgumentType
        {
            get { return _argType; }
            set { _argType = value; }
        }

        public string ArgumentTypeName
        {
            get { return _argName; }
            set { _argName = value; }
        }

        public bool MatchDerivedArgumentTypes
        {
            get { return _trackDerivedArgs; }
            set { _trackDerivedArgs = value; }
        }

        public Type ActivityType
        {
            get { return _activityType; }
            set { _activityType = value; }
        }

        public string ActivityTypeName
        {
            get { return _activityName; }
            set { _activityName = value; }
        }

        public bool MatchDerivedActivityTypes
        {
            get { return _trackDerivedActivities; }
            set { _trackDerivedActivities = value; }
        }

        public TrackingConditionCollection Conditions
        {
            get { return _conditions; }
        }

        #endregion

        #region Internal Matching Methods

        internal bool Match(Activity activity)
        {
            if (!ActTypeIsMatch(activity))
                return false;
            else
                return ConditionsAreMatch(activity);
        }

        internal bool Match(Activity activity, string keyName, object arg)
        {
            return RuntimeMatch(activity, keyName, arg);
        }

        #endregion

        #region Private Matching Methods

        private bool ActTypeIsMatch(Activity activity)
        {
            if (null != _activityType)
                return TypeMatch.IsMatch(activity, _activityType, _trackDerivedActivities);
            else
                return TypeMatch.IsMatch(activity, _activityName, _trackDerivedActivities);
        }

        private bool RuntimeMatch(Activity activity, string keyName, object obj)
        {
            //
            // Check the excludes - if any exclude matches based on activity only we're not a match
            if (!ActTypeIsMatch(activity))
                return false;
            //
            // Check the name of the key, null means match all
            if (null != _keyName)
            {
                if (0 != String.Compare(_keyName, keyName, StringComparison.Ordinal))
                {
                    return false;
                }
            }

            if (null != _argType)
                return TypeMatch.IsMatch(obj, _argType, _trackDerivedArgs);
            else
                return TypeMatch.IsMatch(obj, _argName, _trackDerivedArgs);
        }

        private bool ConditionsAreMatch(object obj)
        {
            //
            // If any condition doesn't match the location doesn't match
            foreach (TrackingCondition c in _conditions)
                if (!c.Match(obj))
                    return false;
            //
            // All conditions match
            return true;
        }


        #endregion
    }

    internal sealed class TypeMatch
    {
        private TypeMatch() { }

        internal static bool IsMatch(object obj, string name, bool matchDerived)
        {
            Type objType = obj.GetType();
            if (0 == string.Compare(objType.Name, name, StringComparison.Ordinal))
            {
                return true;
            }
            else
            {
                //
                // If we're not checking base types we're done
                if (!matchDerived)
                    return false;
                //
                // Check interfaces (case sensitive)
                // This checks all interfaces (including interfaces on base types )
                if (null != objType.GetInterface(name))
                    return true;
                //
                // Walk down the base types and look for a match
                Type b = objType.BaseType;
                while (b != null)
                {
                    if (0 == string.Compare(b.Name, name, StringComparison.Ordinal))
                        return true;

                    b = b.BaseType;
                }
                return false;
            }
        }

        internal static bool IsMatch(object obj, Type matchType, bool matchDerived)
        {
            Type objType = obj.GetType();
            //
            // First check if the type is a direct match.  
            // Can't just use Type.IsInstanceOfType at this point because that matches bases and interfaces.
            // If not then use IsInstanceOfType to check bases and interfaces if we are matching derived
            if (objType == matchType)
                return true;
            else
            {
                if (matchDerived)
                    return matchType.IsInstanceOfType(obj);
                else
                    return false;
            }
        }
    }
}