// 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;
using System.Reflection.Metadata;
using System.Reflection.PortableExecutable;

namespace Microsoft.DotNet.Build.Tasks.Packaging
{
    public static class VersionUtility
    {
        public static readonly Version MaxVersion = new Version(int.MaxValue, int.MaxValue, int.MaxValue, int.MaxValue);

        public static bool IsCompatibleApiVersion(Version referenceVersion, Version definitionVersion)
        {
            return (referenceVersion.Major == definitionVersion.Major &&
                referenceVersion.Minor == definitionVersion.Minor &&
                    (referenceVersion.Build < definitionVersion.Build || // If the Build number is greater, then we don't need to check revision
                    (referenceVersion.Build == definitionVersion.Build && referenceVersion.Revision <= definitionVersion.Revision)));
        }


        public static Version GetAssemblyVersion(string assemblyPath)
        {
            using (var fileStream = new FileStream(assemblyPath, FileMode.Open, FileAccess.Read, FileShare.Delete | FileShare.Read))
            {
                return GetAssemblyVersion(fileStream);
            }
        }

        public static Version GetAssemblyVersion(Stream assemblyStream)
        {
            Version result = null;
            try
            {
                using (PEReader peReader = new PEReader(assemblyStream, PEStreamOptions.LeaveOpen))
                {
                    if (peReader.HasMetadata)
                    {
                        MetadataReader reader = peReader.GetMetadataReader();
                        if (reader.IsAssembly)
                        {
                            result = reader.GetAssemblyDefinition().Version;
                        }
                    }
                }
            }
            catch (BadImageFormatException)
            {
                // not a PE
            }

            return result;
        }

        public static Version As3PartVersion(Version version)
        {
            if (version == null)
                return null;

            int build = version.Build;

            if (build == -1)
            {
                // we have a 2-part version
                build = 0;
            }
            else if (version.Revision == -1)
            {
                // we already have a 3-part version
                return version;
            }

            return new Version(version.Major, version.Minor, build);
        }

        public static Version As2PartVersion(Version version)
        {
            if (version == null)
                return null;

            if (version.Build == -1)
            {
                // we already have a 2-part version
                return version;
            }
            return new Version(version.Major, version.Minor);
        }

        public static Version As4PartVersion(Version version)
        {
            if (version == null)
                return null;

            int build = version.Build, revision = version.Revision;

            if (build == -1)
            {
                // we have a 2-part version
                build = 0;
                revision = 0;
            }
            else if (revision == -1)
            {
                // we have a 3-part version
                revision = 0;
            }
            else
            {
                // we already have a 4-part version
                return version;
            }

            return new Version(version.Major, version.Minor, build, revision);
        }
    }
}