/// <summary>
 /// 
 /// </summary>
 /// <param name="level"></param>
 /// <param name="message"></param>
 public static void CheckAspNetPermission(AspNetHostingPermissionLevel level, string message)
 {
     if (!HasAspNetPermission(level))
     {
         throw new HttpException(message);
     }
 }

		// LinkDemand

		public override object CreateControl (SecurityAction action, AspNetHostingPermissionLevel level)
		{
			// no public ctor is available but we know the Count property isn't protected
			MethodInfo mi = this.Type.GetProperty ("Count").GetGetMethod ();
			Assert.IsNotNull (mi, "Count");
			return mi.Invoke (css, null);
		}

		// LinkDemand

		public override object CreateControl (SecurityAction action, AspNetHostingPermissionLevel level)
		{
			// no public ctor is available but we know that it's properties don't have any restrictions
			MethodInfo mi = this.Type.GetProperty ("AcceptTypes").GetGetMethod ();
			Assert.IsNotNull (mi, "get_AcceptTypes");
			return mi.Invoke (response.Cache.VaryByHeaders, null);
		}

		// LinkDemand

		public override object CreateControl (SecurityAction action, AspNetHostingPermissionLevel level)
		{
			// no public ctor but we know the properties aren't protected
			MethodInfo mi = this.Type.GetProperty ("Visible").GetGetMethod ();
			Assert.IsNotNull (mi, "Visible");
			return mi.Invoke (pager_style, null);
		}

		private object CreateControlStringCtor (SecurityAction action, AspNetHostingPermissionLevel level)
		{
			// not public empty (default) ctor - at least not before 2.0
			ConstructorInfo ci = this.Type.GetConstructor (new Type[1] { typeof (string) });
			Assert.IsNotNull (ci, ".ctor(string)");
			return ci.Invoke (new object[1] { tempFile });
		}

		public override object CreateControl (SecurityAction action, AspNetHostingPermissionLevel level)
		{
			if ((level != AspNetHostingPermissionLevel.None) && (action == SecurityAction.PermitOnly))
				return UnmanagedCreateControl (action, level);
			else
				return base.CreateControl (action, level);
		}

		// LinkDemand

		public override object CreateControl (SecurityAction action, AspNetHostingPermissionLevel level)
		{
			// static class 2.0 / no public ctor before (1.x)
			MethodInfo mi = this.Type.GetMethod ("EnumToString");
			Assert.IsNotNull (mi, "EnumToString");
			return mi.Invoke (null, new object[2] { typeof(SecurityAction), SecurityAction.Demand });
		}

 public override void FromXml(SecurityElement securityElement)
 {
     if (securityElement == null)
     {
         throw new ArgumentNullException(SR.GetString("AspNetHostingPermissionBadXml", new object[] { "securityElement" }));
     }
     if (!securityElement.Tag.Equals("IPermission"))
     {
         throw new ArgumentException(SR.GetString("AspNetHostingPermissionBadXml", new object[] { "securityElement" }));
     }
     string str = securityElement.Attribute("class");
     if (str == null)
     {
         throw new ArgumentException(SR.GetString("AspNetHostingPermissionBadXml", new object[] { "securityElement" }));
     }
     if (str.IndexOf(base.GetType().FullName, StringComparison.Ordinal) < 0)
     {
         throw new ArgumentException(SR.GetString("AspNetHostingPermissionBadXml", new object[] { "securityElement" }));
     }
     if (string.Compare(securityElement.Attribute("version"), "1", StringComparison.OrdinalIgnoreCase) != 0)
     {
         throw new ArgumentException(SR.GetString("AspNetHostingPermissionBadXml", new object[] { "version" }));
     }
     string str3 = securityElement.Attribute("Level");
     if (str3 == null)
     {
         this._level = AspNetHostingPermissionLevel.None;
     }
     else
     {
         this._level = (AspNetHostingPermissionLevel) Enum.Parse(typeof(AspNetHostingPermissionLevel), str3);
     }
 }

		/// <summary>
		/// Get the current trust level of the hosted application
		/// </summary>
		/// <returns></returns>
		public static AspNetHostingPermissionLevel GetCurrentTrustLevel()
		{
		    if (_knowTrustLevel) return _trustLevel;

			foreach (var trustLevel in new[] {
			                                 	AspNetHostingPermissionLevel.Unrestricted,
			                                 	AspNetHostingPermissionLevel.High,
			                                 	AspNetHostingPermissionLevel.Medium,
			                                 	AspNetHostingPermissionLevel.Low,
			                                 	AspNetHostingPermissionLevel.Minimal })
			{
				try
				{
					new AspNetHostingPermission(trustLevel).Demand();
				}
				catch (SecurityException)
				{
					continue;
				}

                _trustLevel = trustLevel;
			    _knowTrustLevel = true;
			    return _trustLevel;
			}

			_trustLevel = AspNetHostingPermissionLevel.None;
            _knowTrustLevel = true;
            return _trustLevel;
        }

		// LinkDemand

		public override object CreateControl (SecurityAction action, AspNetHostingPermissionLevel level)
		{
			ConstructorInfo ci = this.Type.GetConstructor (new Type[7] { typeof (string), typeof (string),
				typeof (int), typeof (string), typeof (string), typeof (string), typeof (BuildMethod) });
			Assert.IsNotNull (ci, ".ctor(2xstring,int,3xstring,BuildMethod)");
			return ci.Invoke (new object[7] { null, null, null, null, null, null, null });
		}

		public AspNetHostingPermission (PermissionState state)
		{
			if (PermissionHelper.CheckPermissionState (state, true) == PermissionState.Unrestricted)
				_level = AspNetHostingPermissionLevel.Unrestricted;
			else
				_level = AspNetHostingPermissionLevel.None;
		}

		// LinkDemand

		public override object CreateControl (SecurityAction action, AspNetHostingPermissionLevel level)
		{
			// there are no public ctor so we're taking a method that we know isn't protected
			// (by a Demand) and call it thru reflection so any linkdemand (on the class) will
			// be promoted to a Demand
			MethodInfo mi = this.Type.GetProperty ("AllKeys").GetGetMethod ();
			return mi.Invoke (appstate, null);
		}

	public AspNetHostingPermission(PermissionState state)
			{
				if(state == PermissionState.Unrestricted)
				{
					this.level = AspNetHostingPermissionLevel.Unrestricted;
				}
				else
				{
					this.level = AspNetHostingPermissionLevel.None;
				}
			}

 public bool HasTrustLevel(AspNetHostingPermissionLevel level)
 {
     bool hasTrustLevel = true;
     try {
         new AspNetHostingPermission(level).Demand();
     }
     catch (SecurityException) {
         hasTrustLevel = false;
     }
     return hasTrustLevel;
 }

		public override object CreateControl (SecurityAction action, AspNetHostingPermissionLevel level)
		{
			if ((level != AspNetHostingPermissionLevel.None) && (action == SecurityAction.PermitOnly)) {
				try {
					return FileIOPermissionCreateControl (action, level);
				}
				catch (TargetInvocationException tie) {
					throw tie;
				}
			} 
			else
				return CreateControlStringCtor (action, level);
		}

        static internal void VerifyAspNetHostingPermissionLevel(AspNetHostingPermissionLevel level, string arg) {
            switch (level) {
            case AspNetHostingPermissionLevel.Unrestricted:
            case AspNetHostingPermissionLevel.High:
            case AspNetHostingPermissionLevel.Medium:
            case AspNetHostingPermissionLevel.Low:
            case AspNetHostingPermissionLevel.Minimal:
            case AspNetHostingPermissionLevel.None:
                break;

            default:
                throw new ArgumentException(arg);
            }
        }

        public AspNetHostingPermission(PermissionState state)
        {
            switch (state)
            {
                case PermissionState.None:
                    this._level = AspNetHostingPermissionLevel.None;
                    return;

                case PermissionState.Unrestricted:
                    this._level = AspNetHostingPermissionLevel.Unrestricted;
                    return;
            }
            throw new ArgumentException(SR.GetString("InvalidArgument", new object[] { state.ToString(), "state" }));
        }

		public override object CreateControl (SecurityAction action, AspNetHostingPermissionLevel level)
		{
			// the ctor NRE makes it more complex
			try {
				return base.CreateControl (action, level);
			}
			catch (TargetInvocationException tie) {
				// we really checking for security exceptions that occurs before a NRE can occurs
				if (tie.InnerException is NullReferenceException)
					return String.Empty;
				else
					return null;
			}
		}

        /// <summary>
        /// 
        /// </summary>
        /// <param name="level"></param>
        /// <returns></returns>
        public static bool HasAspNetPermission(AspNetHostingPermissionLevel level)
        {
            var set = HttpRuntime.GetNamedPermissionSet();

            if (set == null)
            {
                return true;
            }

            var permission = (AspNetHostingPermission)set.GetPermission(typeof(AspNetHostingPermission));

            if (null == permission)
            {
                return false;
            }

            return permission.Level >= level;
        }

        private static string _shadowDirectory = "~/Plugins/loaded"; //this is set in web.config as probe path //used only for medium trust

        #endregion Fields

        #region Constructors

        static PluginEngine()
        {
            TrustLevel = ServerHelper.GetCurrentTrustLevel();
            if (TrustLevel == AspNetHostingPermissionLevel.Unrestricted)
            {
                _shadowDirectory = AppDomain.CurrentDomain.DynamicDirectory;
                ShadowDirectory = new DirectoryInfo(_shadowDirectory);
            }
            else
            {
                ShadowDirectory = new DirectoryInfo(HostingEnvironment.MapPath(_shadowDirectory));

            }

            PluginsDirectory = new DirectoryInfo(HostingEnvironment.MapPath(_pluginsDirectory));

            Plugins = new List<PluginInfo>();
        }