MailCleaner - A C# program to cleanup mailbox with some rules (manual)

program.cs

using System;

namespace MailCleaner
{
    using Pop3;
    using System.Collections.Generic;
    using System.IO;
    using System.Linq;
    using System.Text;
    using System.Text.RegularExpressions;
    using System.Threading.Tasks;

    static class Program
    {
        private static Int32 _totalCounter;
        private static Int32 _deletedCounter;
        private static Int32 _deleted;
        private static Int32 _processed;
        private static readonly HashSet<String> FromHashSet = new HashSet<String>();
        private static readonly HashSet<String> Processed = new HashSet<String>();

        static void Main()
        {
            Console.WriteLine("Hello World!");
            Start().Wait();
        }

        private static async Task Start()
        {
            try
            {
                for (var x = 0; x < 300; x++)
                    await DoWork();
                Console.WriteLine($"Total deleted: {_deletedCounter}");
                if (!FromHashSet.Any())
                    return;
                using (var file = File.OpenWrite($"left_{DateTime.Now:yyyy-MM-dd-HH-mm}.txt"))
                {
                    foreach (var from in FromHashSet)
                    {
                        var buffer = new UTF8Encoding(true).GetBytes($"{from}\r\n");
                        await file.WriteAsync(buffer, 0, buffer.Length);
                    }
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
            }
        }

        private static async Task DoWork()
        {
            _deleted = 0;
            _processed = 0;
            var pop = new Pop3Client();
            await pop.ConnectAsync(
                "smtp.host.com",
                "[email protected]",
                "password",
                true);

            var messages = await pop.ListAsync();
            var pop3Messages = messages as Pop3Message[] ?? messages.ToArray();
            foreach (var message in pop3Messages.Reverse())
            {
                _processed++;
                Console.WriteLine(new String('=', 100));
                await pop.RetrieveHeaderAsync(message);
                if (!Processed.Contains(message.MessageId))
                    _totalCounter++;
                try
                {
                    Console.WriteLine(DateTime.TryParse(message.Date, out var date)
                        ? $"{_totalCounter:00000} {date:dd/MM/yyyy HH:mm:ss} {Decode(message.Subject)}"
                        : $"{_totalCounter:00000} {message.Date} {Decode(message.Subject)}");
                }
                catch (Exception e)
                {
                    Console.WriteLine(e.Message);
                    Console.WriteLine(DateTime.TryParse(message.Date, out var date)
                        ? $"{_totalCounter:00000} {date:dd/MM/yyyy HH:mm:ss} {message.Subject}"
                        : $"{_totalCounter:00000} {message.Date} {message.Subject}");
                }
                Processed.Add(message.MessageId);
                await Validate(pop, message);
                if (_deleted >= 200)
                    break;
            }
            Console.WriteLine(new String('=', 100));
            await pop.DisconnectAsync();
            Console.WriteLine($"Total messages: {pop3Messages.Length}");
            Console.WriteLine($"Messages processed: {_processed}");
            Console.WriteLine($"Unique messages: {Processed.Count}");
            _deletedCounter += _deleted;
        }

        private static async Task Validate(Pop3Client pop, Pop3Message message)
        {
            if (message.From.IndexOf("@spam-domain.com", StringComparison.InvariantCultureIgnoreCase) == -1 &&
                !message.From.Equals("[email protected]") &&
                message.Subject.IndexOf("Spam subject", StringComparison.InvariantCultureIgnoreCase) == -1)
            {
                Console.WriteLine($"Message left from {message.From}");
                FromHashSet.Add(message.From);
                return;
            }
            _deleted++;
            Console.WriteLine($"Deleting message from {message.From}");
            await pop.DeleteAsync(message);
        }

        private static String Decode(String mimeString)
        {
            var regex = new Regex(@"=\?(?<charset>.*?)\?(?<encoding>[qQbB])\?(?<value>.*?)\?=");
            var encodedString = mimeString;
            var decodedString = String.Empty;

            while (encodedString.Length > 0)
            {
                var match = regex.Match(encodedString);
                if (match.Success)
                {
                    // If the match isn't at the start of the string, copy the initial few chars to the output
                    decodedString += encodedString.Substring(0, match.Index);

                    var charset = match.Groups["charset"].Value;
                    var encoding = match.Groups["encoding"].Value.ToUpper();
                    var value = match.Groups["value"].Value;

                    if (encoding.Equals("B"))
                    {
                        // Encoded value is Base-64
                        var bytes = Convert.FromBase64String(value);
                        decodedString += Encoding.GetEncoding(charset).GetString(bytes);
                    }
                    else if (encoding.Equals("Q"))
                    {
                        // Encoded value is Quoted-Printable
                        // Parse looking for =XX where XX is hexadecimal
                        var regx = new Regex("(\\=([0-9A-F][0-9A-F]))", RegexOptions.IgnoreCase);
                        decodedString += regx.Replace(value, delegate (Match m)
                        {
                            var hex = m.Groups[2].Value;
                            var iHex = Convert.ToInt32(hex, 16);

                            // Return the string in the charset defined
                            var bytes = new Byte[1];
                            bytes[0] = Convert.ToByte(iHex);
                            return Encoding.GetEncoding(charset).GetString(bytes);
                        });
                        decodedString = decodedString.Replace('_', ' ');
                    }
                    else
                    {
                        // Encoded value not known, return original string
                        // (Match should not be successful in this case, so this code may never get hit)
                        decodedString += encodedString;
                        break;
                    }

                    // Trim off up to and including the match, then we'll loop and try matching again.
                    encodedString = encodedString.Substring(match.Index + match.Length);
                }
                else
                {
                    // No match, not encoded, return original string
                    decodedString += encodedString;
                    break;
                }
            }
            return decodedString;
        }
    }
}