/// <summary>
        /// The handle.
        /// </summary>
        /// <param name="asset">
        /// The asset.
        /// </param>
        /// <param name="target">
        /// The target.
        /// </param>
        /// <returns>
        /// The <see cref="dynamic"/>.
        /// </returns>
        public IRawAsset Handle(IAsset asset, AssetTarget target)
        {
            var fontAsset = asset as FontAsset;

            if (target == AssetTarget.CompiledFile)
            {
                if (fontAsset.PlatformData == null)
                {
                    throw new InvalidOperationException(
                        "Attempted save of font asset as a compiled file, but the font wasn't compiled.  This usually " +
                        "indicates that the font '" + fontAsset.FontName + "' is not installed on the current system.");
                }

                return new CompiledAsset
                {
                    Loader = typeof(FontAssetLoader).FullName,
                    PlatformData = fontAsset.PlatformData
                };
            }

            return
                new AnonymousObjectBasedRawAsset(
                    new
                    {
                        Loader = typeof(FontAssetLoader).FullName,
                        fontAsset.FontSize,
                        fontAsset.FontName,
                        fontAsset.UseKerning,
                        fontAsset.Spacing,
                        PlatformData = target == AssetTarget.SourceFile ? null : fontAsset.PlatformData
                    });
        }

 public PlainScript(IAsset asset, Bundle bundle, IAmdConfiguration modules)
     : base(asset, bundle)
 {
     this.modules = modules;
     jsonSerializer = new SimpleJsonSerializer();
     asset.AddAssetTransformer(this);
 }

 void AddRawFileReferenceForEachImportedFile(IAsset asset, CompileResult compileResult)
 {
     foreach (var importedFilePath in compileResult.ImportedFilePaths)
     {
         asset.AddRawFileReference(importedFilePath);
     }
 }

        /**
         * Create a simulated asset from a real one.
         * It extract the name of real asset for "fake" one
         * and the first price (at first date) and simulate
         * at all dates from dates_simul.
         * 
         * getPrice(t) with t from dates_simul will then return
         * a simulated price
         * getPrice(t) with t before first date from dates_simul
         * will return real price of asset
         * getPrice(t) with all others date will throw exception
         **/
        public AssetSimulated(IAsset real, LinkedList<DateTime> dates_simul, RandomNormal rand)
        {
            this.real = real;
            prices = new Dictionary<DateTime, double>();
            first_date = dates_simul.First();
            r = 0.04;
                //real.getCurrency().getInterestRate(first_date, TimeSpan.Zero);
            // TODO
            //sigma = real.getVolatility(first_date);
            sigma = 0.2;

            // debug kevin
            double St = 75 + 50*rand.NextDouble();
            DateTime lastDate = first_date;
            //double S0 = real.getPrice(first_date);
            int i = 0;
            foreach (DateTime date in dates_simul)
            {
                double T = (date - lastDate).TotalDays / 365; // time in year
                double WT = Math.Sqrt(T) * rand.NextNormal();
                St = St * Math.Exp((r - sigma * sigma / 2) * T + sigma * WT);
                prices[date] = St;
                lastDate = date;
                i++;
            }
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="AssetFileCollection"/> class.
 /// </summary>
 /// <param name="cloudMediaContext">The cloud media context.</param>
 /// <param name="parentAsset">The parent <see cref="IAsset"/>.</param>
 internal AssetFileCollection(MediaContextBase cloudMediaContext, IAsset parentAsset)
     : this(cloudMediaContext)
 {
     _parentAsset = parentAsset;
     MediaServicesClassFactory factory = this.MediaContext.MediaServicesClassFactory;
     this._assetFileQuery = new Lazy<IQueryable<IAssetFile>>(() => factory.CreateDataServiceContext().CreateQuery<IAssetFile, AssetFileData>(FileSet));
 }

 public Func<Stream> Transform(Func<Stream> openSourceStream, IAsset asset)
 {
     return delegate
     {
         var css = ReadCss(openSourceStream);
         var currentDirectory = GetCurrentDirectory(asset);
         var urlMatches = UrlMatchesInReverse(css);
         var builder = new StringBuilder(css);
         foreach (var match in urlMatches)
         {
             var matchedUrlGroup = match.Groups["url"];
             string queryString;
             string fragment;
             var relativeFilename = GetImageFilename(matchedUrlGroup, currentDirectory, out queryString, out fragment);
             if (ReplaceUrlWithCassetteRawFileUrl(builder, matchedUrlGroup, relativeFilename, queryString, fragment))
             {
                 asset.AddRawFileReference(relativeFilename);
             }
             else
             {
                 ReplaceUrlWithAbsoluteUrl(builder, matchedUrlGroup, currentDirectory);
             }
         }
         return builder.ToString().AsStream();
     };
 }

        public Func<Stream> Transform(Func<Stream> openSourceStream, IAsset asset)
        {
            return () =>
            {
                var addTemplateCalls = openSourceStream().ReadToEnd();

                var output = string.Format(
                    @"(function(d) {{
            var addTemplate = function(id, content) {{
            var script = d.createElement('script');
            script.type = '{0}';
            script.id = id;
            if (typeof script.textContent !== 'undefined') {{
            script.textContent = content;
            }} else {{
            script.innerText = content;
            }}
            var x = d.getElementsByTagName('script')[0];
            x.parentNode.insertBefore(script, x);
            }};
            {1}
            }}(document));",
                    contentType,
                    addTemplateCalls);

                return new MemoryStream(Encoding.UTF8.GetBytes(output));
            };
        }

 public PlainScript(IAsset asset, Bundle bundle, IModuleInitializer modules,string baseUrl = null)
     : base(asset, bundle, baseUrl)
 {
     this.modules = modules;
     jsonSerializer = new SimpleJsonSerializer();
     asset.AddAssetTransformer(this);
 }

        /// <summary>
        /// The handle.
        /// </summary>
        /// <param name="asset">
        /// The asset.
        /// </param>
        /// <param name="target">
        /// The target.
        /// </param>
        /// <returns>
        /// The <see cref="dynamic"/>.
        /// </returns>
        public IRawAsset Handle(IAsset asset, AssetTarget target)
        {
            var textAsset = asset as LanguageAsset;

            return
                new AnonymousObjectBasedRawAsset(new { Loader = typeof(LanguageAssetLoader).FullName, textAsset.Value });
        }

        private static async Task<IJob> CreateMediaEncodeJob(CloudMediaContext context, IAsset assetToEncode)
        {
            //string encodingPreset = "H264 Broadband 720p";
            string encodingPreset = "H264 Smooth Streaming 720p";

            IJob job = context.Jobs.Create("Encoding " + assetToEncode.Name + " to " + encodingPreset);

            string[] y =
                context.MediaProcessors.Where(mp => mp.Name.Equals("Azure Media Encoder"))
                    .ToArray()
                    .Select(mp => mp.Version)
                    .ToArray();

            IMediaProcessor latestWameMediaProcessor =
                context.MediaProcessors.Where(mp => mp.Name.Equals("Azure Media Encoder"))
                    .ToArray()
                    .OrderByDescending(
                        mp =>
                            new Version(int.Parse(mp.Version.Split('.', ',')[0]),
                                int.Parse(mp.Version.Split('.', ',')[1])))
                    .First();

            ITask encodeTask = job.Tasks.AddNew("Encoding", latestWameMediaProcessor, encodingPreset, TaskOptions.None);
            encodeTask.InputAssets.Add(assetToEncode);
            encodeTask.OutputAssets.AddNew(assetToEncode.Name + " as " + encodingPreset, AssetCreationOptions.None);

            job.StateChanged += new EventHandler<JobStateChangedEventArgs>((sender, jsc) => Console.WriteLine(
                $"{((IJob) sender).Name}\n  State: {jsc.CurrentState}\n  Time: {DateTime.UtcNow.ToString(@"yyyy_M_d_hhmmss")}\n\n"));
            return await job.SubmitAsync();
        }

 static ModuleDefinitionParser ParseJavaScriptForModuleDefinition(IAsset asset)
 {
     var tree = ParseJavaScript(asset);
     var moduleDefinitionParser = new ModuleDefinitionParser();
     tree.Accept(moduleDefinitionParser);
     return moduleDefinitionParser;
 }

 /// <summary>
 /// Returns a new <see cref="ILocator"/> instance.
 /// </summary>
 /// <param name="locators">The <see cref="LocatorBaseCollection"/> instance.</param>
 /// <param name="locatorType">The <see cref="LocatorType"/>.</param>
 /// <param name="asset">The <see cref="IAsset"/> instance for the new <see cref="ILocator"/>.</param>
 /// <param name="permissions">The <see cref="AccessPermissions"/> of the <see cref="IAccessPolicy"/> associated with the new <see cref="ILocator"/>.</param>
 /// <param name="duration">The duration of the <see cref="IAccessPolicy"/> associated with the new <see cref="ILocator"/>.</param>
 /// <param name="startTime">The start time of the new <see cref="ILocator"/>.</param>
 /// <returns>A a new <see cref="ILocator"/> instance.</returns>
 public static ILocator Create(this LocatorBaseCollection locators, LocatorType locatorType, IAsset asset, AccessPermissions permissions, TimeSpan duration, DateTime? startTime)
 {
     using (Task<ILocator> task = locators.CreateAsync(locatorType, asset, permissions, duration, startTime))
     {
         return task.Result;
     }
 }

        public static IAsset EncodeToAdaptiveBitrateMP4s(IAsset asset, AssetCreationOptions options)
        {
            // Prepare a job with a single task to transcode the specified asset
            // into a multi-bitrate asset.

            IJob job = _context.Jobs.CreateWithSingleTask(
                MediaProcessorNames.AzureMediaEncoder,
                MediaEncoderTaskPresetStrings.H264AdaptiveBitrateMP4Set720p,
                asset,
                "Adaptive Bitrate MP4",
                options);

            Console.WriteLine("Submitting transcoding job...");

            // Submit the job and wait until it is completed.
            job.Submit();

            job = job.StartExecutionProgressTask(
                j =>
                {
                    Console.WriteLine("Job state: {0}", j.State);
                    Console.WriteLine("Job progress: {0:0.##}%", j.GetOverallProgress());
                },
                CancellationToken.None).Result;

            Console.WriteLine("Transcoding job finished.");

            IAsset outputAsset = job.OutputMediaAssets[0];

            return outputAsset;
        }

        private static async Task<ILocator> CreateSasLocatorAsync(CloudMediaContext context, IAsset asset)
        {
            var accessPolicy = await context.AccessPolicies.CreateAsync(
                asset.Name, TimeSpan.FromDays(2), AccessPermissions.Write | AccessPermissions.List);

            return await context.Locators.CreateSasLocatorAsync(asset, accessPolicy);
        }

        public NamedModule(IAsset asset, Bundle bundle, string modulePath)
            : base(asset, bundle)
        {
            if (modulePath == null) throw new ArgumentNullException("modulePath");

            ModulePath = modulePath;
        }

        public static string ConvertAssetToSmoothStreaming(this CloudMediaContext context, IAsset asset, bool createThumbnail)
        {
            var configuration = MediaServicesHelper.H264SmoothStreamingEncodingPreset;
            var processor = context.MediaProcessors.Where(m => m.Id == MediaServicesHelper.EncoderProcessorId).FirstOrDefault();            

            var job = context.Jobs.Create(asset.Name);

            var task = job.Tasks.AddNew(
                MediaServicesHelper.EncodingTask,
                processor,
                configuration,
                TaskOptions.None);

            task.InputAssets.Add(asset);
            var encodedAsset = task.OutputAssets.AddNew(asset.Name + " - [" + configuration + "]", true, AssetCreationOptions.None);
            encodedAsset.AlternateId = asset.AlternateId + "_0";

            if (createThumbnail)
            {
                var thumbnailTask = job.Tasks.AddNew(
                    MediaServicesHelper.ThumbnailTask,
                    processor,
                    MediaServicesHelper.ThumbnailPreset,
                    TaskOptions.None);

                thumbnailTask.InputAssets.Add(asset);
                var thumbnailAsset = thumbnailTask.OutputAssets.AddNew(asset.Name + " - [thumbnail]", true, AssetCreationOptions.None);
                thumbnailAsset.AlternateId = asset.AlternateId + "_1";
            }
            
            job.Submit();

            return job.Id;
        }

        public ExportAssetToAzureStorage(CloudMediaContext contextUploadArg, string MediaServicesStorageAccountKeyArg, IAsset sourceAsset, string StorageSuffix)
        {
            InitializeComponent();
            this.Icon = Bitmaps.Azure_Explorer_ico;
            MediaServicesStorageAccountKey = MediaServicesStorageAccountKeyArg;
            contextUpload = contextUploadArg;

            // list asset files ///////////////////////
            bool bfileinasset = (sourceAsset.AssetFiles.Count() == 0) ? false : true;
            listViewAssetFiles.Items.Clear();
            if (bfileinasset)
            {
                listViewAssetFiles.BeginUpdate();
                foreach (IAssetFile file in sourceAsset.AssetFiles)
                {
                    ListViewItem item = new ListViewItem(file.Name, 0);
                    if (file.IsPrimary) item.ForeColor = Color.Blue;
                    item.SubItems.Add(file.LastModified.ToLocalTime().ToString("G"));
                    item.SubItems.Add(AssetInfo.FormatByteSize(file.ContentFileSize));
                    (listViewAssetFiles.Items.Add(item)).Selected = true;
                    listassetfiles.Add(file);
                }

                listViewAssetFiles.AutoResizeColumns(ColumnHeaderAutoResizeStyle.HeaderSize);
                listViewAssetFiles.EndUpdate();

            }
            myStorageSuffix = StorageSuffix;
        }

		private IEnumerator LoadAsset(IAsset asset)
		{
			if (!asset.Loaded)
			{
				ResourceRequest request = Resources.LoadAsync(PathPrefix != null ? PathPrefix + "/" + asset.Path : asset.Path);

				Requests[asset] = request;

				yield return request;

				if (request.asset != null)
				{
					asset.Resource = Instantiate(request.asset);

					if (asset.Resource is GameObject)
					{
						((GameObject)(asset.Resource)).transform.SetParent(AssetPool.transform, false);
					}

					asset.Loaded = true;
				}
				else
				{
					Debug.LogError("Failed to load asset! Could not find: " + asset.Path);
				}
			}
		}

        void SendAsset(Bundle bundle, IAsset asset)
        {
            response.ContentType = bundle.ContentType;

            var actualETag = "\"" + asset.Hash.ToHexString() + "\"";
            if(request.RawUrl.Contains(asset.Hash.ToHexString())) {
                HttpResponseUtil.CacheLongTime(response, actualETag);
            }
            else {
                HttpResponseUtil.NoCache(response);
            }

            var givenETag = request.Headers["If-None-Match"];
            if (givenETag == actualETag)
            {
                HttpResponseUtil.SendNotModified(response);
            }
            else
            {
                HttpResponseUtil.EncodeStreamAndAppendResponseHeaders(request, response);

                using (var stream = asset.OpenStream())
                {
                    stream.CopyTo(response.OutputStream);
                }
            }
        }

        public Func<Stream> Transform(Func<Stream> openSourceStream, IAsset asset)
        {
            return delegate
            {
                using (var input = new StreamReader(openSourceStream()))
                {
                    var stream = new MemoryStream();
                    var writer = new StreamWriter(stream);

                    var regex = new Regex("__R\\([\"']{1}.*?[\"']{1}\\)", RegexOptions.Compiled);
                    var script = regex.Replace(input.ReadToEnd(), delegate(Match match)
                    {
                        var resource = match.Value
                            .Remove(match.Value.LastIndexOf(")"), 1)
                            .Replace("__R", "$.localize");

                        resource = string.Format("{0}, \"{1}\")", resource, _path);

                        return Path.GetExtension(_path) == ".htm" ? "${" + resource + "}" : resource;
                    });

                    writer.Write(script);
                    writer.Flush();
                    stream.Position = 0;

                    return stream;
                }
            };
        }