PIbd-22_Bazunov_A.I._SushiBar/SushiBar/SushiBarBusinessLogic/BusinessLogics/WorkModeling.cs

using DocumentFormat.OpenXml.Drawing.Charts;
using Microsoft.Extensions.Logging;
using SushiBarContracts.BindingModels;
using SushiBarContracts.BusinessLogicsContracts;
using SushiBarContracts.SearchModels;
using SushiBarContracts.ViewModels;
using SushiBarDataModels.Enums;

namespace SushiBarBusinessLogic.BusinessLogics;

public class WorkModeling : IWorkProcess
{
    private readonly ILogger _logger;
    private readonly Random _rnd;
    private IOrderLogic? _orderLogic;
    
    public WorkModeling(ILogger<WorkModeling> logger)
    {
        _logger = logger;
        _rnd = new Random(1000);
    }
    
    public void DoWork(IImplementerLogic implementerLogic, IOrderLogic orderLogic)
    {
        _orderLogic = orderLogic;
        var implementers = implementerLogic.ReadList(null);
        if (implementers == null)
        {
            _logger.LogWarning("DoWork. Implementers is null");
            return;
        }
        var orders = _orderLogic.ReadList(new OrderSearchModel { Status = OrderStatus.Accepted });
        if (orders == null || orders.Count == 0)
        {
            _logger.LogWarning("DoWork. Orders is null or empty");
            return;
        }
        _logger.LogDebug("DoWork for {Count} orders", orders.Count);
        foreach (var implementer in implementers)
        {
            Task.Run(() => WorkerWorkAsync(implementer, orders));
        }
    }
    
    private async Task WorkerWorkAsync(ImplementerViewModel implementer,
        List<OrderViewModel> orders)
    {
        if (_orderLogic == null)
        {
            return;
        }
        await RunOrderInWork(implementer);
        await Task.Run(() =>
        {
            foreach (var order in orders)
            {
                try
                {
                    _logger.LogDebug("DoWork. Worker {Id} try get order {Order}", implementer.Id, order.Id);
                    _orderLogic.TakeOrderInWork(new OrderBindingModel
                    {
                        Id = order.Id,
                        ImplementerId = implementer.Id
                    });
                    Thread.Sleep(implementer.WorkExperience * _rnd.Next(100,
                        1000) * order.Count);
                    _logger.LogDebug("DoWork. Worker {Id} finish order {Order}", implementer.Id, order.Id);
                    _orderLogic.FinishOrder(new OrderBindingModel
                    {
                        Id = order.Id
                    });
                }
                catch (InvalidOperationException ex)
                {
                    _logger.LogWarning(ex, "Error try get work");
                }
                catch (Exception ex)
                {
                    _logger.LogError(ex, "Error while do work");
                    throw;
                }
                Thread.Sleep(implementer.Qualification * _rnd.Next(10, 100));
            }
        });
    }
    
    private async Task RunOrderInWork(ImplementerViewModel implementer)
    {
        if (_orderLogic == null)
        {
            return;
        }
        try
        {
            var runOrder = await Task.Run(() => _orderLogic.ReadElement(new
                OrderSearchModel
                {
                    ImplementerId = implementer.Id,
                    Status = OrderStatus.Performed
                }));
            if (runOrder == null)
            {
                return;
            }
            _logger.LogDebug("DoWork. Worker {Id} back to order {Order}",
                implementer.Id, runOrder.Id);
            Thread.Sleep(implementer.WorkExperience * _rnd.Next(100, 300) *
                         runOrder.Count);
            _logger.LogDebug("DoWork. Worker {Id} finish order {Order}",
                implementer.Id, runOrder.Id);
            _orderLogic.FinishOrder(new OrderBindingModel
            {
                Id = runOrder.Id
            });
            Thread.Sleep(implementer.Qualification * _rnd.Next(10, 100));
        }
        catch (InvalidOperationException ex)
        {
            _logger.LogWarning(ex, "Error try get work");
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error while do work");
            throw;
        }
    }
}