using GAMongo.Core.Domain.Logging;
using GAMongo.Core.Domain.Tasks;
using GAMongo.Services.Logging;
using System;
using GAMongo.Core.Data;
using MongoDB.Driver.Linq;
using MongoDB.Driver;
using System.Collections.Generic;
using System.Threading.Tasks;
using System.Linq;
using GAMongo.Data;

namespace GAMongo.Services.Tasks
{
    public partial class UpdateOrdersTask : ScheduleTask, IScheduleTask
    {
        private readonly ILogger _logger;
        private readonly IRepository<Core.Domain.Orders.Order> _orderRepository;
        private readonly DataSettingsManager _dataSettingsManager;

        public UpdateOrdersTask(IRepository<Core.Domain.Orders.Order> orderRepository,
                                              ILogger logger)
        {
            this._orderRepository = orderRepository;
            this._dataSettingsManager = new DataSettingsManager();
            this._logger = logger;
        }

        public void Execute()
        {
            int procCount = Environment.ProcessorCount;
            var orders = _orderRepository.Table.Where(p => p.OrderType != Core.Domain.Orders.OrderType.Offline).ToList();
            if(orders.Count < procCount*100)
            {
                //Обработка в одном потоке
                try
                {
                    InsertLog(OrderTypeUpdate(orders, _orderRepository));
                }
                catch(Exception ex)
                {
                    InsertLog(errors: new List<string>() { ex.Message });
                }
            }
            else
            {
                //Мультипоточная обработка
                var dataProviderSettings = _dataSettingsManager.LoadSettings();
                int cntPartListOrder = orders.Count / procCount;
                List<Task<int>> tasks = new List<Task<int>>();
                List<string> errors = new List<string>();

                for (var a = 0; a < procCount; a++)
                {
                    int i = a;
                    tasks.Add(Task.Run(() => OrderTypeUpdate(orders.GetRange(cntPartListOrder * i, (i == procCount - 1 && orders.Count % 2 != 0) ? cntPartListOrder + 1 : cntPartListOrder),
                        new MongoDBRepository<Core.Domain.Orders.Order>(dataProviderSettings.DataConnectionString))));
                }

                try
                {
                    Task.WaitAll(tasks.ToArray());
                }
                catch (AggregateException ae)
                {
                    foreach (var e in ae.Flatten().InnerExceptions)
                    {
                        errors.Add(e.Message);
                    }
                }

                var cnt = tasks.Where(p => p.Status != TaskStatus.Faulted).Select(p => p.Result).Sum();
                InsertLog(cnt, errors);
            }
        }

        private int OrderTypeUpdate(List<Core.Domain.Orders.Order> orders, IRepository<Core.Domain.Orders.Order> repository)
        {
            orders.ForEach(o => {
                o.StoreId = "125";
                o.OrderType = Core.Domain.Orders.OrderType.Online;
            });
            repository.Update(orders);
            return orders.Count;
        }

        protected void InsertLog(int counter = 0, List<string> errors = null)
        {
            string log = (errors?.Count > 0) ? "Checks and Updates Associated with a field OrderType (orders) : Error during execute. Updated " + counter + " records."
                : "Checks and Updates Associated with a field OrderType (orders) : Successfully completed. Updated " + counter + " records.";

            _logger.InsertLog((errors?.Count > 0 ? LogLevel.Error : LogLevel.Information), log, errors?.Count > 0 ? String.Join(",", errors.ToArray()) : null);
        }
    }
}