namespace SukaBlyad
{
    using System;
    using System.Collections.Concurrent;
    using System.Threading;
    using System.Threading.Tasks;
    using Microsoft.Extensions.DependencyInjection;
    using Microsoft.Extensions.Hosting;
    using Microsoft.Extensions.Logging;

    public class Program
    {
        public static void Main(string[] args)
        {
            CreateHostBuilder(args).Build().Run();
        }

        public static IHostBuilder CreateHostBuilder(string[] args) =>
            Host.CreateDefaultBuilder(args)
                .ConfigureServices((hostContext, services) =>
                {
                    services.AddSingleton<SquareQueue>();
                    services.AddHostedService<SquareWorker>();
                    services.AddHostedService<AddDataWorcker>();
                });
    }

    public class SquareWorker : BackgroundService
    {
        private readonly ILogger<SquareQueue> _logger;
        private readonly SquareQueue _queue;

        public SquareWorker(ILogger<SquareQueue> logger, SquareQueue queue)
        {
            _logger = logger;
            _queue = queue;
        }

        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
        {
            while (!stoppingToken.IsCancellationRequested)
            {
                var data = await _queue.GetData();
                _logger.LogInformation($"Square of {data.Item1} and {data.Item2} = {data.Item1 * data.Item2}");
                await Task.Delay(1000, stoppingToken);
            }
        }
    }

    public class SquareQueue
    {
        ILogger<SquareQueue> _logger;

        ConcurrentQueue<(double, double)> dataQueue;
        public SquareQueue(ILogger<SquareQueue> logger)
        {
            _logger = logger;
            dataQueue = new ConcurrentQueue<(double, double)>();
        }

        public async Task<(double, double)> GetData()
        {
            await Task.Yield();
            if (dataQueue.TryDequeue(out var result))
                return result;
            return (0, 0);
        }
        public async void AddData(double a, double b)
        {
            await Task.Yield();
            dataQueue.Enqueue((a, b));
        }
    }

    public class AddDataWorcker : BackgroundService
    {
        private readonly ILogger<SquareQueue> _logger;
        private readonly SquareQueue _queue;
        Random random = new Random();

        public AddDataWorcker(ILogger<SquareQueue> logger, SquareQueue queue)
        {
            _logger = logger;
            _queue = queue;
        }

        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
        {
            while (!stoppingToken.IsCancellationRequested)
            {
                _queue.AddData(random.NextDouble() + random.Next(100), random.NextDouble() + random.Next(100));
                await Task.Delay(1000, stoppingToken);
            }
        }
    }

}