/// <summary>
 /// Initializes a new instance of the ProfilingDialog class
 /// </summary>
 /// <param name="item"></param>
 /// <param name="resourceId"></param>
 /// <param name="connection"></param>
 public ProfilingDialog(IResource item, string resourceId, IServerConnection connection)
     : this()
 {
     m_connection = connection;
     m_item = item;
     m_resourceId = resourceId;
 }

 /// <summary>
 /// Initializes a new instance of the Location class.
 /// </summary>
 /// <param name="resource"></param>
 /// <param name="source"></param>
 public Location(IResource resource, object source)
 {
     //TODO: look into re-enabling this since resource *is* NULL when parsing config classes vs. acquiring IResources
     //AssertUtils.ArgumentNotNull(resource, "resource");
     this.resource = resource;
     this.source = source;
 }

 /// <summary>
 /// Create an encoded resource using the specified encoding.
 /// </summary>
 /// <param name="resource">the resource to read from. Must not be <c>null</c></param>
 /// <param name="encoding">the encoding to use. If <c>null</c>, encoding will be autodetected.</param>
 /// <param name="autoDetectEncoding">whether to autoDetect encoding from byte-order marks (<see cref="StreamReader(Stream, Encoding, bool)"/>)</param>
 public EncodedResource(IResource resource, Encoding encoding, bool autoDetectEncoding)
 {
     AssertUtils.ArgumentNotNull(resource, "resource");
     this.resource = resource;
     this.encoding = encoding;
     this.autoDetectEncoding = autoDetectEncoding;
 }

        /// <summary>
        /// Validats the specified resources for common issues associated with this
        /// resource type
        /// </summary>
        /// <param name="context"></param>
        /// <param name="resource"></param>
        /// <param name="recurse"></param>
        /// <returns></returns>
        public virtual ValidationIssue[] Validate(ResourceValidationContext context, IResource resource, bool recurse)
        {
            if (!resource.GetResourceTypeDescriptor().Equals(this.SupportedResourceAndVersion))
                return null;

            return ValidateBase(context, resource, recurse);
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="AbstractInterpreter"/> class
        /// from an The <see cref="IResource"/>.
        /// </summary>
        /// <param name="source">The <see cref="IResource"/>.</param>
        public AbstractInterpreter(IResource source)
        {
            Contract.Require.That(source, Is.Not.Null).When("retrieving argument IResource in AbstractInterpreter constructor");

            resource = source;

        }

		private string GetURLInternal(IResource resource)
		{
			IResourceLocation location = resource.Location;
			string path;
			if (location is TypeLocation)
			{
				TypeLocation tl = location as TypeLocation;
				path = String.Format("{2}/{3}{0}/{1}{4}", HttpUtility.UrlPathEncode(tl.ProxyType.Assembly.GetName().Name), HttpUtility.UrlPathEncode(tl.ProxyType.FullName), AppPath, ResourceHttpHandler.AssemblyPath, ResourceHttpHandler.Extension);
			}
			else if (location is EmbeddedLocation)
			{
				EmbeddedLocation el = location as EmbeddedLocation;
				path = String.Format("{2}/{3}{0}/{1}{4}", HttpUtility.UrlPathEncode(el.Assembly.GetName().Name), HttpUtility.UrlPathEncode(el.ResourceName), AppPath, ResourceHttpHandler.AssemblyPath, ResourceHttpHandler.Extension);
			}
			else if (location is VirtualPathLocation)
			{
				VirtualPathLocation vl = location as VirtualPathLocation;
				path = HttpUtility.UrlPathEncode(vl.VirtualPath);
				if (resource is IProxyResource) path += ResourceHttpHandler.Extension;
			}
			else if (location is ExternalLocation)
			{
				ExternalLocation el = location as ExternalLocation;
				return el.Uri.ToString();
			}
			else
				throw new Exception("Unknown IResourceLocationType");
			return path + "?" + ToHex(resource.Version);
		}

 public override void DecorateClass(IResource resource,
                           IMethod request,
                           CodeTypeDeclaration requestClass,
                           CodeTypeDeclaration resourceClass)
 {
     requestClass.Members.Add(CreateRequiredConstructor(resourceClass, request, false));
 }

 private void listViewModels_SelectedIndexChanged(object sender, EventArgs e)
 {
     if (listViewModels.SelectedItems.Count > 0)
     {
         selectedItem = (IResource)listViewModels.SelectedItems[0].Tag;
     }
 }

		/// <summary>
		/// Parses a script from the specified resource.
		/// </summary>
		/// <param name="context">The <see cref="IMansionContext"/>.</param>
		/// <param name="resource">The resource wcich to parse as script.</param>
		/// <returns>Returns the parsed script.</returns>
		/// <exception cref="ParseScriptException">Thrown when an exception occurres while parsing the script.</exception>
		public IExpressionScript Parse(IMansionContext context, IResource resource)
		{
			// validate arguments
			if (context == null)
				throw new ArgumentNullException("context");
			if (resource == null)
				throw new ArgumentNullException("resource");

			// open the script
			var cacheKey = ResourceCacheKey.Create(resource);
			return cachingService.GetOrAdd(
				context,
				cacheKey,
				() =>
				{
					// get the phrase
					string rawPhrase;
					using (var resourceStream = resource.OpenForReading())
					using (var reader = resourceStream.Reader)
						rawPhrase = reader.ReadToEnd();

					// let someone else do the heavy lifting
					var phrase = ParsePhrase(context, rawPhrase);

					// create the cache object
					return new CachedPhrase(phrase);
				});
		}

 public bool LoadMidi(IResource midiFile)
 {
     if (playing == true)
         return false;
     LoadMidiFile(new MidiFile(midiFile));
     return true;
 }

        /// <summary>
        /// Strips for ship.
        /// </summary>
        /// <param name="resource">The resource.</param>
        /// <returns></returns>
        public SerializableResource SerializeResourceForStudio(IResource resource)
        {

            // convert the fliping errors due to json issues in c# ;(
            var errors = new List<ErrorInfo>();
            var parseErrors = resource.Errors;
            if(parseErrors != null)
            {
                errors.AddRange(parseErrors.Select(error => (error as ErrorInfo)));
            }

            var datalist = "<DataList></DataList>";

            if(resource.DataList != null)
            {
                var replace = resource.DataList.Replace("\"", GlobalConstants.SerializableResourceQuote);
                datalist = replace.Replace("'", GlobalConstants.SerializableResourceSingleQuote).ToString();
            }

            return new SerializableResource
            {
                Inputs = resource.Inputs,
                Outputs = resource.Outputs,
                ResourceCategory = resource.ResourcePath,
                ResourceID = resource.ResourceID,
                VersionInfo = resource.VersionInfo,
                ResourceName = resource.ResourceName,
                Permissions = AuthorizationService.GetResourcePermissions(resource.ResourceID),
                ResourceType = resource.ResourceType,
                IsValid = resource.IsValid,
                DataList = datalist,
                Errors = errors,
                IsNewResource = resource.IsNewResource
            };
        }

 public Spec ThrowsSecurityExceptionIfUserIsNotLoggedOn(string input, IResource output)
 {
     return
         new Spec()
         .If(UserIsNotLoggedOn)
         .Throws<SecurityException>();
 }

 public void LoadBank(IResource bankFile)
 {
     if (!bankFile.ReadAllowed())
         throw new Exception("The bank file provided does not have read access.");
     bank.Clear();
     assets.PatchAssetList.Clear();
     assets.SampleAssetList.Clear();
     bankName = string.Empty;
     comment = string.Empty;
     switch (IOHelper.GetExtension(bankFile.GetName()).ToLower())
     {
         case ".bank":
             bankName = IOHelper.GetFileNameWithoutExtension(bankFile.GetName());
             LoadMyBank(bankFile.OpenResourceForRead());
             break;
         case ".sf2":
             bankName = "SoundFont";
             LoadSf2(bankFile.OpenResourceForRead());
             break;
         default:
             throw new Exception("Invalid bank resource was provided. An extension must be included in the resource name.");
     }
     assets.PatchAssetList.TrimExcess();
     assets.SampleAssetList.TrimExcess();
 }

        public void DecorateClass(IResource resource,
            string className,
            CodeTypeDeclaration resourceClass,
            ResourceClassGenerator generator,
            string serviceClassName,
            IEnumerable<IResourceDecorator> allDecorators)
        {
            var gen = new ResourceGenerator(className, objectTypeProvider, commentCreator);
            foreach (var method in resource.Methods.Values)
            {
                logger.Debug("Adding RequestObject Method {0}.{1}", resource.Name, method.Name);

                // Add the default request method to the class:
                CodeTypeMember convenienceMethod = gen.CreateMethod(resourceClass, resource, method, false);
                if (convenienceMethod != null)
                {
                    resourceClass.Members.Add(convenienceMethod);
                }

                // Add the request method specifiying all parameters (also optional ones) to the class:
                if (AddOptionalParameters && method.HasOptionalParameters())
                {
                    convenienceMethod = gen.CreateMethod(resourceClass, resource, method, true);
                    if (convenienceMethod != null)
                    {
                        resourceClass.Members.Add(convenienceMethod);
                    }
                }
            }
        }

        private static void ConvertRecursively(IResource currentResource, JObject node, JsonSerializer serializer)
        {
            if (currentResource == null)
            {
                return;
            }

            var currentResourceType = currentResource.GetType();
            var readableProperties = GetReadablePropertyInfos(currentResourceType);

            var nonResourceProperties = readableProperties.Where(IsNeitherResourceOrReservedProperty).ToList();
            var resourceProperties = readableProperties.Where(IsResourceProperty).ToList();

            node.Add(ReservedPropertyNames.Relations, JObject.FromObject(currentResource.Relations, serializer));
            var embeddedResourceObject = new JObject();
            node.Add(ReservedPropertyNames.EmbeddedResources, embeddedResourceObject);

            foreach (var resourceProperty in resourceProperties)
            {                
                var embeddedResourceNodeValue = new JObject();

                ConvertRecursively((IResource)resourceProperty.GetValue(currentResource), embeddedResourceNodeValue, serializer);
                embeddedResourceObject.Add(ToCamelCase(resourceProperty.Name), embeddedResourceNodeValue);
            }

            if (IsCollectionResourceType(currentResourceType))
            {
                var currentResourceDynamic = (dynamic) currentResource;
                var jArray = new JArray();
                string name = "";
                foreach (IResource resourceItem in currentResourceDynamic.Items)
                {
                    var embeddedResourceNodeValue = new JObject();
                    ConvertRecursively(resourceItem, embeddedResourceNodeValue, serializer);
                    jArray.Add(embeddedResourceNodeValue);
                    name =  resourceItem.GetType().Name;
                }

                // Remove the "Resource" by convention.
                if (name.EndsWith("Resource"))
                {
                    name = name.Remove(name.LastIndexOf("Resource", StringComparison.Ordinal));
                }

                embeddedResourceObject.Add(ToCamelCase(name), jArray);
            }

            foreach (var nonResourceProperty in nonResourceProperties)
            {
                var value = nonResourceProperty.GetValue(currentResource);
                if (value != null && value.GetType().GetTypeInfo().IsClass && value.GetType() != typeof(string))
                {
                    node.Add(ToCamelCase(nonResourceProperty.Name), JToken.FromObject(value, serializer));
                }
                else
                {
                    node.Add(ToCamelCase(nonResourceProperty.Name), new JValue(value));
                }                
            }
        }

		public string GetURL(IResource resource)
		{
			string url;
			_lock.AcquireReaderLock(3000);
			try
			{
				if (!_urlCache.TryGetValue(resource, out url))
				{
					var c = _lock.UpgradeToWriterLock(3000);
					try
					{
						_urlCache.Add(resource, url = GetURLInternal(resource));
					}
					finally
					{
						_lock.DowngradeFromWriterLock(ref c);
					}
				}
			}
			finally
			{
				_lock.ReleaseReaderLock();
			}
			IProxyResource pr = resource as IProxyResource;
			if (!(resource.Location is ExternalLocation) && pr != null && (pr.CultureSensitive || pr.CultureUISensitive))
			{
				url += "-";
				if (pr.CultureSensitive)
					url += CultureInfo.CurrentCulture.LCID.ToString("x");
				url += "-";
				if (pr.CultureUISensitive)
					url += CultureInfo.CurrentCulture.LCID.ToString("x");
			}
			return url;
		}

        public HtmlProxy(FileLocation location)
		{
            _includes = new IResource[0];
            _references = _builds = _includes;
			_location = location;
			_version = ChecksumHelper.GetCombinedChecksum(location.Version, _includes, _builds);
		}

        public string Upload(IResource resource, string storeName)
        {
            // Authenticate the application (if not authenticated) and load the OAuth token
            // if (!File.Exists(OAuthTokenFileName))
            // {
            //     AuthorizeAppOAuth(dropboxServiceProvider);
            // }

            // OAuthToken oauthAccessToken = LoadOAuthToken();

            // Login in Dropbox
            IDropbox dropbox = this.dropboxServiceProvider
                .GetApi(AuthorizationConstants.DropBoxOAuthAccessTokenValue, AuthorizationConstants.DropBoxOAuthAccessTokenSecret);

            // Display user name (from his profile)
            DropboxProfile profile = dropbox.GetUserProfileAsync().Result;

            // Upload a file
            Entry uploadFileEntry = dropbox.UploadFileAsync(resource, storeName).Result;

            // Share a file
            DropboxLink sharedUrl = dropbox.GetShareableLinkAsync(uploadFileEntry.Path).Result;

            var link = dropbox.GetMediaLinkAsync(uploadFileEntry.Path).Result;
            return link.Url;
        }

		public XmlNode Process(IResource resource)
		{
			try
			{
				using (resource)
				{
					var doc = new XmlDocument();
					using (var stream = resource.GetStreamReader())
					{
						doc.Load(stream);
					}

					engine.PushResource(resource);

					var element = Process(doc.DocumentElement);

					engine.PopResource();

					return element;
				}
			}
			catch (ConfigurationProcessingException)
			{
				throw;
			}
			catch (Exception ex)
			{
				var message = String.Format("Error processing node resource {0}", resource);

				throw new ConfigurationProcessingException(message, ex);
			}
		}

		public virtual void Enlist(IResource resource)
		{
			logger.DebugFormat("Enlisting resource {0}", resource);

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

			// We can't add the resource more than once
			if (resources.Contains(resource)) return;

			if (Status == TransactionStatus.Active)
			{
				try
				{
					resource.Start();
				}
				catch(Exception ex)
				{
					state = TransactionStatus.Invalid;

					logger.Error("Enlisting resource failed", ex);

					throw;
				}
			}

			resources.Add(resource);

			logger.DebugFormat("Resource enlisted successfully {0}", resource);
		}