// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
 
using System;
using System.Diagnostics;
using System.Threading;
using Roslyn.Utilities;
 
namespace Microsoft.CodeAnalysis;
 
/// <summary>
/// VersionStamp should be only used to compare versions returned by same API.
/// </summary>
public readonly struct VersionStamp : IEquatable<VersionStamp>
{
    public static VersionStamp Default => default;
 
    private const int GlobalVersionMarker = -1;
    private const int InitialGlobalVersion = 10000;
 
    /// <summary>
    /// global counter to avoid collision within same session. 
    /// it starts with a big initial number just for a clarity in debugging
    /// </summary>
    private static int s_globalVersion = InitialGlobalVersion;
 
    /// <summary>
    /// time stamp
    /// </summary>
    private readonly DateTime _utcLastModified;
 
    /// <summary>
    /// indicate whether there was a collision on same item
    /// </summary>
    private readonly int _localIncrement;
 
    /// <summary>
    /// unique version in same session
    /// </summary>
    private readonly int _globalIncrement;
 
    private VersionStamp(DateTime utcLastModified)
        : this(utcLastModified, 0)
    {
    }
 
    private VersionStamp(DateTime utcLastModified, int localIncrement)
        : this(utcLastModified, localIncrement, GetNextGlobalVersion())
    {
    }
 
    private VersionStamp(DateTime utcLastModified, int localIncrement, int globalIncrement)
    {
        if (utcLastModified != default && utcLastModified.Kind != DateTimeKind.Utc)
        {
            throw new ArgumentException(WorkspacesResources.DateTimeKind_must_be_Utc, nameof(utcLastModified));
        }
 
        _utcLastModified = utcLastModified;
        _localIncrement = localIncrement;
        _globalIncrement = globalIncrement;
    }
 
    /// <summary>
    /// Creates a new instance of a VersionStamp.
    /// </summary>
    public static VersionStamp Create()
        => new(DateTime.UtcNow);
 
    /// <summary>
    /// Creates a new instance of a version stamp based on the specified DateTime.
    /// </summary>
    public static VersionStamp Create(DateTime utcTimeLastModified)
        => new(utcTimeLastModified);
 
    /// <summary>
    /// compare two different versions and return either one of the versions if there is no collision, otherwise, create a new version
    /// that can be used later to compare versions between different items
    /// </summary>
    public VersionStamp GetNewerVersion(VersionStamp version)
    {
        // * NOTE *
        // in current design/implementation, there are 4 possible ways for a version to be created.
        //
        // 1. created from a file stamp (most likely by starting a new session). "increment" will have 0 as value
        // 2. created by modifying existing item (text changes, project changes etc).
        //    "increment" will have either 0 or previous increment + 1 if there was a collision.
        // 3. created from deserialization (probably by using persistent service).
        // 4. created by accumulating versions of multiple items.
        //
        // and this method is the one that is responsible for #4 case.
 
        if (_utcLastModified > version._utcLastModified)
        {
            return this;
        }
 
        if (_utcLastModified == version._utcLastModified)
        {
            var thisGlobalVersion = GetGlobalVersion(this);
            var thatGlobalVersion = GetGlobalVersion(version);
 
            if (thisGlobalVersion == thatGlobalVersion)
            {
                // given versions are same one
                return this;
            }
 
            // mark it as global version
            // global version can't be moved to newer version.
            return new VersionStamp(_utcLastModified, (thisGlobalVersion > thatGlobalVersion) ? thisGlobalVersion : thatGlobalVersion, GlobalVersionMarker);
        }
 
        return version;
    }
 
    /// <summary>
    /// Gets a new VersionStamp that is guaranteed to be newer than its base one
    /// this should only be used for same item to move it to newer version
    /// </summary>
    public VersionStamp GetNewerVersion()
    {
        // global version can't be moved to newer version
        Debug.Assert(_globalIncrement != GlobalVersionMarker);
 
        var now = DateTime.UtcNow;
        var incr = (now == _utcLastModified) ? _localIncrement + 1 : 0;
 
        return new VersionStamp(now, incr);
    }
 
    /// <summary>
    /// Returns the serialized text form of the VersionStamp.
    /// </summary>
    public override string ToString()
    {
        // 'o' is the roundtrip format that captures the most detail.
        return _utcLastModified.ToString("o") + "-" + _globalIncrement + "-" + _localIncrement;
    }
 
    public override int GetHashCode()
        => Hash.Combine(_utcLastModified.GetHashCode(), _localIncrement);
 
    public override bool Equals(object? obj)
    {
        if (obj is VersionStamp v)
        {
            return this.Equals(v);
        }
 
        return false;
    }
 
    public bool Equals(VersionStamp version)
    {
        if (_utcLastModified == version._utcLastModified)
        {
            return GetGlobalVersion(this) == GetGlobalVersion(version);
        }
 
        return false;
    }
 
    public static bool operator ==(VersionStamp left, VersionStamp right)
        => left.Equals(right);
 
    public static bool operator !=(VersionStamp left, VersionStamp right)
        => !left.Equals(right);
 
    private static int GetGlobalVersion(VersionStamp version)
    {
        // global increment < 0 means it is a global version which has its global increment in local increment
        return version._globalIncrement >= 0 ? version._globalIncrement : version._localIncrement;
    }
 
    private static int GetNextGlobalVersion()
    {
        // REVIEW: not sure what is best way to wrap it when it overflows. should I just throw or don't care.
        // with 50ms (typing) as an interval for a new version, it gives more than 1 year before int32 to overflow.
        // with 5ms as an interval, it gives more than 120 days before it overflows.
        // since global version is only for per VS session, I think we don't need to worry about overflow.
        // or we could use Int64 which will give more than a million years turn around even on 1ms interval.
 
        // this will let versions to be compared safely between multiple items
        // without worrying about collision within same session
        var globalVersion = Interlocked.Increment(ref VersionStamp.s_globalVersion);
 
        return globalVersion;
    }
 
    internal TestAccessor GetTestAccessor()
        => new(this);
 
    internal readonly struct TestAccessor(VersionStamp versionStamp)
    {
 
        /// <summary>
        /// True if this VersionStamp is newer than the specified one.
        /// </summary>
        internal bool IsNewerThan(in VersionStamp version)
        {
            if (versionStamp._utcLastModified > version._utcLastModified)
            {
                return true;
            }
 
            if (versionStamp._utcLastModified == version._utcLastModified)
            {
                return GetGlobalVersion(versionStamp) > GetGlobalVersion(version);
            }
 
            return false;
        }
    }
}