PIbd-21_Ihonkina_E.S._PrecastConcretePlant/PrecastConcretePlantBusinessLogic/BusinessLogic/WorkModeling.cs

using Microsoft.Extensions.Logging;
using PrecastConcretePlantContracts.BindingModels;
using PrecastConcretePlantContracts.BusinessLogicsContracts;
using PrecastConcretePlantContracts.SearchModels;
using PrecastConcretePlantContracts.ViewModels;
using PrecastConcretePlantDataModels.Enums;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace PrecastConcretePlantBusinessLogic.BusinessLogic
{
    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 { Statuses = new() { OrderStatus.Принят, OrderStatus.Выполняется,OrderStatus.Ожидание } });
            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 || implementer == null)
			{
				return;
			}
			await RunOrderInWork(implementer, orders);

			await Task.Run(() =>
			{
				foreach (var order in orders.Where(x => x.Status == OrderStatus.Ожидание && x.ImplementerId == implementer.Id))
				{
					try
					{
						_orderLogic.DeliveryOrder(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));
				}
			});

			await RunOrderInWork(implementer, orders);

			await Task.Run(() =>
			{
				foreach (var order in orders.Where(x => x.Status == OrderStatus.Принят))
				{
					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.DeliveryOrder(new OrderBindingModel
						{
							Id = order.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;
					}
				}
			});
		}
		private async Task RunOrderInWork(ImplementerViewModel implementer, List<OrderViewModel> allOrders)
        {
            if (_orderLogic == null || implementer == null || allOrders == null || allOrders.Count == 0)
            {
                return;
            }
            try
            {
                var runOrder = await Task.Run(() => allOrders.FirstOrDefault(x => x.ImplementerId == implementer.Id && x.Status == OrderStatus.Выполняется));
                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.DeliveryOrder(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;
            }
        }
    }
}