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

        private static IHostBuilder CreateHostBuilder(string[] args) =>
            Host.CreateDefaultBuilder(args)
                .ConfigureServices(services =>
                {
                    var builder = new ConfigurationBuilder()
                        .AddJsonFile("appsettings.json")
                        .AddJsonFile("dbsettings.json");
                    var config = builder.Build();

                    services
                        .Configure<DbConnectionOptions>(config.GetSection(nameof(DbConnectionOptions)))
                        .Configure<ImapOptions>(config.GetSection(nameof(ImapOptions)))
                        .AddTransient(
                            provider =>
                            {
                                var cnn = provider.GetService<IOptions<DbConnectionOptions>>().Value.ConnectionString;
                                var res = new NpgsqlConnection(cnn);
                                res.Open();
                                return (IDbConnection) res;
                            })
                        .AddHttpClient()
                        .UseSmartpartsData()
                        .AddMediatR(Assembly.GetExecutingAssembly())
                        .AddHostedService<EvaWorker>();
                });
    }

 public class EvaWorker : BackgroundService
    {
        private readonly IHostApplicationLifetime _hostLifetime;
        private readonly IMediator _mediator;
        private readonly ImapOptions _imapOptions;


        public EvaWorker(IHostApplicationLifetime hostLifetime, IMediator mediator, IOptions<ImapOptions> imapOptions)
        {
            _hostLifetime = hostLifetime;
            _mediator = mediator;
            _imapOptions = imapOptions.Value ?? throw new ArgumentException(nameof(imapOptions));
        }

        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
        {
            var tasks = FetchTasksForOrdering();

            _hostLifetime.StopApplication();
        }

        private IEnumerable<TaskForOrdering> FetchTasksForOrdering()
        {
            using var client = GetImapClient();
            var result = new List<TaskForOrdering>();
            var toplevel = client.GetFolder(client.PersonalNamespaces[0]);
            var subfolders = toplevel.GetSubfolders().ToList();
            var archive = subfolders
                              .SingleOrDefault(sf => sf.Name == _imapOptions.ArchiveFolderName) ??
                          toplevel.Create(_imapOptions.ArchiveFolderName, true);

            foreach (var uid in client.Inbox.Search(SearchQuery.DeliveredAfter(DateTime.Now.AddDays(-1))))
            {
                var message = client.Inbox.GetMessage(uid);
                var attaches = message.BodyParts
                    .Where(a => ((MimePart) a).FileName != null)
                    .Select(a => (MimePart) a)
                    .ToList();
                var tasks = attaches.Select(a => GetTaskForOrderingFromEmail(message, a)).Where(a => a != default);
                result.AddRange(tasks);
                client.Inbox.AddFlags(uid, MessageFlags.Seen, true);
                client.Inbox.MoveTo(uid, archive);
            }

            return result;
        }

        private static TaskForOrdering GetTaskForOrderingFromEmail(MimeMessage msg, MimePart attach)
        {
            try
            {
                msg.Subject = msg.Subject.DecodeSubject(msg.Body.ContentType.Charset);
                var fileName = attach.FileName;
                var fileExtension = Path.GetExtension(fileName).Trim('.');

                using var stream = new MemoryStream();
                attach.Content.DecodeTo(stream);
                var res = new TaskForOrdering
                (
                    stream.ToArray(),
                    fileExtension,
                    msg.From.Mailboxes.SingleOrDefault()?.Address,
                    msg.Subject,
                    fileName
                );
                return res;
            }
            catch
            {
                return default;
            }
        }

        private ImapClient GetImapClient()
        {
            var client = new ImapClient
            {
                Timeout = (int) TimeSpan.FromMinutes(2).TotalMilliseconds
            };

            client.Connect(_imapOptions.Host, _imapOptions.Port, _imapOptions.UseSsl);
            client.AuthenticationMechanisms.Remove("XOAUTH2");
            client.Authenticate(_imapOptions.Login, _imapOptions.Password);
            client.Inbox.Open(FolderAccess.ReadWrite);
            return client;
        }
    }

public class TaskForOrdering
    {
        public byte[] File { get;  }
        public string FileExtension { get;  }
        public string SenderAddress { get; }
        public string Subject { get;  }
        public string Filename { get; }

        public TaskForOrdering(
            byte[] file,
            string fileExtension,
            string senderAddress,
            string subject,
            string filename)
        {
            File = file;
            FileExtension = fileExtension;
            SenderAddress = senderAddress;
            Subject = subject;
            Filename = filename;
        }
    }

  public class ImapOptions
    {
        public string Host { get; set; }
        public int Port { get; set; }
        public bool UseSsl { get; set; }
        public string Login { get; set; }
        public string Password { get; set; }
        public string ArchiveFolderName { get; set; }
    }