// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
 
#nullable disable
 
using System.Reflection;
using System.Transactions;
using Microsoft.DotNet.Cli.Utils;
 
namespace Microsoft.DotNet.Cli;
 
public sealed class TransactionalAction
{
    static TransactionalAction()
    {
        DisableTransactionTimeoutUpperLimit();
    }
 
    private class EnlistmentNotification(Action commit, Action rollback) : IEnlistmentNotification
    {
        private Action _commit = commit;
        private Action _rollback = rollback;
 
        public void Commit(Enlistment enlistment)
        {
            if (_commit != null)
            {
                _commit();
                _commit = null;
            }
 
            enlistment.Done();
        }
 
        public void InDoubt(Enlistment enlistment)
        {
            Rollback(enlistment);
        }
 
        public void Prepare(PreparingEnlistment enlistment)
        {
            enlistment.Prepared();
        }
 
        public void Rollback(Enlistment enlistment)
        {
            if (_rollback != null)
            {
                _rollback();
                _rollback = null;
            }
 
            enlistment.Done();
        }
    }
 
    public static T Run<T>(
        Func<T> action,
        Action commit = null,
        Action rollback = null)
    {
        if (action == null)
        {
            throw new ArgumentNullException(nameof(action));
        }
 
        // This automatically inherits any ambient transaction
        // If a transaction is inherited, completing this scope will be a no-op
        T result = default(T);
        try
        {
            using (var scope = new TransactionScope(
                TransactionScopeOption.Required,
                TimeSpan.Zero))
            {
                Transaction.Current.EnlistVolatile(
                    new EnlistmentNotification(commit, rollback),
                    EnlistmentOptions.None);
 
                result = action();
 
                scope.Complete();
            }
 
            return result;
        }
        catch (TransactionAbortedException ex)
        {
            Reporter.Verbose.WriteLine(string.Format("TransactionAbortedException Message: {0}", ex.Message));
            Reporter.Verbose.WriteLine(
                $"Inner Exception Message: {ex?.InnerException?.Message + "---" + ex?.InnerException}");
            throw;
        }
    }
 
    private static void SetTransactionManagerField(string fieldName, object value)
    {
        typeof(TransactionManager).GetField(fieldName, BindingFlags.NonPublic | BindingFlags.Static)
            .SetValue(null, value);
    }
 
    // https://github.com/dotnet/sdk/issues/21101
    // we should use the proper API once it is available
    public static void DisableTransactionTimeoutUpperLimit()
    {
        SetTransactionManagerField("s_cachedMaxTimeout", true);
        SetTransactionManagerField("s_maximumTimeout", TimeSpan.Zero);
    }
 
    public static void Run(
        Action action,
        Action commit = null,
        Action rollback = null)
    {
        Run<object>(
            action: () =>
            {
                action();
                return null;
            },
            commit: commit,
            rollback: rollback);
    }
}