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

/*
 * HashCodeCombiner class
 * 
 * Copyright (c) 1999 Microsoft Corporation
 */

namespace System.Web.Util {
using System.Text;
using System.IO;
using System.Globalization;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Web.Security.Cryptography;

/*
 * Class used to combine several hashcodes into a single hashcode
 */
internal class HashCodeCombiner {

    private long _combinedHash;

    internal HashCodeCombiner() {
       // Start with a seed (obtained from String.GetHashCode implementation)
       _combinedHash = 5381;
    }

    internal HashCodeCombiner(long initialCombinedHash)   {
        _combinedHash = initialCombinedHash;
    }

    internal static int CombineHashCodes(int h1, int h2) {
        return ((h1 << 5) + h1) ^ h2;
    }

    internal static int CombineHashCodes(int h1, int h2, int h3) {
        return CombineHashCodes(CombineHashCodes(h1, h2), h3);
    }

    internal static int CombineHashCodes(int h1, int h2, int h3, int h4) {
        return CombineHashCodes(CombineHashCodes(h1, h2), CombineHashCodes(h3, h4));
    }

    internal static int CombineHashCodes(int h1, int h2, int h3, int h4, int h5) {
        return CombineHashCodes(CombineHashCodes(h1, h2, h3, h4), h5);
    }

    internal static string GetDirectoryHash(VirtualPath virtualDir) {
        HashCodeCombiner hashCodeCombiner = new HashCodeCombiner();
        hashCodeCombiner.AddDirectory(virtualDir.MapPathInternal());
        return hashCodeCombiner.CombinedHashString;
    }

    internal void AddArray(string[] a) {
        if (a != null) {
            int n = a.Length;
            for (int i = 0; i < n; i++) {
                AddObject(a[i]);
            }
        }
    }

    internal void AddInt(int n) {
        _combinedHash = ((_combinedHash << 5) + _combinedHash) ^ n;
        Debug.Trace("HashCodeCombiner", "Adding " + n.ToString("x") + " --> " + _combinedHash.ToString("x"));
    }

    internal void AddObject(int n) {
        AddInt(n);
    }

    internal void AddObject(byte b) {
        AddInt(b.GetHashCode());
    }

    internal void AddObject(long l) {
        AddInt(l.GetHashCode());
    }

    internal void AddObject(bool b) {
        AddInt(b.GetHashCode());
    }

    internal void AddObject(string s) {
        if (s != null)
            AddInt(StringUtil.GetStringHashCode(s));
    }

    internal void AddObject(Type t) {
        if (t != null)
            AddObject(System.Web.UI.Util.GetAssemblyQualifiedTypeName(t));
    }

    internal void AddObject(object o) {
        if (o != null)
            AddInt(o.GetHashCode());
    }

    internal void AddCaseInsensitiveString(string s) {
        if (s != null)
            AddInt(StringUtil.GetNonRandomizedHashCode(s, ignoreCase:true));
    }

    internal void AddDateTime(DateTime dt) {
        Debug.Trace("HashCodeCombiner", "Ticks: " + dt.Ticks.ToString("x", CultureInfo.InvariantCulture));
        Debug.Trace("HashCodeCombiner", "Hashcode: " + dt.GetHashCode().ToString("x", CultureInfo.InvariantCulture));
        AddInt(dt.GetHashCode());
    }

    private void AddFileSize(long fileSize) {
        Debug.Trace("HashCodeCombiner", "file size: " + fileSize.ToString("x", CultureInfo.InvariantCulture));
        Debug.Trace("HashCodeCombiner", "Hashcode: " + fileSize.GetHashCode().ToString("x", CultureInfo.InvariantCulture));
        AddInt(fileSize.GetHashCode());
    }

    [SuppressMessage("Microsoft.Security", "CA2122:DoNotIndirectlyExposeMethodsWithLinkDemands", Justification = "This call site is trusted.")]
    private void AddFileVersionInfo(FileVersionInfo fileVersionInfo) {
        Debug.Trace("HashCodeCombiner", "FileMajorPart: " + fileVersionInfo.FileMajorPart.GetHashCode().ToString("x", CultureInfo.InvariantCulture));
        Debug.Trace("HashCodeCombiner", "FileMinorPart: " + fileVersionInfo.FileMinorPart.GetHashCode().ToString("x", CultureInfo.InvariantCulture));
        Debug.Trace("HashCodeCombiner", "FileBuildPart: " + fileVersionInfo.FileBuildPart.GetHashCode().ToString("x", CultureInfo.InvariantCulture));
        Debug.Trace("HashCodeCombiner", "FilePrivatePart: " + fileVersionInfo.FilePrivatePart.GetHashCode().ToString("x", CultureInfo.InvariantCulture));
        AddInt(fileVersionInfo.FileMajorPart.GetHashCode());
        AddInt(fileVersionInfo.FileMinorPart.GetHashCode());
        AddInt(fileVersionInfo.FileBuildPart.GetHashCode());
        AddInt(fileVersionInfo.FilePrivatePart.GetHashCode());
    }

    private void AddFileContentHashKey(string fileContentHashKey) {
        AddInt(StringUtil.GetNonRandomizedHashCode(fileContentHashKey));
    }

    internal void AddFileContentHash(string fileName) {
        // Convert file content to hash bytes
        byte[] fileContentBytes = File.ReadAllBytes(fileName);
        byte[] fileContentHashBytes = CryptoUtil.ComputeSHA256Hash(fileContentBytes);

        // Convert byte[] to hex string representation
        StringBuilder sbFileContentHashBytes = new StringBuilder();
        for (int index = 0; index < fileContentHashBytes.Length; index++) {
            sbFileContentHashBytes.Append(fileContentHashBytes[index].ToString("X2", CultureInfo.InvariantCulture));
        }

        AddFileContentHashKey(sbFileContentHashBytes.ToString());
    }

    internal void AddFile(string fileName) {
        Debug.Trace("HashCodeCombiner", "AddFile: " + fileName);
        if (!FileUtil.FileExists(fileName)) {

            // Review: Should we change the dependency model to take directory into account?
            if (FileUtil.DirectoryExists(fileName)) {
                // Add as a directory dependency if it's a directory.
                AddDirectory(fileName);
                return;
            }

            Debug.Trace("HashCodeCombiner", "Could not find target " + fileName);
            return;
        }

        AddExistingFile(fileName);
    }

    // Same as AddFile, but only called for a file which is known to exist
    private void AddExistingFile(string fileName) {
        Debug.Trace("HashCodeCombiner", "AddExistingFile: " + fileName);

        AddInt(StringUtil.GetStringHashCode(fileName));
        FileInfo file = new FileInfo(fileName);
        if (!AppSettings.PortableCompilationOutput) {
            AddDateTime(file.CreationTimeUtc);
        }
        AddDateTime(file.LastWriteTimeUtc);
        AddFileSize(file.Length);
    }

    [SuppressMessage("Microsoft.Security", "CA2122:DoNotIndirectlyExposeMethodsWithLinkDemands", Justification = "This call site is trusted.")]
    internal void AddExistingFileVersion(string fileName) {
        Debug.Trace("HashCodeCombiner", "AddExistingFileVersion: " + fileName);

        AddInt(StringUtil.GetStringHashCode(fileName));
        FileVersionInfo fileVersionInfo = FileVersionInfo.GetVersionInfo(fileName);

        AddFileVersionInfo(fileVersionInfo);
    }

    internal void AddDirectory(string directoryName) {

        DirectoryInfo directory = new DirectoryInfo(directoryName);
        if (!directory.Exists) {
            return;
        }

        AddObject(directoryName);

        // Go through all the files in the directory
        foreach (FileData fileData in FileEnumerator.Create(directoryName)) {

            if (fileData.IsDirectory)
                AddDirectory(fileData.FullName);
            else
                AddExistingFile(fileData.FullName);
        }

        if (!AppSettings.PortableCompilationOutput) {
            AddDateTime(directory.CreationTimeUtc);
            AddDateTime(directory.LastWriteTimeUtc);
        }
    }

    // Same as AddDirectory, but only look at files that don't have a culture
    internal void AddResourcesDirectory(string directoryName) {

        DirectoryInfo directory = new DirectoryInfo(directoryName);
        if (!directory.Exists) {
            return;
        }

        AddObject(directoryName);

        // Go through all the files in the directory
        foreach (FileData fileData in FileEnumerator.Create(directoryName)) {

            if (fileData.IsDirectory)
                AddResourcesDirectory(fileData.FullName);
            else {
                // Ignore the file if it has a culture, since only neutral files
                // need to re-trigger compilation (VSWhidbey 359029)
                string fullPath = fileData.FullName;
                if (System.Web.UI.Util.GetCultureName(fullPath) == null) {
                    AddExistingFile(fullPath);
                }
            }
        }

        if (!AppSettings.PortableCompilationOutput) {
            AddDateTime(directory.CreationTimeUtc);
        }
    }

    internal long CombinedHash { get { return _combinedHash; } }
    internal int CombinedHash32 { get { return _combinedHash.GetHashCode(); } }

    internal string CombinedHashString {
        get {
            return _combinedHash.ToString("x", CultureInfo.InvariantCulture);
        }
    }
}


}