//------------------------------------------------------------------------------
// <copyright file="CodeDirectoryCompiler.cs" company="Microsoft">
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>
//------------------------------------------------------------------------------



namespace System.Web.Compilation {

using System;
using System.IO;
using System.Collections;
using System.CodeDom.Compiler;
using System.Configuration;
using System.Globalization;
using System.Web.Configuration;
using System.Reflection;
using System.Web.Hosting;
using System.Web.Util;
using System.Web.UI;

// The different types of directory that we treat as 'Code' (with minor differences)
internal enum CodeDirectoryType {
    MainCode,       // The main /code directory
    SubCode,        // Code subdirectories registered to be compiled separately
    AppResources,   // The /Resources directory
    LocalResources, // A /LocalResources directory (at any level)
    WebReferences   // The /WebReferences directory
}

internal class CodeDirectoryCompiler {

    private VirtualPath _virtualDir;
    private CodeDirectoryType _dirType;
    private StringSet _excludedSubdirectories;

    private BuildProvidersCompiler _bpc;
    private BuildProviderSet _buildProviders = new BuildProviderSet();

    private bool _onlyBuildLocalizedResources;

    static internal BuildResultMainCodeAssembly _mainCodeBuildResult;

    internal static bool IsResourceCodeDirectoryType(CodeDirectoryType dirType) {
        return dirType == CodeDirectoryType.AppResources || dirType == CodeDirectoryType.LocalResources;
    }

    internal static Assembly GetCodeDirectoryAssembly(VirtualPath virtualDir,
        CodeDirectoryType dirType, string assemblyName,
        StringSet excludedSubdirectories, bool isDirectoryAllowed) {

        string physicalDir = virtualDir.MapPath();

        if (!isDirectoryAllowed) {

            // The directory should never exist in a precompiled app
            if (Directory.Exists(physicalDir)) {
                throw new HttpException(SR.GetString(SR.Bar_dir_in_precompiled_app, virtualDir));
            }
        }

        bool supportLocalization = IsResourceCodeDirectoryType(dirType);

        // Determine the proper cache key based on the type of directory we're processing
        string cacheKey = assemblyName;

        // Try the cache first
        BuildResult result = BuildManager.GetBuildResultFromCache(cacheKey);
        Assembly resultAssembly = null;

        // If it's cached, just return it
        if (result != null) {

            // It should always be a BuildResultCompiledAssembly, though if there is
            // a VirtualPathProvider doing very bad things, it may not (VSWhidbey 341701)
            Debug.Assert(result is BuildResultCompiledAssembly);
            if (result is BuildResultCompiledAssembly) {

                // If it's the main code assembly, keep track of it so we can later call
                // the AppInitialize method
                if (result is BuildResultMainCodeAssembly) {
                    Debug.Assert(dirType == CodeDirectoryType.MainCode);
                    Debug.Assert(_mainCodeBuildResult == null);
                    _mainCodeBuildResult = (BuildResultMainCodeAssembly) result;
                }

                resultAssembly = ((BuildResultCompiledAssembly)result).ResultAssembly;

                if (!supportLocalization)
                    return resultAssembly;

                // We found a preserved resource assembly.  However, we may not be done,
                // as the culture specific files may have changed.

                // But don't make any further checks if the directory is not allowed (precomp secenario).
                // In that case, we should always return the assembly (VSWhidbey 533498)
                if (!isDirectoryAllowed)
                    return resultAssembly;

                BuildResultResourceAssembly buildResultResAssembly = (BuildResultResourceAssembly)result;

                string newResourcesDependenciesHash = HashCodeCombiner.GetDirectoryHash(virtualDir);

                // If the resources hash (which includes satellites) is up to date, we're done
                if (newResourcesDependenciesHash == buildResultResAssembly.ResourcesDependenciesHash)
                    return resultAssembly;
           }
        }

        // If app was precompiled, don't attempt compilation
        if (!isDirectoryAllowed)
            return null;

        // Check whether the virtual dir is mapped to a different application,
        // which we don't support (VSWhidbey 218603).  But don't do this for LocalResource (VSWhidbey 237935)
        if (dirType != CodeDirectoryType.LocalResources && !StringUtil.StringStartsWithIgnoreCase(physicalDir, HttpRuntime.AppDomainAppPathInternal)) {
            throw new HttpException(SR.GetString(SR.Virtual_codedir, virtualDir.VirtualPathString));
        }

        // If the directory doesn't exist, we may be done
        if (!Directory.Exists(physicalDir)) {

            // We're definitely done if it's not the main code dir
            if (dirType != CodeDirectoryType.MainCode)
                return null;

            // If it is the main code dir, we're only done is there is no profile to compile
            // since the profice gets built as part of the main assembly.
            if (!ProfileBuildProvider.HasCompilableProfile)
                return null;
        }


        // Otherwise, compile it

        BuildManager.ReportDirectoryCompilationProgress(virtualDir);

        DateTime utcStart = DateTime.UtcNow;

        CodeDirectoryCompiler cdc = new CodeDirectoryCompiler(virtualDir,
            dirType, excludedSubdirectories);

        string outputAssemblyName = null;

        if (resultAssembly != null) {
            // If resultAssembly is not null, we are in the case where we just need to build
            // the localized resx file in a resources dir (local or global)
            Debug.Assert(supportLocalization);
            outputAssemblyName = resultAssembly.GetName().Name;
            cdc._onlyBuildLocalizedResources = true;
        }
        else {
            outputAssemblyName = BuildManager.GenerateRandomAssemblyName(assemblyName);
        }

        BuildProvidersCompiler bpc = 
            new BuildProvidersCompiler(virtualDir, supportLocalization, outputAssemblyName);

        cdc._bpc = bpc;

        // Find all the build provider we want to compile from the code directory
        cdc.FindBuildProviders();

        // Give them to the BuildProvidersCompiler
        bpc.SetBuildProviders(cdc._buildProviders);

        // Compile them into an assembly
        CompilerResults results = bpc.PerformBuild();

        // Did we just compile something?
        if (results != null) {
            Debug.Assert(result == null);
            Debug.Assert(resultAssembly == null);

            // If there is already a loaded module with the same path, try to wait for it to be unloaded.
            // Otherwise, we would end up loading this old assembly instead of the new one (VSWhidbey 554697)
            DateTime waitLimit = DateTime.UtcNow.AddMilliseconds(3000);
            for (;;) {
                IntPtr hModule = UnsafeNativeMethods.GetModuleHandle(results.PathToAssembly);
                if (hModule == IntPtr.Zero)
                    break;

                Debug.Trace("CodeDirectoryCompiler", results.PathToAssembly + " is already loaded. Waiting a bit");

                System.Threading.Thread.Sleep(250);

                // Stop trying if the timeout was reached
                if (DateTime.UtcNow > waitLimit) {
                    Debug.Trace("CodeDirectoryCompiler", "Timeout waiting for old assembly to unload: " + results.PathToAssembly);
                    throw new HttpException(SR.GetString(SR.Assembly_already_loaded, results.PathToAssembly));
                }
            }

            resultAssembly = results.CompiledAssembly;
        }

        // It is possible that there was nothing to compile (and we're not in the
        // satellite resources case)
        if (resultAssembly == null)
            return null;

        // For the main code directory, use a special BuildResult that takes care of
        // calling AppInitialize if it finds one
        if (dirType == CodeDirectoryType.MainCode) {
            // Keep track of it so we can later call the AppInitialize method
            _mainCodeBuildResult = new BuildResultMainCodeAssembly(resultAssembly);

            result = _mainCodeBuildResult;
        }
        else if (supportLocalization) {
            result = new BuildResultResourceAssembly(resultAssembly);
        }
        else {
            result = new BuildResultCompiledAssembly(resultAssembly);
        }

        result.VirtualPath = virtualDir;

        // If compilations are optimized, we need to include the right dependencies, since we can no longer
        // rely on everything getting wiped out when something in App_Code changes.
        // But don't do this for local resources, since they have their own special way of
        // dealing with dependencies (in BuildResultResourceAssembly.ComputeSourceDependenciesHashCode).
        // It's crucial *not* to do it as it triggers a tricky infinite recursion due to the fact
        // that GetBuildResultFromCacheInternal calls EnsureFirstTimeDirectoryInitForDependencies if
        // there is at least one dependency
        if (BuildManager.OptimizeCompilations && dirType != CodeDirectoryType.LocalResources) {
            result.AddVirtualPathDependencies(new SingleObjectCollection(virtualDir.AppRelativeVirtualPathString));
        }

        // Top level assembly should not be cached to memory.  But LocalResources are *not*
        // top level files, and do benefit from memory caching
        if (dirType != CodeDirectoryType.LocalResources)
            result.CacheToMemory = false;

        // Cache it for next time
        BuildManager.CacheBuildResult(cacheKey, result, utcStart);

        return resultAssembly;
    }

    // Call the AppInitialize method in the Code assembly if there is one
    internal static void CallAppInitializeMethod() {
        if (_mainCodeBuildResult != null)
            _mainCodeBuildResult.CallAppInitializeMethod();
    }

    internal const string sourcesDirectoryPrefix = "Sources_";

    internal static void GetCodeDirectoryInformation(
        VirtualPath virtualDir, CodeDirectoryType dirType, StringSet excludedSubdirectories, int index,
        out Type codeDomProviderType, out CompilerParameters compilerParameters,
        out string generatedFilesDir) {

        // Compute the full path to the directory we'll use to generate all
        // the code files
        generatedFilesDir = HttpRuntime.CodegenDirInternal + "\\" + 
            sourcesDirectoryPrefix + virtualDir.FileName;

        bool supportLocalization = IsResourceCodeDirectoryType(dirType);

        // the index is used to retrieve the correct referenced assemblies
        BuildProvidersCompiler bpc = new BuildProvidersCompiler(virtualDir, supportLocalization,
            generatedFilesDir, index);

        CodeDirectoryCompiler cdc = new CodeDirectoryCompiler(virtualDir,
            dirType, excludedSubdirectories);
        cdc._bpc = bpc;

        // Find all the build provider we want to compile from the code directory
        cdc.FindBuildProviders();

        // Give them to the BuildProvidersCompiler
        bpc.SetBuildProviders(cdc._buildProviders);

        // Generate all the sources into the directory generatedFilesDir
        bpc.GenerateSources(out codeDomProviderType, out compilerParameters);
    }

    private CodeDirectoryCompiler(VirtualPath virtualDir, CodeDirectoryType dirType,
        StringSet excludedSubdirectories) {

        _virtualDir = virtualDir;
        _dirType = dirType;
        _excludedSubdirectories = excludedSubdirectories;
    }

    private void FindBuildProviders() {

        // If we need to build the profile, add its build provider
        if (_dirType == CodeDirectoryType.MainCode && ProfileBuildProvider.HasCompilableProfile) {
            _buildProviders.Add(ProfileBuildProvider.Create());

        }

        VirtualDirectory vdir = HostingEnvironment.VirtualPathProvider.GetDirectory(_virtualDir);
        ProcessDirectoryRecursive(vdir, true /*topLevel*/);
    }

    private void AddFolderLevelBuildProviders(VirtualDirectory vdir, FolderLevelBuildProviderAppliesTo appliesTo) {
        BuildManager.AddFolderLevelBuildProviders(_buildProviders, vdir.VirtualPathObject,
            appliesTo, _bpc.CompConfig, _bpc.ReferencedAssemblies);
    }

    private void ProcessDirectoryRecursive(VirtualDirectory vdir, bool topLevel) {

        // If it's a WebReferences directory, handle it using a single WebReferencesBuildProvider
        // instead of creating a different BuildProvider for each file.
        if (_dirType == CodeDirectoryType.WebReferences) {
            // Create a build provider for the current directory
            BuildProvider buildProvider = new WebReferencesBuildProvider(vdir);
            buildProvider.SetVirtualPath(vdir.VirtualPathObject);
            _buildProviders.Add(buildProvider);

            AddFolderLevelBuildProviders(vdir, FolderLevelBuildProviderAppliesTo.WebReferences);
        }
        else if (_dirType == CodeDirectoryType.AppResources) {
            AddFolderLevelBuildProviders(vdir, FolderLevelBuildProviderAppliesTo.GlobalResources);
        }
        else if (_dirType == CodeDirectoryType.LocalResources) {
            AddFolderLevelBuildProviders(vdir, FolderLevelBuildProviderAppliesTo.LocalResources);
        }
        else if (_dirType == CodeDirectoryType.MainCode || _dirType == CodeDirectoryType.SubCode) {
            AddFolderLevelBuildProviders(vdir, FolderLevelBuildProviderAppliesTo.Code);
        }

        // Go through all the files in the directory
        foreach (VirtualFileBase child in vdir.Children) {

            if (child.IsDirectory) {

                // If we are at the top level of this code directory, and the current
                // subdirectory is in the exclude list, skip it
                if (topLevel && _excludedSubdirectories != null &&
                    _excludedSubdirectories.Contains(child.Name)) {
                    continue;
                }

                // Exclude the special FrontPage directory (VSWhidbey 116727)
                if (child.Name == "_vti_cnf")
                    continue;

                ProcessDirectoryRecursive(child as VirtualDirectory, false /*topLevel*/);
                continue;
            }

            // Don't look at individual files for WebReferences directories
            if (_dirType == CodeDirectoryType.WebReferences)
                continue;

            // Skip neutral files if _onlyBuildLocalizedResources is true
            if (IsResourceCodeDirectoryType(_dirType)) {
                if (_onlyBuildLocalizedResources && System.Web.UI.Util.GetCultureName(child.VirtualPath) == null) {
                    continue;
                }
            }

            BuildProvider buildProvider = BuildManager.CreateBuildProvider(child.VirtualPathObject,
                (IsResourceCodeDirectoryType(_dirType)) ?
                    BuildProviderAppliesTo.Resources : BuildProviderAppliesTo.Code,
                _bpc.CompConfig,
                _bpc.ReferencedAssemblies, false /*failIfUnknown*/);

            // Non-supported file type
            if (buildProvider == null)
                continue;

            // For Page resources, don't generate a strongly typed class
            if (_dirType == CodeDirectoryType.LocalResources && buildProvider is BaseResourcesBuildProvider) {
                ((BaseResourcesBuildProvider)buildProvider).DontGenerateStronglyTypedClass();
            }

            _buildProviders.Add(buildProvider);
        }
    }
}

}