using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Configs;
using BenchmarkDotNet.Running;
using System.Threading;
using System.Threading.Tasks;
using BenchmarkDotNet.Diagnosers;
using Perfolizer.Horology;
using BenchmarkDotNet.Columns;
using System.Globalization;
using BenchmarkDotNet.Reports;

[MemoryDiagnoser]
public class Program
{
    public static void Main(string[] args) =>
        BenchmarkSwitcher.FromAssembly(typeof(Program).Assembly).Run(args,
            DefaultConfig.Instance.WithSummaryStyle(new SummaryStyle(CultureInfo.InvariantCulture,
                printUnitsInHeader: false,
                sizeUnit: SizeUnit.B,
                timeUnit: TimeUnit.Nanosecond,
                printZeroValuesInContent: true)));

    [Benchmark]
    public Task CanceledWithAsync()
    {
        var cts = new CancellationTokenSource();
        Task<bool> t = DelayWithAsync(1_000_000, cts.Token);
        cts.Cancel();
        return t.ContinueWith(_ => _, CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);
    }

    [Benchmark]
    public Task CanceledWithContinueWith()
    {
        var cts = new CancellationTokenSource();
        Task<bool> t = DelayWithContinueWith(1_000_000, cts.Token);
        cts.Cancel();
        return t.ContinueWith(_ => _, CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);
    }

    [Benchmark]
    public Task<bool> Delay0WithAsync() => DelayWithAsync(0, default);

    [Benchmark]
    public Task<bool> Delay0ContinueWith() => DelayWithContinueWith(0, default);

    [Benchmark]
    public Task<bool> Delay1WithAsync() => DelayWithAsync(1, default);

    [Benchmark]
    public Task<bool> Delay1ContinueWith() => DelayWithContinueWith(1, default);

    private static async Task<bool> DelayWithAsync(int delay, CancellationToken cancellationToken)
    {
        await Task.Delay(delay, cancellationToken).ConfigureAwait(false);
        return true;
    }

    private static Task<bool> DelayWithContinueWith(int delay, CancellationToken cancellationToken)
    {
        if (cancellationToken.IsCancellationRequested)
        {
            return Task.FromCanceled<bool>(cancellationToken);
        }

        var t = Task.Delay(delay, cancellationToken);
        if (t.IsCompleted)
        {
            return t.Status == TaskStatus.RanToCompletion ?
                SpecializedTasks.True :
                Task.FromCanceled<bool>(cancellationToken);
        }

        return t.ContinueWith(
            _ => true,
            CancellationToken.None,
            TaskContinuationOptions.ExecuteSynchronously | TaskContinuationOptions.NotOnCanceled,
            TaskScheduler.Default);
    }

    class SpecializedTasks
    {
        public static readonly Task<bool> True = Task.FromResult(true);
    }
}