private MailBox ProcessMailbox(MailBox mailbox, TasksConfig tasksConfig, CancellationToken cancelToken)
        {
            var taskLogger = LoggerFactory.GetLogger(LoggerFactory.LoggerType.Log4Net, "Task_" + Task.CurrentId);

            taskLogger.Info(
                "ProcessMailbox(Tenant = {0}, MailboxId = {1} Address = '{2}') Is {3}",
                mailbox.TenantId, mailbox.MailBoxId,
                mailbox.EMail, mailbox.Active ? "Active" : "Inactive");

            var manager = new MailBoxManager(taskLogger)
            {
                AuthErrorWarningTimeout = tasksConfig.AuthErrorWarningTimeout,
                AuthErrorDisableTimeout = tasksConfig.AuthErrorDisableMailboxTimeout
            };

            try
            {
                using (var client = new MailClient(mailbox, cancelToken, _tasksConfig.TcpTimeout, _tasksConfig.SslCertificateErrorsPermit, taskLogger))
                {
                    client.Authenticated += ClientOnAuthenticated;
                    client.GetMessage    += ClientOnGetMessage;

                    client.Aggregate(tasksConfig, tasksConfig.MaxMessagesPerSession);

                    client.GetMessage    -= ClientOnGetMessage;
                    client.Authenticated -= ClientOnAuthenticated;
                }

                taskLogger.Info("Mailbox '{0}' has been processed.", mailbox.EMail);
            }
            catch (OperationCanceledException)
            {
                taskLogger.Info("Task canceled.");
                if (_tasksConfig.EnableSignalr)
                {
                    NotifySignalr(mailbox, taskLogger);
                }
            }
            catch (AuthenticationException authEx)
            {
                taskLogger.Error(
                    "ProcessMailbox(Tenant = {0}, MailboxId = {1}, Address = '{2}')\r\nException: {3}\r\n",
                    mailbox.TenantId, mailbox.MailBoxId, mailbox.EMail, authEx.ToStringDescriptive());

                if (!mailbox.AuthErrorDate.HasValue)
                {
                    manager.SetMailboxAuthError(mailbox, true);
                }
            }
            catch (Exception ex)
            {
                taskLogger.Error(
                    "ProcessMailbox(Tenant = {0}, MailboxId = {1}, Address = '{2}')\r\nException: {3}\r\n",
                    mailbox.TenantId, mailbox.MailBoxId, mailbox.EMail,
                    ex is ImapProtocolException || ex is Pop3ProtocolException ? ex.Message : ex.ToString());
            }

            return(mailbox);
        }
        private void ProcessMailbox(MailClient client, TasksConfig tasksConfig)
        {
            var mailbox = client.Account;

            Stopwatch watch = null;

            if (_tasksConfig.CollectStatistics)
            {
                watch = new Stopwatch();
                watch.Start();
            }

            var failed = false;

            var taskLogger = LoggerFactory.GetLogger(LoggerFactory.LoggerType.Log4Net,
                                                     string.Format("Mbox_{0} Task_{1}", mailbox.MailBoxId, Task.CurrentId));

            taskLogger.Info(
                "ProcessMailbox(Tenant = {0}, MailboxId = {1} Address = '{2}') Is {3}",
                mailbox.TenantId, mailbox.MailBoxId,
                mailbox.EMail, mailbox.Active ? "Active" : "Inactive");

            try
            {
                client.Log = taskLogger;

                client.GetMessage += ClientOnGetMessage;

                client.Aggregate(tasksConfig, tasksConfig.MaxMessagesPerSession);
            }
            catch (OperationCanceledException)
            {
                taskLogger.Info(
                    "[CANCEL] ProcessMailbox(Tenant = {0}, MailboxId = {1}, Address = '{2}')",
                    mailbox.TenantId, mailbox.MailBoxId, mailbox.EMail);

                NotifySignalrIfNeed(mailbox, taskLogger);
            }
            catch (Exception ex)
            {
                taskLogger.Error(
                    "ProcessMailbox(Tenant = {0}, MailboxId = {1}, Address = '{2}')\r\nException: {3}\r\n",
                    mailbox.TenantId, mailbox.MailBoxId, mailbox.EMail,
                    ex is ImapProtocolException || ex is Pop3ProtocolException ? ex.Message : ex.ToString());

                failed = true;
            }
            finally
            {
                CloseMailClient(client, mailbox, _log);

                if (_tasksConfig.CollectStatistics && watch != null)
                {
                    watch.Stop();

                    LogStat(PROCESS_MAILBOX, mailbox, watch.Elapsed, failed);
                }
            }

            var manager = new MailBoxManager(taskLogger);

            var state = GetMailboxState(manager, mailbox, taskLogger);

            switch (state)
            {
            case MailboxState.NoChanges:
                taskLogger.Info("MailBox with id={0} not changed.", mailbox.MailBoxId);
                break;

            case MailboxState.Disabled:
                taskLogger.Info("MailBox with id={0} is deactivated.", mailbox.MailBoxId);
                break;

            case MailboxState.Deleted:
                taskLogger.Info("MailBox with id={0} is removed.", mailbox.MailBoxId);

                try
                {
                    taskLogger.Info("RemoveMailBox(id={0}) >> Try clear new data from removed mailbox", mailbox.MailBoxId);
                    manager.RemoveMailBox(mailbox);
                }
                catch (Exception exRem)
                {
                    taskLogger.Info(
                        "[REMOVE] ProcessMailbox->RemoveMailBox(Tenant = {0}, MailboxId = {1}, Address = '{2}') Exception: {3}",
                        mailbox.TenantId, mailbox.MailBoxId, mailbox.EMail, exRem.Message);
                }
                break;

            case MailboxState.DateChanged:
                taskLogger.Info("MailBox with id={0}: beginDate was changed.", mailbox.MailBoxId);
                break;

            default:
                throw new ArgumentOutOfRangeException();
            }

            taskLogger.Info("Mailbox '{0}' has been processed.", mailbox.EMail);
        }