// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
 
using System;
using System.IO;
 
namespace Microsoft.DotNet.StrongName
{
    public static class StrongNameHelper
    {
        /// <summary>
        /// Returns true if the file has a valid strong name signature.
        /// </summary>
        /// <param name="file">Path to file</param>
        /// <param name="snPath">Path to sn.exe, if available and desired.</param>
        /// <returns>True if the file has a valid strong name signature, false otherwise.</returns>
        public static bool IsSigned(string file, string snPath = null) =>
            Verification.IsSigned(file, snPath);
 
        /// <summary>
        /// Determine whether the file is strong named, using sn.exe instead
        /// of the custom implementation
        /// </summary>
        /// <param name="file">Path to file</param>
        /// <param name="snPath">sn.exe path</param>
        /// <returns>True if the file is strong named, false otherwise.</returns>
        public static bool IsSigned_Legacy(string file, string snPath) =>
            Verification.IsSigned_Legacy(file, snPath);
 
        /// <summary>
        /// Unset the strong name signing bit from a file. This is required for sn
        /// </summary>
        /// <param name="file"></param>
        public static void ClearStrongNameSignedBit(string file) =>
            Signing.ClearStrongNameSignedBit(file);
 
        /// <summary>
        /// Gets the public key token from a strong named file.
        /// </summary>
        /// <param name="file">Path to file</param>
        /// <returns>Public key token</returns>
        public static int GetStrongNameTokenFromAssembly(string file, out string tokenStr) =>
            Signing.GetStrongNameTokenFromAssembly(file, out tokenStr);
 
        /// <summary>
        /// Strong names an existing previously signed or delay-signed binary with keyfile.
        /// Fall back to legacy signing if available and new signing fails.
        /// </summary>
        /// <param name="file">Path to file to sign</param>
        /// <param name="keyFile">Path to key pair.</param>
        /// <param name="snPath">Optional path to sn.exe</param>
        /// <returns>True if the file was signed successfully, false otherwise</returns>
        public static bool Sign(string file, string keyFile, string snPath = null) =>
            Signing.Sign(file, keyFile, snPath);
 
        /// <summary>
        /// Strong names an existing previously signed or delay-signed binary with keyfile
        //  using sn.exe instead of the custom implementation.
        /// </summary>
        /// <param name="file">Path to file</param>
        /// <param name="snPath">sn.exe path</param>
        /// <returns>True if the file is strong named, false otherwise.</returns>
        public static bool Sign_Legacy(string file, string keyfile,  string snPath) =>
            Signing.Sign_Legacy(file, keyfile, snPath);
 
        /// <summary>
        /// Given a key file, sets the strong name in the managed binary
        /// </summary>
        /// <param name="peStream"></param>
        /// <param name="keyFile"></param>
        /// <exception cref="InvalidOperationException"></exception>
        /// <exception cref="Exception"></exception>
        public static void Sign(Stream peStream, string keyFile) =>
            Signing.Sign(peStream, keyFile);
 
        // Internal for testing to avoid having to write a file to disk.
        internal static bool IsSigned(Stream peStream) =>
            Verification.IsSigned(peStream);
    }
}