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

namespace System.Web.Compilation {

using System;
using System.Resources;
using System.Resources.Tools;
using System.Reflection;
using System.Globalization;
using System.Collections;
using System.IO;
using System.Xml;
using System.Xml.Schema;
using System.CodeDom;
using System.CodeDom.Compiler;
using System.Web.Configuration;
using System.Web.Hosting;
using System.Web.Compilation;
using System.Web.UI;
using System.Web.Util;
using Util=System.Web.UI.Util;

/// Base class for BuildProviders that generate resources
[BuildProviderAppliesTo(BuildProviderAppliesTo.Resources)]
internal abstract class BaseResourcesBuildProvider : BuildProvider {

    internal const string DefaultResourcesNamespace = "Resources";

    // The generated namespace and type name
    private string _ns;
    private string _typeName;
    
    private string _cultureName;
    private bool _dontGenerateStronglyTypedClass;

    internal void DontGenerateStronglyTypedClass() {
        _dontGenerateStronglyTypedClass = true;
    }

    public override void GenerateCode(AssemblyBuilder assemblyBuilder) {

        _cultureName = GetCultureName();

        if (!_dontGenerateStronglyTypedClass) {
            // Get the namespace and type name that we will use
            _ns = Util.GetNamespaceAndTypeNameFromVirtualPath(VirtualPathObject,
                (_cultureName == null) ? 1 : 2 /*chunksToIgnore*/, out _typeName);

            // Always prepend the namespace with Resources.
            if (_ns.Length == 0)
                _ns = DefaultResourcesNamespace;
            else
                _ns = DefaultResourcesNamespace + "." + _ns;
        }

        // Get an input stream for our virtual path, and get a resource reader from it
        using (Stream inputStream = OpenStream()) {
            IResourceReader reader = GetResourceReader(inputStream);

            try {
                GenerateResourceFile(assemblyBuilder, reader);
            }
            catch (ArgumentException e) {
                // If the inner exception is Xml, throw that instead, as it contains more
                // useful info
                if (e.InnerException != null &&
                    (e.InnerException is XmlException || e.InnerException is XmlSchemaException)) {
                    throw e.InnerException;
                }

                // Otherwise, so just rethrow
                throw;
            }

            // Skip the code part for satellite assemblies, or if dontGenerate is set
            if (_cultureName == null && !_dontGenerateStronglyTypedClass)
                GenerateStronglyTypedClass(assemblyBuilder, reader);
        }
    }

    protected abstract IResourceReader GetResourceReader(Stream inputStream);

    private void GenerateResourceFile(AssemblyBuilder assemblyBuilder, IResourceReader reader) {

        // Get the name of the generated .resource file
        string resourceFileName;
        if (_ns == null) {
            // In the case where we don't generate code, just name the resource file
            // after the virtual file
            resourceFileName = UrlPath.GetFileNameWithoutExtension(VirtualPath) + ".resources";
        }
        else if (_cultureName == null) {
            // Name the resource file after the generated class, since that's what the
            // generated class expects
            resourceFileName = _ns + "." + _typeName + ".resources";
        }
        else {
            // If it's a non-default resource, include the culture in the name
            resourceFileName = _ns + "." + _typeName + "." + _cultureName + ".resources";
        }

        // Make it lower case, since GetManifestResourceStream (which we use later on) is
        // case sensitive
        resourceFileName = resourceFileName.ToLower(CultureInfo.InvariantCulture);

        Stream outputStream = null;

        try {
            try {
                try {
                }
                finally {
                    // Put the assignment in a finally block to avoid a ThreadAbortException from
                    // causing the created stream to not get assigned and become leaked (Dev10 bug 844463)
                    outputStream = assemblyBuilder.CreateEmbeddedResource(this, resourceFileName);
                }
            }
            catch (ArgumentException) {
                // This throws an ArgumentException if the resource file name was already added.
                // Catch the situation, and give a better error message (VSWhidbey 87110)

                throw new HttpException(SR.GetString(SR.Duplicate_Resource_File, VirtualPath));
            }

            // Create an output stream from the .resource file
            using (outputStream) {
                using (ResourceWriter writer = new ResourceWriter(outputStream)) {
                    // Enable resource writer to be target-aware
                    writer.TypeNameConverter = System.Web.UI.TargetFrameworkUtil.TypeNameConverter;

                    // Copy the resources
                    foreach (DictionaryEntry de in reader) {
                        writer.AddResource((string)de.Key, de.Value);
                    }
                }
            }
        }
        finally {
            // Always close the stream to avoid a ThreadAbortException from causing the stream
            // to be leaked (Dev10 bug 844463)
            if (outputStream != null) {
                outputStream.Close();
            }
        }
    }

    private void GenerateStronglyTypedClass(AssemblyBuilder assemblyBuilder, IResourceReader reader) {

        // Copy the resources into an IDictionary
        IDictionary resourceList;
        using (reader) {
            resourceList = GetResourceList(reader);
        }

        // Generate a strongly typed class from the resources
        CodeDomProvider provider = assemblyBuilder.CodeDomProvider;
        string[] unmatchable;
        CodeCompileUnit ccu = StronglyTypedResourceBuilder.Create(
            resourceList, _typeName, _ns,
            provider, false /*internalClass*/, out unmatchable);

        // Ignore the unmatchable items.  We just won't generate code for them,
        // but they'll still be usable via the ResourceManager (VSWhidbey 248226)

// We decided to cut support for My.Resources (VSWhidbey 358088)
#if OLD
        // generate a My.Resources.* override (VSWhidbey 251554)
        CodeNamespace ns = new CodeNamespace();
        ns.Name = "My." + _ns;

        CodeTypeDeclaration type = new CodeTypeDeclaration();
        type.Name = _typeName;
        CodeTypeReference baseType = new CodeTypeReference(_ns + "." + _typeName);

        // Need to use a global reference to avoid a conflict, since the classes have the same name
        baseType.Options = CodeTypeReferenceOptions.GlobalReference;
        type.BaseTypes.Add(baseType);

        ns.Types.Add(type);
        ccu.Namespaces.Add(ns);
#endif

        // Add the code compile unit to the compilation
        assemblyBuilder.AddCodeCompileUnit(this, ccu);
    }

    private IDictionary GetResourceList(IResourceReader reader) {

        // Read the resources into a dictionary.
        IDictionary resourceList = new Hashtable(StringComparer.OrdinalIgnoreCase);
        foreach(DictionaryEntry de in reader)
            resourceList.Add(de.Key, de.Value);

        return resourceList;
    }
}

}