Update version

Fixes #120

.gitignore

@@ -258,7 +258,4 @@ paket-files/
 
 # Python Tools for Visual Studio (PTVS)
 __pycache__/
-*.pyc
-
-# Ammy auto-generated XAML
-*.g.xaml
+*.pyc

Changelog.md

@@ -1,3 +1,78 @@
+### v2.10 (03-Mar-2019)
+
+- [HTML] Reworked the entire markdown parsing engine which fixes numerous rendering inconsistencies (over 15 issues fixed).
+- [HTML] Added support for animated emojis.
+- [HTML] Standard emojis are now rendered using Twemoji, the same image set that Discord uses.
+- [HTML] Fixed an issue where video attachments would render incorrectly.
+- [HTML] Minor fixes in styling.
+- [GUI] Aggregated export progress is now shown in the taskbar.
+- [GUI] Checkmarks are now displayed next to channels that are selected.
+- [CLI] Added progress reporting when exporting chat logs.
+
+### v2.9.1 (10-Feb-2019)
+
+- Fixed an issue where some of the last messages in a channel would sometimes not get exported.
+
+### v2.9 (09-Feb-2019)
+
+- Added categories to channel list in GUI. Channels are now also grouped by category.
+- Added ability to export multiple channels at once in GUI by selecting them with shift or ctrl keys.
+- Added CLI command to export all available channels in a guild (`exportguild`).
+- Added CLI command to export all direct message channels (`exportdm`).
+- Added retry policy for 503 status code errors to prevent random crashes.
+- Changed how channels are exported in GUI. Now you need to select them first and then click a button to export. You can also double click a single channel to export it as before.
+- Improved default file name generation by adding date ranges and channel ID to the file name.
+- Improved naming of files exported with partitioning.
+- Improved usage instructions.
+- Improved GUI layout and styling.
+- Fixed an issue where dialogs would sometimes appear over other windows.
+- Fixed an issue where launching DiscordChatExporter from Windows Start Menu would make it crash.
+
+### v2.8 (03-Nov-2018)
+
+- Added support for partitioning which lets you split the output into multiple files by setting the partition message limit (`-p` parameter for CLI).
+- Exported file will no longer open automatically on completion.
+- Reduced amount of memory used during exporting.
+- Disabled message grouping in PlainText export.
+- Improved encoding of newlines in CSV export.
+- Improved error messages in the GUI app during crashes.
+
+### v2.7 (14-Sep-2018)
+
+- Updated instructions on how to obtain the user token.
+- Expanded CLI with new commands: `channels` (get a list of channels in a guild), `dm` (get a list of DM channels), `guilds` (get a list of guilds), on top of `export` (export chatlog).
+- Improved help text and error messages in CLI.
+- In CLI, the file name will be automatically generated if the provided output file path is a directory.
+
+### v2.6 (25-Jul-2018)
+
+- Added support for bot tokens as an alternative to user tokens. For GUI, use the button in the top-left to switch between user and bot token. For CLI, pass the `--bot` switch to indicate that the given token is a bot token.
+- Added support for animated avatars.
+
+### v2.5.1 (01-Jul-2018)
+
+- Fixed a bug that would prevent timestamps from rendering properly in CSV and PlainText exports.
+- Fixed incorrect layout in CSV export.
+- Improved readability of PlainText export.
+
+### v2.5 (28-Jun-2018)
+
+- Added support for embeds and webhooks (HTML only).
+- Implemented progress reporting when downloading messages.
+- Added support for reactions (HTML only).
+- Selected date range is now shown in the export (HTML and PlainText).
+- Added placeholders for guild icons to display while the icons are loading.
+- Added support for jumbo emojis (custom emojis only).
+- Added basic retry policy for 429 error responses.
+- Added validation for from/to dates in the UI which prevents choosing invalid date ranges.
+- Added an error message when trying to export a deleted channel.
+
+### v2.4.1 (15-Apr-2018)
+
+- Added CSV export format.
+- Channels are now ordered by name in the UI.
+- Exported file is now always opened upon completion.
+
 ### v2.4 (08-Apr-2018)
 
 - Added channel topic to output.

Deploy/Prepare.ps1

@@ -8,4 +8,4 @@ $files | Compress-Archive -DestinationPath "$PSScriptRoot\bin\DiscordChatExporte
 # CLI
 $files = @()
 $files += Get-ChildItem -Path "$PSScriptRoot\..\DiscordChatExporter.Cli\bin\Release\net461\*" -Include "*.exe", "*.dll", "*.config"
-$files | Compress-Archive -DestinationPath "$PSScriptRoot\bin\DiscordChatExporter.Cli.zip" -Force
+$files | Compress-Archive -DestinationPath "$PSScriptRoot\bin\DiscordChatExporter.CLI.zip" -Force

DiscordChatExporter.Cli/CliOptions.cs

@@ -1,24 +0,0 @@
-using System;
-using DiscordChatExporter.Core.Models;
-
-namespace DiscordChatExporter.Cli
-{
-    public class CliOptions
-    {
-        public string Token { get; set; }
-
-        public string ChannelId { get; set; }
-
-        public ExportFormat ExportFormat { get; set; }
-
-        public string FilePath { get; set; }
-
-        public DateTime? From { get; set; }
-
-        public DateTime? To { get; set; }
-
-        public string DateFormat { get; set; }
-
-        public int MessageGroupLimit { get; set; }
-    }
-}

DiscordChatExporter.Cli/Container.cs

@@ -1,37 +1,24 @@
-using CommonServiceLocator;
-using DiscordChatExporter.Cli.ViewModels;
-using DiscordChatExporter.Core.Services;
-using GalaSoft.MvvmLight.Ioc;
+using DiscordChatExporter.Core.Services;
+using StyletIoC;
 
 namespace DiscordChatExporter.Cli
 {
-    public class Container
+    public static class Container
     {
-        public IMainViewModel MainViewModel => Resolve<IMainViewModel>();
-        public ISettingsService SettingsService => Resolve<ISettingsService>();
+        public static IContainer Instance { get; }
 
-        private T Resolve<T>(string key = null)
+        static Container()
         {
-            return ServiceLocator.Current.GetInstance<T>(key);
-        }
+            var builder = new StyletIoCBuilder();
 
-        public void Init()
-        {
-            ServiceLocator.SetLocatorProvider(() => SimpleIoc.Default);
-            SimpleIoc.Default.Reset();
+            // Autobind services in the .Core assembly
+            builder.Autobind(typeof(DataService).Assembly);
 
-            // Services
-            SimpleIoc.Default.Register<IDataService, DataService>();
-            SimpleIoc.Default.Register<IExportService, ExportService>();
-            SimpleIoc.Default.Register<IMessageGroupService, MessageGroupService>();
-            SimpleIoc.Default.Register<ISettingsService, SettingsService>();
+            // Bind settings as singleton
+            builder.Bind<SettingsService>().ToSelf().InSingletonScope();
 
-            // View models
-            SimpleIoc.Default.Register<IMainViewModel, MainViewModel>(true);
-        }
-
-        public void Cleanup()
-        {
+            // Set instance
+            Instance = builder.BuildContainer();
         }
     }
 }

DiscordChatExporter.Cli/DiscordChatExporter.Cli.csproj

@@ -3,17 +3,16 @@
     <PropertyGroup>
         <OutputType>Exe</OutputType>
         <TargetFramework>net461</TargetFramework>
-        <Version>2.4</Version>
+        <Version>2.10</Version>
         <Company>Tyrrrz</Company>
-        <Copyright>Copyright (c) 2017-2018 Alexey Golub</Copyright>
+        <Copyright>Copyright (c) Alexey Golub</Copyright>
         <ApplicationIcon>..\favicon.ico</ApplicationIcon>
     </PropertyGroup>
 
     <ItemGroup>
-        <PackageReference Include="CommonServiceLocator" Version="2.0.3" />
-        <PackageReference Include="FluentCommandLineParser" Version="1.4.3" />
-        <PackageReference Include="MvvmLightLibs" Version="5.4.1" />
-        <PackageReference Include="Tyrrrz.Extensions" Version="1.5.0" />
+        <PackageReference Include="CommandLineParser" Version="2.3.0" />
+        <PackageReference Include="Stylet" Version="1.1.22" />
+        <PackageReference Include="Tyrrrz.Extensions" Version="1.5.1" />
     </ItemGroup>
 
     <ItemGroup>

DiscordChatExporter.Cli/Internal/InlineProgress.cs

@@ -0,0 +1,28 @@
+using System;
+
+namespace DiscordChatExporter.Cli.Internal
+{
+    internal class InlineProgress : IProgress<double>, IDisposable
+    {
+        private readonly int _posX;
+        private readonly int _posY;
+
+        public InlineProgress()
+        {
+            _posX = Console.CursorLeft;
+            _posY = Console.CursorTop;
+        }
+
+        public void Report(double progress)
+        {
+            Console.SetCursorPosition(_posX, _posY);
+            Console.WriteLine($"{progress:P1}");
+        }
+
+        public void Dispose()
+        {
+            Console.SetCursorPosition(_posX, _posY);
+            Console.WriteLine("Completed ✓");
+        }
+    }
+}

DiscordChatExporter.Cli/Program.cs

@@ -1,107 +1,72 @@
 using System;
-using System.Reflection;
-using DiscordChatExporter.Core.Models;
-using Fclp;
+using System.Linq;
+using CommandLine;
+using DiscordChatExporter.Cli.Verbs;
+using DiscordChatExporter.Cli.Verbs.Options;
 
 namespace DiscordChatExporter.Cli
 {
     public static class Program
     {
-        private static readonly Container Container = new Container();
-
-        private static void ShowHelp()
+        private static void PrintTokenHelp()
         {
-            var version = Assembly.GetExecutingAssembly().GetName().Version;
-
-            Console.WriteLine($"=== Discord Chat Exporter (Command Line Interface) v{version} ===");
+            Console.WriteLine("# To get user token:");
+            Console.WriteLine(" 1. Open Discord");
+            Console.WriteLine(" 2. Press Ctrl+Shift+I to show developer tools");
+            Console.WriteLine(" 3. Press Ctrl+R to reload");
+            Console.WriteLine(" 4. Navigate to the Application tab");
+            Console.WriteLine(" 5. Select \"Local Storage\" > \"https://discordapp.com\" on the left");
+            Console.WriteLine(" 6. Find \"token\" under key and copy the value");
             Console.WriteLine();
-            Console.WriteLine("[-t] [--token]       Discord authorization token.");
-            Console.WriteLine("[-c] [--channel]     Discord channel ID.");
-            Console.WriteLine("[-f] [--format]      Export format (PlainText/HtmlDark/HtmlLight). Optional.");
-            Console.WriteLine("[-o] [--output]      Output file path. Optional.");
-            Console.WriteLine("     [--datefrom]    Limit to messages after this date. Optional.");
-            Console.WriteLine("     [--dateto]      Limit to messages before this date. Optional.");
-            Console.WriteLine("     [--dateformat]  Date format. Optional.");
-            Console.WriteLine("     [--grouplimit]  Message group limit. Optional.");
+            Console.WriteLine("# To get bot token:");
+            Console.WriteLine(" 1. Go to Discord developer portal");
+            Console.WriteLine(" 2. Open your application's settings");
+            Console.WriteLine(" 3. Navigate to the Bot section on the left");
+            Console.WriteLine(" 4. Under Token click Copy");
             Console.WriteLine();
-            Console.WriteLine("# To get authorization token:");
-            Console.WriteLine(" - Open Discord app");
-            Console.WriteLine(" - Log in if you haven't");
-            Console.WriteLine(" - Press Ctrl+Shift+I");
-            Console.WriteLine(" - Navigate to Application tab");
-            Console.WriteLine(" - Expand Storage > Local Storage > https://discordapp.com");
-            Console.WriteLine(" - Find \"token\" under key and copy the value");
-            Console.WriteLine();
-            Console.WriteLine("# To get channel ID:");
-            Console.WriteLine(" - Open Discord app");
-            Console.WriteLine(" - Log in if you haven't");
-            Console.WriteLine(" - Go to any channel you want to export");
-            Console.WriteLine(" - Press Ctrl+Shift+I");
-            Console.WriteLine(" - Navigate to Console tab");
-            Console.WriteLine(" - Type \"document.URL\" and press Enter");
-            Console.WriteLine(" - Copy the long sequence of numbers after last slash");
-        }
-
-        private static CliOptions ParseOptions(string[] args)
-        {
-            var argsParser = new FluentCommandLineParser<CliOptions>();
-
-            var settings = Container.SettingsService;
-
-            argsParser.Setup(o => o.Token).As('t', "token").Required();
-            argsParser.Setup(o => o.ChannelId).As('c', "channel").Required();
-            argsParser.Setup(o => o.ExportFormat).As('f', "format").SetDefault(ExportFormat.HtmlDark);
-            argsParser.Setup(o => o.FilePath).As('o', "output").SetDefault(null);
-            argsParser.Setup(o => o.From).As("datefrom").SetDefault(null);
-            argsParser.Setup(o => o.To).As("dateto").SetDefault(null);
-            argsParser.Setup(o => o.DateFormat).As("dateformat").SetDefault(settings.DateFormat);
-            argsParser.Setup(o => o.MessageGroupLimit).As("grouplimit").SetDefault(settings.MessageGroupLimit);
-
-            var parsed = argsParser.Parse(args);
-
-            // Show help if no arguments
-            if (parsed.EmptyArgs)
-            {
-                ShowHelp();
-                Environment.Exit(0);
-            }
-            // Show error if there are any
-            else if (parsed.HasErrors)
-            {
-                Console.Error.Write(parsed.ErrorText);
-                Environment.Exit(-1);
-            }
-
-            return argsParser.Object;
+            Console.WriteLine("# To get guild or channel ID:");
+            Console.WriteLine(" 1. Open Discord");
+            Console.WriteLine(" 2. Open Settings");
+            Console.WriteLine(" 3. Go to Appearance section");
+            Console.WriteLine(" 4. Enable Developer Mode");
+            Console.WriteLine(" 5. Right click on the desired guild or channel and click Copy ID");
         }
 
         public static void Main(string[] args)
         {
-            // Init container
-            Container.Init();
+            // Get all verb types
+            var verbTypes = new[]
+            {
+                typeof(ExportChannelOptions),
+                typeof(ExportDirectMessagesOptions),
+                typeof(ExportGuildOptions),
+                typeof(GetChannelsOptions),
+                typeof(GetDirectMessageChannelsOptions),
+                typeof(GetGuildsOptions)
+            };
 
-            // Parse options
-            var options = ParseOptions(args);
+            // Parse command line arguments
+            var parsedArgs = Parser.Default.ParseArguments(args, verbTypes);
 
-            // Inject some settings
-            var settings = Container.SettingsService;
-            settings.DateFormat = options.DateFormat;
-            settings.MessageGroupLimit = options.MessageGroupLimit;
+            // Execute commands
+            parsedArgs.WithParsed<ExportChannelOptions>(o => new ExportChannelVerb(o).Execute());
+            parsedArgs.WithParsed<ExportDirectMessagesOptions>(o => new ExportDirectMessagesVerb(o).Execute());
+            parsedArgs.WithParsed<ExportGuildOptions>(o => new ExportGuildVerb(o).Execute());
+            parsedArgs.WithParsed<GetChannelsOptions>(o => new GetChannelsVerb(o).Execute());
+            parsedArgs.WithParsed<GetDirectMessageChannelsOptions>(o => new GetDirectMessageChannelsVerb(o).Execute());
+            parsedArgs.WithParsed<GetGuildsOptions>(o => new GetGuildsVerb(o).Execute());
 
-            // Export
-            var vm = Container.MainViewModel;
-            vm.ExportAsync(
-                options.Token,
-                options.ChannelId,
-                options.FilePath,
-                options.ExportFormat,
-                options.From,
-                options.To).GetAwaiter().GetResult();
+            // Show token help if help requested or no verb specified
+            parsedArgs.WithNotParsed(errs =>
+            {
+                var err = errs.First();
 
-            // Cleanup container
-            Container.Cleanup();
+                if (err.Tag == ErrorType.NoVerbSelectedError)
+                    PrintTokenHelp();
 
-            Console.WriteLine("Export complete.");
+                if (err.Tag == ErrorType.HelpVerbRequestedError && args.Length == 1)
+                    PrintTokenHelp();
+            });
         }
     }
 }

DiscordChatExporter.Cli/Verbs/ExportChannelVerb.cs

@@ -0,0 +1,57 @@
+using System;
+using System.IO;
+using System.Threading.Tasks;
+using DiscordChatExporter.Cli.Internal;
+using DiscordChatExporter.Cli.Verbs.Options;
+using DiscordChatExporter.Core.Helpers;
+using DiscordChatExporter.Core.Services;
+using Tyrrrz.Extensions;
+
+namespace DiscordChatExporter.Cli.Verbs
+{
+    public class ExportChannelVerb : Verb<ExportChannelOptions>
+    {
+        public ExportChannelVerb(ExportChannelOptions options)
+            : base(options)
+        {
+        }
+
+        public override async Task ExecuteAsync()
+        {
+            // Get services
+            var settingsService = Container.Instance.Get<SettingsService>();
+            var dataService = Container.Instance.Get<DataService>();
+            var exportService = Container.Instance.Get<ExportService>();
+
+            // Configure settings
+            if (Options.DateFormat.IsNotBlank())
+                settingsService.DateFormat = Options.DateFormat;
+            if (Options.MessageGroupLimit > 0)
+                settingsService.MessageGroupLimit = Options.MessageGroupLimit;
+
+            // Track progress
+            Console.Write($"Exporting channel [{Options.ChannelId}]... ");
+            using (var progress = new InlineProgress())
+            {
+                // Get chat log
+                var chatLog = await dataService.GetChatLogAsync(Options.GetToken(), Options.ChannelId,
+                    Options.After, Options.Before, progress);
+
+                // Generate file path if not set or is a directory
+                var filePath = Options.OutputPath;
+                if (filePath.IsBlank() || ExportHelper.IsDirectoryPath(filePath))
+                {
+                    // Generate default file name
+                    var fileName = ExportHelper.GetDefaultExportFileName(Options.ExportFormat, chatLog.Guild,
+                        chatLog.Channel, Options.After, Options.Before);
+
+                    // Combine paths
+                    filePath = Path.Combine(filePath ?? "", fileName);
+                }
+
+                // Export
+                exportService.ExportChatLog(chatLog, filePath, Options.ExportFormat, Options.PartitionLimit);
+            }
+        }
+    }
+}

DiscordChatExporter.Cli/Verbs/ExportDirectMessagesVerb.cs

@@ -0,0 +1,76 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Net;
+using System.Threading.Tasks;
+using DiscordChatExporter.Cli.Internal;
+using DiscordChatExporter.Cli.Verbs.Options;
+using DiscordChatExporter.Core.Exceptions;
+using DiscordChatExporter.Core.Helpers;
+using DiscordChatExporter.Core.Services;
+using Tyrrrz.Extensions;
+
+namespace DiscordChatExporter.Cli.Verbs
+{
+    public class ExportDirectMessagesVerb : Verb<ExportDirectMessagesOptions>
+    {
+        public ExportDirectMessagesVerb(ExportDirectMessagesOptions options)
+            : base(options)
+        {
+        }
+
+        public override async Task ExecuteAsync()
+        {
+            // Get services
+            var settingsService = Container.Instance.Get<SettingsService>();
+            var dataService = Container.Instance.Get<DataService>();
+            var exportService = Container.Instance.Get<ExportService>();
+
+            // Configure settings
+            if (Options.DateFormat.IsNotBlank())
+                settingsService.DateFormat = Options.DateFormat;
+            if (Options.MessageGroupLimit > 0)
+                settingsService.MessageGroupLimit = Options.MessageGroupLimit;
+
+            // Get channels
+            var channels = await dataService.GetDirectMessageChannelsAsync(Options.GetToken());
+
+            // Order channels
+            channels = channels.OrderBy(c => c.Name).ToArray();
+
+            // Loop through channels
+            foreach (var channel in channels)
+            {
+                try
+                {
+                    // Track progress
+                    Console.Write($"Exporting channel [{channel.Name}]... ");
+                    using (var progress = new InlineProgress())
+                    {
+                        // Get chat log
+                        var chatLog = await dataService.GetChatLogAsync(Options.GetToken(), channel,
+                            Options.After, Options.Before, progress);
+
+                        // Generate default file name
+                        var fileName = ExportHelper.GetDefaultExportFileName(Options.ExportFormat, chatLog.Guild,
+                            chatLog.Channel, Options.After, Options.Before);
+
+                        // Generate file path
+                        var filePath = Path.Combine(Options.OutputPath ?? "", fileName);
+
+                        // Export
+                        exportService.ExportChatLog(chatLog, filePath, Options.ExportFormat, Options.PartitionLimit);
+                    }
+                }
+                catch (HttpErrorStatusCodeException ex) when (ex.StatusCode == HttpStatusCode.Forbidden)
+                {
+                    Console.Error.WriteLine("You don't have access to this channel");
+                }
+                catch (HttpErrorStatusCodeException ex) when (ex.StatusCode == HttpStatusCode.NotFound)
+                {
+                    Console.Error.WriteLine("This channel doesn't exist");
+                }
+            }
+        }
+    }
+}

DiscordChatExporter.Cli/Verbs/ExportGuildVerb.cs

@@ -0,0 +1,77 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Net;
+using System.Threading.Tasks;
+using DiscordChatExporter.Cli.Internal;
+using DiscordChatExporter.Cli.Verbs.Options;
+using DiscordChatExporter.Core.Exceptions;
+using DiscordChatExporter.Core.Helpers;
+using DiscordChatExporter.Core.Models;
+using DiscordChatExporter.Core.Services;
+using Tyrrrz.Extensions;
+
+namespace DiscordChatExporter.Cli.Verbs
+{
+    public class ExportGuildVerb : Verb<ExportGuildOptions>
+    {
+        public ExportGuildVerb(ExportGuildOptions options)
+            : base(options)
+        {
+        }
+
+        public override async Task ExecuteAsync()
+        {
+            // Get services
+            var settingsService = Container.Instance.Get<SettingsService>();
+            var dataService = Container.Instance.Get<DataService>();
+            var exportService = Container.Instance.Get<ExportService>();
+
+            // Configure settings
+            if (Options.DateFormat.IsNotBlank())
+                settingsService.DateFormat = Options.DateFormat;
+            if (Options.MessageGroupLimit > 0)
+                settingsService.MessageGroupLimit = Options.MessageGroupLimit;
+
+            // Get channels
+            var channels = await dataService.GetGuildChannelsAsync(Options.GetToken(), Options.GuildId);
+
+            // Filter and order channels
+            channels = channels.Where(c => c.Type == ChannelType.GuildTextChat).OrderBy(c => c.Name).ToArray();
+
+            // Loop through channels
+            foreach (var channel in channels)
+            {
+                try
+                {
+                    // Track progress
+                    Console.Write($"Exporting channel [{channel.Name}]... ");
+                    using (var progress = new InlineProgress())
+                    {
+                        // Get chat log
+                        var chatLog = await dataService.GetChatLogAsync(Options.GetToken(), channel,
+                            Options.After, Options.Before, progress);
+
+                        // Generate default file name
+                        var fileName = ExportHelper.GetDefaultExportFileName(Options.ExportFormat, chatLog.Guild,
+                            chatLog.Channel, Options.After, Options.Before);
+
+                        // Generate file path
+                        var filePath = Path.Combine(Options.OutputPath ?? "", fileName);
+
+                        // Export
+                        exportService.ExportChatLog(chatLog, filePath, Options.ExportFormat, Options.PartitionLimit);
+                    }
+                }
+                catch (HttpErrorStatusCodeException ex) when (ex.StatusCode == HttpStatusCode.Forbidden)
+                {
+                    Console.Error.WriteLine("You don't have access to this channel");
+                }
+                catch (HttpErrorStatusCodeException ex) when (ex.StatusCode == HttpStatusCode.NotFound)
+                {
+                    Console.Error.WriteLine("This channel doesn't exist");
+                }
+            }
+        }
+    }
+}

DiscordChatExporter.Cli/Verbs/GetChannelsVerb.cs

@@ -0,0 +1,33 @@
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+using DiscordChatExporter.Cli.Verbs.Options;
+using DiscordChatExporter.Core.Models;
+using DiscordChatExporter.Core.Services;
+
+namespace DiscordChatExporter.Cli.Verbs
+{
+    public class GetChannelsVerb : Verb<GetChannelsOptions>
+    {
+        public GetChannelsVerb(GetChannelsOptions options)
+            : base(options)
+        {
+        }
+
+        public override async Task ExecuteAsync()
+        {
+            // Get data service
+            var dataService = Container.Instance.Get<DataService>();
+
+            // Get channels
+            var channels = await dataService.GetGuildChannelsAsync(Options.GetToken(), Options.GuildId);
+
+            // Filter and order channels
+            channels = channels.Where(c => c.Type == ChannelType.GuildTextChat).OrderBy(c => c.Name).ToArray();
+
+            // Print result
+            foreach (var channel in channels)
+                Console.WriteLine($"{channel.Id} | {channel.Name}");
+        }
+    }
+}

DiscordChatExporter.Cli/Verbs/GetDirectMessageChannelsVerb.cs

@@ -0,0 +1,32 @@
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+using DiscordChatExporter.Cli.Verbs.Options;
+using DiscordChatExporter.Core.Services;
+
+namespace DiscordChatExporter.Cli.Verbs
+{
+    public class GetDirectMessageChannelsVerb : Verb<GetDirectMessageChannelsOptions>
+    {
+        public GetDirectMessageChannelsVerb(GetDirectMessageChannelsOptions options) 
+            : base(options)
+        {
+        }
+
+        public override async Task ExecuteAsync()
+        {
+            // Get data service
+            var dataService = Container.Instance.Get<DataService>();
+
+            // Get channels
+            var channels = await dataService.GetDirectMessageChannelsAsync(Options.GetToken());
+
+            // Order channels
+            channels = channels.OrderBy(c => c.Name).ToArray();
+
+            // Print result
+            foreach (var channel in channels)
+                Console.WriteLine($"{channel.Id} | {channel.Name}");
+        }
+    }
+}

DiscordChatExporter.Cli/Verbs/GetGuildsVerb.cs

@@ -0,0 +1,32 @@
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+using DiscordChatExporter.Cli.Verbs.Options;
+using DiscordChatExporter.Core.Services;
+
+namespace DiscordChatExporter.Cli.Verbs
+{
+    public class GetGuildsVerb : Verb<GetGuildsOptions>
+    {
+        public GetGuildsVerb(GetGuildsOptions options) 
+            : base(options)
+        {
+        }
+
+        public override async Task ExecuteAsync()
+        {
+            // Get data service
+            var dataService = Container.Instance.Get<DataService>();
+
+            // Get guilds
+            var guilds = await dataService.GetUserGuildsAsync(Options.GetToken());
+
+            // Order guilds
+            guilds = guilds.OrderBy(g => g.Name).ToArray();
+
+            // Print result
+            foreach (var guild in guilds)
+                Console.WriteLine($"{guild.Id} | {guild.Name}");
+        }
+    }
+}

DiscordChatExporter.Cli/Verbs/Options/ExportChannelOptions.cs

@@ -0,0 +1,11 @@
+using CommandLine;
+
+namespace DiscordChatExporter.Cli.Verbs.Options
+{
+    [Verb("export", HelpText = "Export channel.")]
+    public class ExportChannelOptions : ExportOptions
+    {
+        [Option('c', "channel", Required = true, HelpText = "Channel ID.")]
+        public string ChannelId { get; set; }
+    }
+}

DiscordChatExporter.Cli/Verbs/Options/ExportDirectMessagesOptions.cs

@@ -0,0 +1,9 @@
+using CommandLine;
+
+namespace DiscordChatExporter.Cli.Verbs.Options
+{
+    [Verb("exportdm", HelpText = "Export all direct message channels.")]
+    public class ExportDirectMessagesOptions : ExportOptions
+    {
+    }
+}

DiscordChatExporter.Cli/Verbs/Options/ExportGuildOptions.cs

@@ -0,0 +1,11 @@
+using CommandLine;
+
+namespace DiscordChatExporter.Cli.Verbs.Options
+{
+    [Verb("exportguild", HelpText = "Export all channels within a given guild.")]
+    public class ExportGuildOptions : ExportOptions
+    {
+        [Option('g', "guild", Required = true, HelpText = "Guild ID.")]
+        public string GuildId { get; set; }
+    }
+}

DiscordChatExporter.Cli/Verbs/Options/ExportOptions.cs

@@ -0,0 +1,30 @@
+using System;
+using CommandLine;
+using DiscordChatExporter.Core.Models;
+
+namespace DiscordChatExporter.Cli.Verbs.Options
+{
+    public abstract class ExportOptions : TokenOptions
+    {
+        [Option('f', "format", Default = ExportFormat.HtmlDark, HelpText = "Output file format.")]
+        public ExportFormat ExportFormat { get; set; }
+
+        [Option('o', "output", Default = null, HelpText = "Output file or directory path.")]
+        public string OutputPath { get; set; }
+
+        [Option("after", Default = null, HelpText = "Limit to messages sent after this date.")]
+        public DateTime? After { get; set; }
+
+        [Option("before", Default = null, HelpText = "Limit to messages sent before this date.")]
+        public DateTime? Before { get; set; }
+
+        [Option('p', "partition", Default = null, HelpText = "Split output into partitions limited to this number of messages.")]
+        public int? PartitionLimit { get; set; }
+
+        [Option("dateformat", Default = null, HelpText = "Date format used in output.")]
+        public string DateFormat { get; set; }
+
+        [Option("grouplimit", Default = 0, HelpText = "Message group limit.")]
+        public int MessageGroupLimit { get; set; }
+    }
+}

DiscordChatExporter.Cli/Verbs/Options/GetChannelsOptions.cs

@@ -0,0 +1,11 @@
+using CommandLine;
+
+namespace DiscordChatExporter.Cli.Verbs.Options
+{
+    [Verb("channels", HelpText = "Get the list of channels in the given guild.")]
+    public class GetChannelsOptions : TokenOptions
+    {
+        [Option('g', "guild", Required = true, HelpText = "Guild ID.")]
+        public string GuildId { get; set; }
+    }
+}

DiscordChatExporter.Cli/Verbs/Options/GetDirectMessageChannelsOptions.cs

@@ -0,0 +1,9 @@
+using CommandLine;
+
+namespace DiscordChatExporter.Cli.Verbs.Options
+{
+    [Verb("dm", HelpText = "Get the list of direct message channels.")]
+    public class GetDirectMessageChannelsOptions : TokenOptions
+    {
+    }
+}

DiscordChatExporter.Cli/Verbs/Options/GetGuildsOptions.cs

@@ -0,0 +1,9 @@
+using CommandLine;
+
+namespace DiscordChatExporter.Cli.Verbs.Options
+{
+    [Verb("guilds", HelpText = "Get the list of accessible guilds.")]
+    public class GetGuildsOptions : TokenOptions
+    {
+    }
+}

DiscordChatExporter.Cli/Verbs/Options/TokenOptions.cs

@@ -0,0 +1,16 @@
+using CommandLine;
+using DiscordChatExporter.Core.Models;
+
+namespace DiscordChatExporter.Cli.Verbs.Options
+{
+    public abstract class TokenOptions
+    {
+        [Option('t', "token", Required = true, HelpText = "Authorization token.")]
+        public string TokenValue { get; set; }
+
+        [Option('b', "bot", Default = false, HelpText = "Whether this authorization token belongs to a bot.")]
+        public bool IsBotToken { get; set; }
+
+        public AuthToken GetToken() => new AuthToken(IsBotToken ? AuthTokenType.Bot : AuthTokenType.User, TokenValue);
+    }
+}

DiscordChatExporter.Cli/Verbs/Verb.cs

@@ -0,0 +1,18 @@
+using System.Threading.Tasks;
+
+namespace DiscordChatExporter.Cli.Verbs
+{
+    public abstract class Verb<TOptions>
+    {
+        protected TOptions Options { get; }
+
+        protected Verb(TOptions options)
+        {
+            Options = options;
+        }
+
+        public abstract Task ExecuteAsync();
+
+        public virtual void Execute() => ExecuteAsync().GetAwaiter().GetResult();
+    }
+}

DiscordChatExporter.Cli/ViewModels/IMainViewModel.cs

@@ -1,12 +0,0 @@
-using System;
-using System.Threading.Tasks;
-using DiscordChatExporter.Core.Models;
-
-namespace DiscordChatExporter.Cli.ViewModels
-{
-    public interface IMainViewModel
-    {
-        Task ExportAsync(string token, string channelId, string filePath, ExportFormat format, DateTime? from,
-            DateTime? to);
-    }
-}

DiscordChatExporter.Cli/ViewModels/MainViewModel.cs

@@ -1,53 +0,0 @@
-using System;
-using System.IO;
-using System.Threading.Tasks;
-using DiscordChatExporter.Core.Models;
-using DiscordChatExporter.Core.Services;
-using Tyrrrz.Extensions;
-
-namespace DiscordChatExporter.Cli.ViewModels
-{
-    public class MainViewModel : IMainViewModel
-    {
-        private readonly IDataService _dataService;
-        private readonly IMessageGroupService _messageGroupService;
-        private readonly IExportService _exportService;
-
-        public MainViewModel(IDataService dataService, IMessageGroupService messageGroupService,
-            IExportService exportService)
-        {
-            _dataService = dataService;
-            _messageGroupService = messageGroupService;
-            _exportService = exportService;
-        }
-
-        public async Task ExportAsync(string token, string channelId, string filePath, ExportFormat format, DateTime? from,
-            DateTime? to)
-        {
-            // Get channel and guild
-            var channel = await _dataService.GetChannelAsync(token, channelId);
-            var guild = channel.GuildId == Guild.DirectMessages.Id
-                ? Guild.DirectMessages
-                : await _dataService.GetGuildAsync(token, channel.GuildId);
-
-            // Generate file path if not set
-            if (filePath.IsBlank())
-            {
-                filePath = $"{guild.Name} - {channel.Name}.{format.GetFileExtension()}"
-                    .Replace(Path.GetInvalidFileNameChars(), '_');
-            }
-
-            // Get messages
-            var messages = await _dataService.GetChannelMessagesAsync(token, channelId, from, to);
-
-            // Group them
-            var messageGroups = _messageGroupService.GroupMessages(messages);
-
-            // Create log
-            var log = new ChannelChatLog(guild, channel, messageGroups, messages.Count);
-
-            // Export
-            await _exportService.ExportAsync(format, filePath, log);
-        }
-    }
-}

DiscordChatExporter.Core.Markdown/DiscordChatExporter.Core.Markdown.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net461</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Sprache" Version="2.2.0" />
+    <PackageReference Include="Tyrrrz.Extensions" Version="1.5.1" />
+  </ItemGroup>
+
+</Project>

DiscordChatExporter.Core.Markdown/EmojiNode.cs

@@ -0,0 +1,30 @@
+using Tyrrrz.Extensions;
+
+namespace DiscordChatExporter.Core.Markdown
+{
+    public class EmojiNode : Node
+    {
+        public string Id { get; }
+
+        public string Name { get; }
+
+        public bool IsAnimated { get; }
+
+        public bool IsCustomEmoji => Id.IsNotBlank();
+
+        public EmojiNode(string lexeme, string id, string name, bool isAnimated)
+            : base(lexeme)
+        {
+            Id = id;
+            Name = name;
+            IsAnimated = isAnimated;
+        }
+
+        public EmojiNode(string lexeme, string name)
+            : this(lexeme, null, name, false)
+        {
+        }
+
+        public override string ToString() => $"<Emoji> {Name}";
+    }
+}

DiscordChatExporter.Core.Markdown/FormattedNode.cs

@@ -0,0 +1,23 @@
+using System.Collections.Generic;
+
+namespace DiscordChatExporter.Core.Markdown
+{
+    public class FormattedNode : Node
+    {
+        public string Token { get; }
+
+        public TextFormatting Formatting { get; }
+
+        public IReadOnlyList<Node> Children { get; }
+
+        public FormattedNode(string lexeme, string token, TextFormatting formatting, IReadOnlyList<Node> children)
+            : base(lexeme)
+        {
+            Token = token;
+            Formatting = formatting;
+            Children = children;
+        }
+
+        public override string ToString() => $"<{Formatting}> ({Children.Count} direct children)";
+    }
+}

DiscordChatExporter.Core.Markdown/InlineCodeBlockNode.cs

@@ -0,0 +1,15 @@
+namespace DiscordChatExporter.Core.Markdown
+{
+    public class InlineCodeBlockNode : Node
+    {
+        public string Code { get; }
+
+        public InlineCodeBlockNode(string lexeme, string code)
+            : base(lexeme)
+        {
+            Code = code;
+        }
+
+        public override string ToString() => $"<Code> {Code}";
+    }
+}

DiscordChatExporter.Core.Markdown/Internal/Grammar.cs

@@ -0,0 +1,178 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Text.RegularExpressions;
+using Sprache;
+using Tyrrrz.Extensions;
+
+namespace DiscordChatExporter.Core.Markdown.Internal
+{
+    // The following parsing logic is meant to replicate Discord's markdown grammar as close as possible
+    internal static class Grammar
+    {
+        /* Formatting */
+
+        // Capture until the earliest double asterisk not followed by an asterisk
+        private static readonly Parser<Node> BoldFormattedNode =
+            Parse.RegexMatch(new Regex("\\*\\*(.+?)\\*\\*(?!\\*)", RegexOptions.Singleline))
+                .Select(m => new FormattedNode(m.Value, "**", TextFormatting.Bold, BuildTree(m.Groups[1].Value)));
+
+        // Capture until the earliest single asterisk not preceded or followed by an asterisk
+        // Can't have whitespace right after opening or right before closing asterisk
+        private static readonly Parser<Node> ItalicFormattedNode =
+            Parse.RegexMatch(new Regex("\\*(?!\\s)(.+?)(?<!\\s|\\*)\\*(?!\\*)", RegexOptions.Singleline))
+                .Select(m => new FormattedNode(m.Value, "*", TextFormatting.Italic, BuildTree(m.Groups[1].Value)));
+
+        // Can't have underscores inside
+        // Can't have word characters right after closing underscore
+        private static readonly Parser<Node> ItalicAltFormattedNode =
+            Parse.RegexMatch(new Regex("_([^_]+?)_(?!\\w)", RegexOptions.Singleline))
+                .Select(m => new FormattedNode(m.Value, "_", TextFormatting.Italic, BuildTree(m.Groups[1].Value)));
+
+        // Treated as a separate entity for simplicity
+        // Capture until the earliest triple asterisk not preceded or followed by an asterisk
+        private static readonly Parser<Node> ItalicBoldFormattedNode =
+            Parse.RegexMatch(new Regex("\\*(\\*\\*(?:.+?)\\*\\*)\\*(?!\\*)", RegexOptions.Singleline))
+                .Select(m => new FormattedNode(m.Value, "*", TextFormatting.Italic, BuildTree(m.Groups[1].Value)));
+
+        // Capture until the earliest double underscore not followed by an underscore
+        private static readonly Parser<Node> UnderlineFormattedNode =
+            Parse.RegexMatch(new Regex("__(.+?)__(?!_)", RegexOptions.Singleline))
+                .Select(m => new FormattedNode(m.Value, "__", TextFormatting.Underline, BuildTree(m.Groups[1].Value)));
+
+        // Treated as a separate entity for simplicity
+        // Capture until the earliest triple underscore not preceded or followed by an underscore
+        private static readonly Parser<Node> ItalicUnderlineFormattedNode =
+            Parse.RegexMatch(new Regex("_(__(?:.+?)__)_(?!_)", RegexOptions.Singleline))
+                .Select(m => new FormattedNode(m.Value, "_", TextFormatting.Italic, BuildTree(m.Groups[1].Value)));
+
+        // Strikethrough is safe
+        private static readonly Parser<Node> StrikethroughFormattedNode =
+            Parse.RegexMatch(new Regex("~~(.+?)~~", RegexOptions.Singleline))
+                .Select(m => new FormattedNode(m.Value, "~~", TextFormatting.Strikethrough, BuildTree(m.Groups[1].Value)));
+
+        // Spoiler is safe
+        private static readonly Parser<Node> SpoilerFormattedNode =
+            Parse.RegexMatch(new Regex("\\|\\|(.+?)\\|\\|", RegexOptions.Singleline))
+                .Select(m => new FormattedNode(m.Value, "||", TextFormatting.Spoiler, BuildTree(m.Groups[1].Value)));
+
+        // Combinator, order matters
+        private static readonly Parser<Node> AnyFormattedNode = 
+            ItalicBoldFormattedNode.Or(ItalicUnderlineFormattedNode)
+            .Or(BoldFormattedNode).Or(ItalicFormattedNode)
+            .Or(UnderlineFormattedNode).Or(ItalicAltFormattedNode)
+            .Or(StrikethroughFormattedNode).Or(SpoilerFormattedNode);
+
+        /* Code blocks */
+
+        // Can't have backticks inside and surrounding whitespace is trimmed
+        private static readonly Parser<Node> InlineCodeBlockNode =
+            Parse.RegexMatch(new Regex("`\\s*([^`]+?)\\s*`", RegexOptions.Singleline))
+                .Select(m => new InlineCodeBlockNode(m.Value, m.Groups[1].Value));
+
+        // The first word is a language identifier if it's the only word followed by a newline, the rest is code
+        private static readonly Parser<Node> MultilineCodeBlockNode =
+            Parse.RegexMatch(new Regex("```(?:(\\w*?)?(?:\\s*?\\n))?(.+)```", RegexOptions.Singleline))
+                .Select(m => new MultilineCodeBlockNode(m.Value, m.Groups[1].Value, m.Groups[2].Value));
+
+        // Combinator, order matters
+        private static readonly Parser<Node> AnyCodeBlockNode = MultilineCodeBlockNode.Or(InlineCodeBlockNode);
+
+        /* Mentions */
+
+        // @everyone or @here
+        private static readonly Parser<Node> MetaMentionNode = Parse.RegexMatch("@(everyone|here)")
+            .Select(m => new MentionNode(m.Value, m.Groups[1].Value, MentionType.Meta));
+
+        // <@123456> or <@!123456>
+        private static readonly Parser<Node> UserMentionNode = Parse.RegexMatch("<@!?(\\d+)>")
+            .Select(m => new MentionNode(m.Value, m.Groups[1].Value, MentionType.User));
+
+        // <#123456>
+        private static readonly Parser<Node> ChannelMentionNode = Parse.RegexMatch("<#(\\d+)>")
+            .Select(m => new MentionNode(m.Value, m.Groups[1].Value, MentionType.Channel));
+
+        // <@&123456>
+        private static readonly Parser<Node> RoleMentionNode = Parse.RegexMatch("<@&(\\d+)>")
+            .Select(m => new MentionNode(m.Value, m.Groups[1].Value, MentionType.Role));
+
+        // Combinator, order matters
+        private static readonly Parser<Node> AnyMentionNode =
+            MetaMentionNode.Or(UserMentionNode).Or(ChannelMentionNode).Or(RoleMentionNode);
+
+        /* Emojis */
+
+        // Matches all standard unicode emojis
+        private static readonly Parser<Node> StandardEmojiNode = Parse.RegexMatch(
+                "([\\u2700-\\u27bf]|" +
+                "(?:\\ud83c[\\udde6-\\uddff]){2}|" +
+                "[\\ud800-\\udbff][\\udc00-\\udfff]|" +
+                "[\\u0023-\\u0039]\\u20e3|" +
+                "\\u3299|\\u3297|\\u303d|\\u3030|\\u24c2|\\ud83c[\\udd70-\\udd71]|\\ud83c[\\udd7e-\\udd7f]|\\ud83c\\udd8e|\\ud83c[\\udd91-\\udd9a]|\\ud83c[\\udde6-\\uddff]|" +
+                "[\\ud83c[\\ude01-\\ude02]|\\ud83c\\ude1a|\\ud83c\\ude2f|[\\ud83c[\\ude32-\\ude3a]|[\\ud83c[\\ude50-\\ude51]|\\u203c|\\u2049|[\\u25aa-\\u25ab]|" +
+                "\\u25b6|\\u25c0|[\\u25fb-\\u25fe]|\\u00a9|\\u00ae|\\u2122|\\u2139|\\ud83c\\udc04|[\\u2600-\\u26FF]|\\u2b05|\\u2b06|\\u2b07|\\u2b1b|\\u2b1c|\\u2b50|" +
+                "\\u2b55|\\u231a|\\u231b|\\u2328|\\u23cf|[\\u23e9-\\u23f3]|[\\u23f8-\\u23fa]|\\ud83c\\udccf|\\u2934|\\u2935|[\\u2190-\\u21ff])")
+            .Select(m => new EmojiNode(m.Value, m.Groups[1].Value));
+
+        // <:lul:123456> or <a:lul:123456>
+        private static readonly Parser<Node> CustomEmojiNode = Parse.RegexMatch("<(a)?:(.+):(\\d+)>")
+            .Select(m => new EmojiNode(m.Value, m.Groups[3].Value, m.Groups[2].Value, m.Groups[1].Value.IsNotBlank()));
+
+        // Combinator, order matters
+        private static readonly Parser<Node> AnyEmojiNode = StandardEmojiNode.Or(CustomEmojiNode);
+
+        /* Links */
+
+        // [title](link)
+        private static readonly Parser<Node> TitledLinkNode = Parse.RegexMatch("\\[(.+)\\]\\((.+)\\)")
+            .Select(m => new LinkNode(m.Value, m.Groups[2].Value, m.Groups[1].Value));
+
+        // Starts with http:// or https://, stops at the last non-whitespace character followed by whitespace or punctuation character
+        private static readonly Parser<Node> AutoLinkNode = Parse.RegexMatch("(https?://\\S*[^\\.,:;\"\'\\s])")
+            .Select(m => new LinkNode(m.Value, m.Groups[1].Value));
+
+        // Autolink surrounded by angular brackets
+        private static readonly Parser<Node> HiddenLinkNode = Parse.RegexMatch("<(https?://\\S*[^\\.,:;\"\'\\s])>")
+            .Select(m => new LinkNode(m.Value, m.Groups[1].Value));
+
+        // Combinator, order matters
+        private static readonly Parser<Node> AnyLinkNode = TitledLinkNode.Or(HiddenLinkNode).Or(AutoLinkNode); 
+
+        /* Text */
+
+        // Shrug is an exception and needs to be exempt from formatting
+        private static readonly Parser<Node> ShrugTextNode =
+            Parse.String("¯\\_(ツ)_/¯").Text().Select(s => new TextNode(s));
+
+        // Backslash escapes any following unicode surrogate pair
+        private static readonly Parser<Node> EscapedSurrogateTextNode =
+            from slash in Parse.Char('\\')
+            from high in Parse.AnyChar.Where(char.IsHighSurrogate)
+            from low in Parse.AnyChar
+            let lexeme = $"{slash}{high}{low}"
+            let text = $"{high}{low}"
+            select new TextNode(lexeme, text);
+
+        // Backslash escapes any following non-whitespace character except for digits and latin letters
+        private static readonly Parser<Node> EscapedTextNode =
+            Parse.RegexMatch("\\\\([^a-zA-Z0-9\\s])").Select(m => new TextNode(m.Value, m.Groups[1].Value));
+
+        // Combinator, order matters
+        private static readonly Parser<Node> AnyTextNode = ShrugTextNode.Or(EscapedSurrogateTextNode).Or(EscapedTextNode);
+
+        /* Aggregator and fallback */
+
+        // Any node recognized by above patterns
+        private static readonly Parser<Node> AnyRecognizedNode = AnyFormattedNode.Or(AnyCodeBlockNode)
+            .Or(AnyMentionNode).Or(AnyEmojiNode).Or(AnyLinkNode).Or(AnyTextNode);
+
+        // Any node not recognized by above patterns (treated as plain text)
+        private static readonly Parser<Node> FallbackNode =
+            Parse.AnyChar.Except(AnyRecognizedNode).AtLeastOnce().Text().Select(s => new TextNode(s));
+
+        // Any node
+        private static readonly Parser<Node> AnyNode = AnyRecognizedNode.Or(FallbackNode);
+
+        // Entry point
+        public static IReadOnlyList<Node> BuildTree(string input) => AnyNode.Many().Parse(input).ToArray();
+    }
+}

DiscordChatExporter.Core.Markdown/LinkNode.cs

@@ -0,0 +1,22 @@
+namespace DiscordChatExporter.Core.Markdown
+{
+    public class LinkNode : Node
+    {
+        public string Url { get; }
+
+        public string Title { get; }
+
+        public LinkNode(string lexeme, string url, string title)
+            : base(lexeme)
+        {
+            Url = url;
+            Title = title;
+        }
+
+        public LinkNode(string lexeme, string url) : this(lexeme, url, url)
+        {
+        }
+
+        public override string ToString() => $"<Link> {Title}";
+    }
+}

DiscordChatExporter.Core.Markdown/MarkdownParser.cs

@@ -0,0 +1,10 @@
+using System.Collections.Generic;
+using DiscordChatExporter.Core.Markdown.Internal;
+
+namespace DiscordChatExporter.Core.Markdown
+{
+    public static class MarkdownParser
+    {
+        public static IReadOnlyList<Node> Parse(string input) => Grammar.BuildTree(input);
+    }
+}

DiscordChatExporter.Core.Markdown/MentionNode.cs

@@ -0,0 +1,18 @@
+namespace DiscordChatExporter.Core.Markdown
+{
+    public class MentionNode : Node
+    {
+        public string Id { get; }
+
+        public MentionType Type { get; }
+
+        public MentionNode(string lexeme, string id, MentionType type)
+            : base(lexeme)
+        {
+            Id = id;
+            Type = type;
+        }
+
+        public override string ToString() => $"<{Type} mention> {Id}";
+    }
+}

DiscordChatExporter.Core.Markdown/MentionType.cs

@@ -0,0 +1,10 @@
+namespace DiscordChatExporter.Core.Markdown
+{
+    public enum MentionType
+    {
+        Meta,
+        User,
+        Channel,
+        Role
+    }
+}

DiscordChatExporter.Core.Markdown/MultilineCodeBlockNode.cs

@@ -0,0 +1,18 @@
+namespace DiscordChatExporter.Core.Markdown
+{
+    public class MultilineCodeBlockNode : Node
+    {
+        public string Language { get; }
+
+        public string Code { get; }
+
+        public MultilineCodeBlockNode(string lexeme, string language, string code)
+            : base(lexeme)
+        {
+            Language = language;
+            Code = code;
+        }
+
+        public override string ToString() => $"<Code [{Language}]> {Code}";
+    }
+}

DiscordChatExporter.Core.Markdown/Node.cs

@@ -0,0 +1,12 @@
+namespace DiscordChatExporter.Core.Markdown
+{
+    public abstract class Node
+    {
+        public string Lexeme { get; }
+
+        protected Node(string lexeme)
+        {
+            Lexeme = lexeme;
+        }
+    }
+}

DiscordChatExporter.Core.Markdown/TextFormatting.cs

@@ -0,0 +1,11 @@
+namespace DiscordChatExporter.Core.Markdown
+{
+    public enum TextFormatting
+    {
+        Bold,
+        Italic,
+        Underline,
+        Strikethrough,
+        Spoiler
+    }
+}

DiscordChatExporter.Core.Markdown/TextNode.cs

@@ -0,0 +1,19 @@
+namespace DiscordChatExporter.Core.Markdown
+{
+    public class TextNode : Node
+    {
+        public string Text { get; }
+
+        public TextNode(string lexeme, string text)
+            : base(lexeme)
+        {
+            Text = text;
+        }
+
+        public TextNode(string text) : this(text, text)
+        {
+        }
+
+        public override string ToString() => Text;
+    }
+}

DiscordChatExporter.Core/DiscordChatExporter.Core.csproj

@@ -2,23 +2,35 @@
 
     <PropertyGroup>
         <TargetFramework>net461</TargetFramework>
-        <Version>2.4</Version>
     </PropertyGroup>
 
     <ItemGroup>
-        <EmbeddedResource Include="Resources\ExportService\DarkTheme.css" />
-        <EmbeddedResource Include="Resources\ExportService\LightTheme.css" />
+        <EmbeddedResource Include="Resources\ExportTemplates\PlainText\Template.txt" />
+        <EmbeddedResource Include="Resources\ExportTemplates\HtmlDark\Template.html" />
+        <EmbeddedResource Include="Resources\ExportTemplates\HtmlLight\Template.html" />
+        <EmbeddedResource Include="Resources\ExportTemplates\HtmlShared\Main.html" />
+        <EmbeddedResource Include="Resources\ExportTemplates\HtmlShared\Main.css" />
+        <EmbeddedResource Include="Resources\ExportTemplates\HtmlDark\Theme.css" />
+        <EmbeddedResource Include="Resources\ExportTemplates\HtmlLight\Theme.css" />
+        <EmbeddedResource Include="Resources\ExportTemplates\Csv\Template.csv" />
     </ItemGroup>
 
     <ItemGroup>
-        <Reference Include="System.Net.Http" />
+        <Reference Include="mscorlib" />
     </ItemGroup>
 
     <ItemGroup>
-        <PackageReference Include="Newtonsoft.Json" Version="11.0.2" />
-        <PackageReference Include="Onova" Version="2.1.0" />
-        <PackageReference Include="Tyrrrz.Extensions" Version="1.5.0" />
-        <PackageReference Include="Tyrrrz.Settings" Version="1.3.2" />
+        <PackageReference Include="ByteSize" Version="1.3.0" />
+        <PackageReference Include="Failsafe" Version="1.1.0" />
+        <PackageReference Include="Newtonsoft.Json" Version="12.0.1" />
+        <PackageReference Include="Onova" Version="2.2.0" />
+        <PackageReference Include="Scriban" Version="1.2.9" />
+        <PackageReference Include="Tyrrrz.Extensions" Version="1.5.1" />
+        <PackageReference Include="Tyrrrz.Settings" Version="1.3.3" />
+    </ItemGroup>
+
+    <ItemGroup>
+      <ProjectReference Include="..\DiscordChatExporter.Core.Markdown\DiscordChatExporter.Core.Markdown.csproj" />
     </ItemGroup>
 
 </Project>

DiscordChatExporter.Core/Exceptions/HttpErrorStatusCodeException.cs

@@ -7,9 +7,13 @@ namespace DiscordChatExporter.Core.Exceptions
     {
         public HttpStatusCode StatusCode { get; }
 
-        public HttpErrorStatusCodeException(HttpStatusCode statusCode)
+        public string ReasonPhrase { get; }
+
+        public HttpErrorStatusCodeException(HttpStatusCode statusCode, string reasonPhrase)
+            : base($"Error HTTP status code: {statusCode} - {reasonPhrase}")
         {
             StatusCode = statusCode;
+            ReasonPhrase = reasonPhrase;
         }
     }
 }

DiscordChatExporter.Core/Helpers/ExportHelper.cs

@@ -0,0 +1,59 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Text;
+using DiscordChatExporter.Core.Models;
+using Tyrrrz.Extensions;
+
+namespace DiscordChatExporter.Core.Helpers
+{
+    public static class ExportHelper
+    {
+        public static bool IsDirectoryPath(string path)
+            => path.Last() == Path.DirectorySeparatorChar ||
+               path.Last() == Path.AltDirectorySeparatorChar ||
+               Path.GetExtension(path).IsBlank();
+
+        public static string GetDefaultExportFileName(ExportFormat format, Guild guild, Channel channel,
+            DateTime? from = null, DateTime? to = null)
+        {
+            var result = new StringBuilder();
+
+            // Append guild and channel names
+            result.Append($"{guild.Name} - {channel.Name} [{channel.Id}]");
+
+            // Append date range
+            if (from != null || to != null)
+            {
+                result.Append(" (");
+
+                // Both 'from' and 'to' are set
+                if (from != null && to != null)
+                {
+                    result.Append($"{from:yyyy-MM-dd} to {to:yyyy-MM-dd}");
+                }
+                // Only 'from' is set
+                else if (from != null)
+                {
+                    result.Append($"after {from:yyyy-MM-dd}");
+                }
+                // Only 'to' is set
+                else
+                {
+                    result.Append($"before {to:yyyy-MM-dd}");
+                }
+
+                result.Append(")");
+            }
+
+            // Append extension
+            result.Append($".{format.GetFileExtension()}");
+
+            // Replace invalid chars
+            foreach (var invalidChar in Path.GetInvalidFileNameChars())
+                result.Replace(invalidChar, '_');
+
+            return result.ToString();
+        }
+    }
+}

DiscordChatExporter.Core/Internal/Extensions.cs

@@ -1,22 +1,21 @@
-using System.IO;
-using System.Reflection;
-using System.Resources;
+using System;
+using System.Drawing;
+using System.Net;
 
 namespace DiscordChatExporter.Core.Internal
 {
     internal static class Extensions
     {
-        public static string GetManifestResourceString(this Assembly assembly, string resourceName)
+        public static string ToSnowflake(this DateTime dateTime)
         {
-            var stream = assembly.GetManifestResourceStream(resourceName);
-            if (stream == null)
-                throw new MissingManifestResourceException($"Could not find resource [{resourceName}].");
-
-            using (stream)
-            using (var reader = new StreamReader(stream))
-            {
-                return reader.ReadToEnd();
-            }
+            const long epoch = 62135596800000;
+            var unixTime = dateTime.ToUniversalTime().Ticks / TimeSpan.TicksPerMillisecond - epoch;
+            var value = ((ulong) unixTime - 1420070400000UL) << 22;
+            return value.ToString();
         }
+
+        public static Color ResetAlpha(this Color color) => Color.FromArgb(1, color);
+
+        public static string HtmlEncode(this string value) => WebUtility.HtmlEncode(value);
     }
 }

DiscordChatExporter.Core/Models/Attachment.cs

@@ -1,24 +1,40 @@
-namespace DiscordChatExporter.Core.Models
+using System;
+using ByteSizeLib;
+
+namespace DiscordChatExporter.Core.Models
 {
+    // https://discordapp.com/developers/docs/resources/channel#attachment-object
+
     public class Attachment
     {
         public string Id { get; }
 
-        public AttachmentType Type { get; }
-
         public string Url { get; }
 
+        public int? Width { get; }
+
+        public int? Height { get; }
+
         public string FileName { get; }
 
-        public long FileSize { get; }
+        public bool IsImage => FileName.EndsWith(".jpg", StringComparison.OrdinalIgnoreCase) ||
+                               FileName.EndsWith(".jpeg", StringComparison.OrdinalIgnoreCase) ||
+                               FileName.EndsWith(".png", StringComparison.OrdinalIgnoreCase) ||
+                               FileName.EndsWith(".gif", StringComparison.OrdinalIgnoreCase) ||
+                               FileName.EndsWith(".bmp", StringComparison.OrdinalIgnoreCase);
 
-        public Attachment(string id, AttachmentType type, string url, string fileName, long fileSize)
+        public ByteSize FileSize { get; }
+
+        public Attachment(string id, int? width, int? height, string url, string fileName, ByteSize fileSize)
         {
             Id = id;
-            Type = type;
             Url = url;
+            Width = width;
+            Height = height;
             FileName = fileName;
             FileSize = fileSize;
         }
+
+        public override string ToString() => FileName;
     }
 }

DiscordChatExporter.Core/Models/AuthToken.cs

@@ -0,0 +1,15 @@
+namespace DiscordChatExporter.Core.Models
+{
+    public class AuthToken
+    {
+        public AuthTokenType Type { get; }
+
+        public string Value { get; }
+
+        public AuthToken(AuthTokenType type, string value)
+        {
+            Type = type;
+            Value = value;
+        }
+    }
+}

DiscordChatExporter.Core/Models/AuthTokenType.cs

@@ -1,8 +1,8 @@
 namespace DiscordChatExporter.Core.Models
 {
-    public enum AttachmentType
+    public enum AuthTokenType
     {
-        Other,
-        Image
+        User,
+        Bot
     }
 }

DiscordChatExporter.Core/Models/Channel.cs

@@ -1,9 +1,13 @@
 namespace DiscordChatExporter.Core.Models
 {
+    // https://discordapp.com/developers/docs/resources/channel#channel-object
+
     public partial class Channel
     {
         public string Id { get; }
 
+        public string ParentId { get; }
+
         public string GuildId { get; }
 
         public string Name { get; }
@@ -11,27 +15,23 @@
         public string Topic { get; }
 
         public ChannelType Type { get; }
-
-        public Channel(string id, string guildId, string name, string topic, ChannelType type)
+        
+        public Channel(string id, string parentId, string guildId, string name, string topic, ChannelType type)
         {
             Id = id;
+            ParentId = parentId;
             GuildId = guildId;
             Name = name;
             Topic = topic;
             Type = type;
         }
 
-        public override string ToString()
-        {
-            return Name;
-        }
+        public override string ToString() => Name;
     }
 
     public partial class Channel
     {
-        public static Channel CreateDeletedChannel(string id)
-        {
-            return new Channel(id, null, "deleted-channel", null, ChannelType.GuildTextChat);
-        }
+        public static Channel CreateDeletedChannel(string id) =>
+            new Channel(id, null, null, "deleted-channel", null, ChannelType.GuildTextChat);
     }
 }

DiscordChatExporter.Core/Models/ChannelChatLog.cs

@@ -1,24 +0,0 @@
-using System.Collections.Generic;
-
-namespace DiscordChatExporter.Core.Models
-{
-    public class ChannelChatLog
-    {
-        public Guild Guild { get; }
-
-        public Channel Channel { get; }
-
-        public IReadOnlyList<MessageGroup> MessageGroups { get; }
-
-        public int TotalMessageCount { get; }
-
-        public ChannelChatLog(Guild guild, Channel channel, IReadOnlyList<MessageGroup> messageGroups,
-            int totalMessageCount)
-        {
-            Guild = guild;
-            Channel = channel;
-            MessageGroups = messageGroups;
-            TotalMessageCount = totalMessageCount;
-        }
-    }
-}

DiscordChatExporter.Core/Models/ChannelType.cs

@@ -1,5 +1,7 @@
 namespace DiscordChatExporter.Core.Models
 {
+    // https://discordapp.com/developers/docs/resources/channel#channel-object-channel-types
+
     public enum ChannelType
     {
         GuildTextChat,

DiscordChatExporter.Core/Models/ChatLog.cs

@@ -0,0 +1,33 @@
+using System;
+using System.Collections.Generic;
+
+namespace DiscordChatExporter.Core.Models
+{
+    public class ChatLog
+    {
+        public Guild Guild { get; }
+
+        public Channel Channel { get; }
+
+        public DateTime? From { get; }
+
+        public DateTime? To { get; }
+
+        public IReadOnlyList<Message> Messages { get; }
+
+        public Mentionables Mentionables { get; }
+
+        public ChatLog(Guild guild, Channel channel, DateTime? from, DateTime? to,
+            IReadOnlyList<Message> messages, Mentionables mentionables)
+        {
+            Guild = guild;
+            Channel = channel;
+            From = from;
+            To = to;
+            Messages = messages;
+            Mentionables = mentionables;
+        }
+
+        public override string ToString() => $"{Guild.Name} | {Channel.Name}";
+    }
+}

DiscordChatExporter.Core/Models/Embed.cs

@@ -0,0 +1,48 @@
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+
+namespace DiscordChatExporter.Core.Models
+{
+    // https://discordapp.com/developers/docs/resources/channel#embed-object
+
+    public class Embed
+    {
+        public string Title { get; }
+
+        public string Url { get; }
+
+        public DateTime? Timestamp { get; }
+
+        public Color Color { get; }
+
+        public EmbedAuthor Author { get; }
+
+        public string Description { get; }
+
+        public IReadOnlyList<EmbedField> Fields { get; }
+
+        public EmbedImage Thumbnail { get; }
+
+        public EmbedImage Image { get; }
+
+        public EmbedFooter Footer { get; }
+
+        public Embed(string title, string url, DateTime? timestamp, Color color, EmbedAuthor author, string description,
+            IReadOnlyList<EmbedField> fields, EmbedImage thumbnail, EmbedImage image, EmbedFooter footer)
+        {
+            Title = title;
+            Url = url;
+            Timestamp = timestamp;
+            Color = color;
+            Author = author;
+            Description = description;
+            Fields = fields;
+            Thumbnail = thumbnail;
+            Image = image;
+            Footer = footer;
+        }
+
+        public override string ToString() => Title;
+    }
+}

DiscordChatExporter.Core/Models/EmbedAuthor.cs

@@ -0,0 +1,22 @@
+namespace DiscordChatExporter.Core.Models
+{
+    // https://discordapp.com/developers/docs/resources/channel#embed-object-embed-author-structure
+
+    public class EmbedAuthor
+    {
+        public string Name { get; }
+
+        public string Url { get; }
+
+        public string IconUrl { get; }
+
+        public EmbedAuthor(string name, string url, string iconUrl)
+        {
+            Name = name;
+            Url = url;
+            IconUrl = iconUrl;
+        }
+
+        public override string ToString() => Name;
+    }
+}

DiscordChatExporter.Core/Models/EmbedField.cs

@@ -0,0 +1,22 @@
+namespace DiscordChatExporter.Core.Models
+{
+    // https://discordapp.com/developers/docs/resources/channel#embed-object-embed-field-structure
+
+    public class EmbedField
+    {
+        public string Name { get; }
+
+        public string Value { get; }
+
+        public bool IsInline { get; }
+
+        public EmbedField(string name, string value, bool isInline)
+        {
+            Name = name;
+            Value = value;
+            IsInline = isInline;
+        }
+
+        public override string ToString() => $"{Name} | {Value}";
+    }
+}

DiscordChatExporter.Core/Models/EmbedFooter.cs

@@ -0,0 +1,19 @@
+namespace DiscordChatExporter.Core.Models
+{
+    // https://discordapp.com/developers/docs/resources/channel#embed-object-embed-footer-structure
+
+    public class EmbedFooter
+    {
+        public string Text { get; }
+
+        public string IconUrl { get; }
+
+        public EmbedFooter(string text, string iconUrl)
+        {
+            Text = text;
+            IconUrl = iconUrl;
+        }
+
+        public override string ToString() => Text;
+    }
+}

DiscordChatExporter.Core/Models/EmbedImage.cs

@@ -0,0 +1,20 @@
+namespace DiscordChatExporter.Core.Models
+{
+    // https://discordapp.com/developers/docs/resources/channel#embed-object-embed-image-structure
+
+    public class EmbedImage
+    {
+        public string Url { get; }
+
+        public int? Width { get; }
+
+        public int? Height { get; }
+
+        public EmbedImage(string url, int? width, int? height)
+        {
+            Url = url;
+            Height = height;
+            Width = width;
+        }
+    }
+}

DiscordChatExporter.Core/Models/Emoji.cs

@@ -0,0 +1,56 @@
+using System.Collections.Generic;
+using System.Linq;
+using Tyrrrz.Extensions;
+
+namespace DiscordChatExporter.Core.Models
+{
+    // https://discordapp.com/developers/docs/resources/emoji#emoji-object
+
+    public partial class Emoji
+    {
+        public string Id { get; }
+
+        public string Name { get; }
+
+        public bool IsAnimated { get; }
+
+        public string ImageUrl
+        {
+            get
+            {
+                // Custom emoji
+                if (Id.IsNotBlank())
+                {
+                    // Animated
+                    if (IsAnimated)
+                        return $"https://cdn.discordapp.com/emojis/{Id}.gif";
+
+                    // Non-animated
+                    return $"https://cdn.discordapp.com/emojis/{Id}.png";
+                }
+
+                // Standard unicode emoji (via twemoji)
+                return $"https://twemoji.maxcdn.com/2/72x72/{GetTwemojiName(Name)}.png";
+            }
+        }
+
+        public Emoji(string id, string name, bool isAnimated)
+        {
+            Id = id;
+            Name = name;
+            IsAnimated = isAnimated;
+        }
+    }
+
+    public partial class Emoji
+    {
+        private static IEnumerable<int> GetCodePoints(string emoji)
+        {
+            for (var i = 0; i < emoji.Length; i += char.IsHighSurrogate(emoji[i]) ? 2 : 1)
+                yield return char.ConvertToUtf32(emoji, i);
+        }
+
+        private static string GetTwemojiName(string emoji)
+            => GetCodePoints(emoji).Select(i => i.ToString("x")).JoinToString("-");
+    }
+}

DiscordChatExporter.Core/Models/ExportFormat.cs

@@ -4,6 +4,7 @@
     {
         PlainText,
         HtmlDark,
-        HtmlLight
+        HtmlLight,
+        Csv
     }
 }

DiscordChatExporter.Core/Models/Extensions.cs

@@ -12,6 +12,8 @@ namespace DiscordChatExporter.Core.Models
                 return "html";
             if (format == ExportFormat.HtmlLight)
                 return "html";
+            if (format == ExportFormat.Csv)
+                return "csv";
 
             throw new ArgumentOutOfRangeException(nameof(format));
         }
@@ -24,6 +26,8 @@ namespace DiscordChatExporter.Core.Models
                 return "HTML (Dark)";
             if (format == ExportFormat.HtmlLight)
                 return "HTML (Light)";
+            if (format == ExportFormat.Csv)
+                return "Comma Seperated Values (CSV)";
 
             throw new ArgumentOutOfRangeException(nameof(format));
         }

DiscordChatExporter.Core/Models/Guild.cs

@@ -1,8 +1,9 @@
-using System.Collections.Generic;
-using Tyrrrz.Extensions;
+using Tyrrrz.Extensions;
 
 namespace DiscordChatExporter.Core.Models
 {
+    // https://discordapp.com/developers/docs/resources/guild#guild-object
+
     public partial class Guild
     {
         public string Id { get; }
@@ -15,24 +16,18 @@ namespace DiscordChatExporter.Core.Models
             ? $"https://cdn.discordapp.com/icons/{Id}/{IconHash}.png"
             : "https://cdn.discordapp.com/embed/avatars/0.png";
 
-        public IReadOnlyList<Role> Roles { get; }
-
-        public Guild(string id, string name, string iconHash, IReadOnlyList<Role> roles)
+        public Guild(string id, string name, string iconHash)
         {
             Id = id;
             Name = name;
             IconHash = iconHash;
-            Roles = roles;
         }
 
-        public override string ToString()
-        {
-            return Name;
-        }
+        public override string ToString() => Name;
     }
 
     public partial class Guild
     {
-        public static Guild DirectMessages { get; } = new Guild("@me", "Direct Messages", null, new Role[0]);
+        public static Guild DirectMessages { get; } = new Guild("@me", "Direct Messages", null);
     }
 }

DiscordChatExporter.Core/Models/Mentionables.cs

@@ -0,0 +1,30 @@
+using System.Collections.Generic;
+using System.Linq;
+
+namespace DiscordChatExporter.Core.Models
+{
+    public class Mentionables
+    {
+        public IReadOnlyList<User> Users { get; }
+
+        public IReadOnlyList<Channel> Channels { get; }
+
+        public IReadOnlyList<Role> Roles { get; }
+
+        public Mentionables(IReadOnlyList<User> users, IReadOnlyList<Channel> channels, IReadOnlyList<Role> roles)
+        {
+            Users = users;
+            Channels = channels;
+            Roles = roles;
+        }
+
+        public User GetUser(string id) =>
+            Users.FirstOrDefault(u => u.Id == id) ?? User.CreateUnknownUser(id);
+
+        public Channel GetChannel(string id) =>
+            Channels.FirstOrDefault(c => c.Id == id) ?? Channel.CreateDeletedChannel(id);
+
+        public Role GetRole(string id) =>
+            Roles.FirstOrDefault(r => r.Id == id) ?? Role.CreateDeletedRole(id);
+    }
+}

DiscordChatExporter.Core/Models/Message.cs

@@ -3,6 +3,8 @@ using System.Collections.Generic;
 
 namespace DiscordChatExporter.Core.Models
 {
+    // https://discordapp.com/developers/docs/resources/channel#message-object
+
     public class Message
     {
         public string Id { get; }
@@ -13,42 +15,37 @@ namespace DiscordChatExporter.Core.Models
 
         public User Author { get; }
 
-        public DateTime TimeStamp { get; }
+        public DateTime Timestamp { get; }
 
-        public DateTime? EditedTimeStamp { get; }
+        public DateTime? EditedTimestamp { get; }
 
         public string Content { get; }
 
         public IReadOnlyList<Attachment> Attachments { get; }
 
+        public IReadOnlyList<Embed> Embeds { get; }
+
+        public IReadOnlyList<Reaction> Reactions { get; }
+
         public IReadOnlyList<User> MentionedUsers { get; }
 
-        public IReadOnlyList<Role> MentionedRoles { get; }
-
-        public IReadOnlyList<Channel> MentionedChannels { get; }
-
-        public Message(string id, string channelId, MessageType type,
-            User author, DateTime timeStamp,
-            DateTime? editedTimeStamp, string content,
-            IReadOnlyList<Attachment> attachments, IReadOnlyList<User> mentionedUsers,
-            IReadOnlyList<Role> mentionedRoles, IReadOnlyList<Channel> mentionedChannels)
+        public Message(string id, string channelId, MessageType type, User author, DateTime timestamp,
+            DateTime? editedTimestamp, string content, IReadOnlyList<Attachment> attachments,
+            IReadOnlyList<Embed> embeds, IReadOnlyList<Reaction> reactions, IReadOnlyList<User> mentionedUsers)
         {
             Id = id;
             ChannelId = channelId;
             Type = type;
             Author = author;
-            TimeStamp = timeStamp;
-            EditedTimeStamp = editedTimeStamp;
+            Timestamp = timestamp;
+            EditedTimestamp = editedTimestamp;
             Content = content;
             Attachments = attachments;
+            Embeds = embeds;
+            Reactions = reactions;
             MentionedUsers = mentionedUsers;
-            MentionedRoles = mentionedRoles;
-            MentionedChannels = mentionedChannels;
         }
 
-        public override string ToString()
-        {
-            return Content;
-        }
+        public override string ToString() => Content;
     }
 }

DiscordChatExporter.Core/Models/MessageGroup.cs

@@ -1,21 +0,0 @@
-using System;
-using System.Collections.Generic;
-
-namespace DiscordChatExporter.Core.Models
-{
-    public class MessageGroup
-    {
-        public User Author { get; }
-
-        public DateTime TimeStamp { get; }
-
-        public IReadOnlyList<Message> Messages { get; }
-
-        public MessageGroup(User author, DateTime timeStamp, IReadOnlyList<Message> messages)
-        {
-            Author = author;
-            TimeStamp = timeStamp;
-            Messages = messages;
-        }
-    }
-}

DiscordChatExporter.Core/Models/MessageType.cs

@@ -1,5 +1,7 @@
 namespace DiscordChatExporter.Core.Models
 {
+    // https://discordapp.com/developers/docs/resources/channel#message-object-message-types
+
     public enum MessageType
     {
         Default,

DiscordChatExporter.Core/Models/Reaction.cs

@@ -0,0 +1,17 @@
+namespace DiscordChatExporter.Core.Models
+{
+    // https://discordapp.com/developers/docs/resources/channel#reaction-object
+
+    public class Reaction
+    {
+        public int Count { get; }
+
+        public Emoji Emoji { get; }
+
+        public Reaction(int count, Emoji emoji)
+        {
+            Count = count;
+            Emoji = emoji;
+        }
+    }
+}

DiscordChatExporter.Core/Models/Role.cs

@@ -1,5 +1,7 @@
 namespace DiscordChatExporter.Core.Models
 {
+    // https://discordapp.com/developers/docs/topics/permissions#role-object
+
     public partial class Role
     {
         public string Id { get; }
@@ -12,17 +14,12 @@
             Name = name;
         }
 
-        public override string ToString()
-        {
-            return Name;
-        }
+        public override string ToString() => Name;
     }
 
     public partial class Role
     {
-        public static Role CreateDeletedRole(string id)
-        {
-            return new Role(id, "deleted-role");
-        }
+        public static Role CreateDeletedRole(string id) =>
+            new Role(id, "deleted-role");
     }
 }

DiscordChatExporter.Core/Models/User.cs

@@ -1,8 +1,11 @@
-using Tyrrrz.Extensions;
+using System;
+using Tyrrrz.Extensions;
 
 namespace DiscordChatExporter.Core.Models
 {
-    public class User
+    // https://discordapp.com/developers/docs/topics/permissions#role-object
+
+    public partial class User
     {
         public string Id { get; }
 
@@ -12,13 +15,32 @@ namespace DiscordChatExporter.Core.Models
 
         public string FullName => $"{Name}#{Discriminator:0000}";
 
-        public string AvatarHash { get; }
-
         public string DefaultAvatarHash => $"{Discriminator % 5}";
 
-        public string AvatarUrl => AvatarHash.IsNotBlank()
-            ? $"https://cdn.discordapp.com/avatars/{Id}/{AvatarHash}.png"
-            : $"https://cdn.discordapp.com/embed/avatars/{DefaultAvatarHash}.png";
+        public string AvatarHash { get; }
+
+        public bool IsAvatarAnimated =>
+            AvatarHash.IsNotBlank() && AvatarHash.StartsWith("a_", StringComparison.Ordinal);
+
+        public string AvatarUrl
+        {
+            get
+            {
+                // Custom avatar
+                if (AvatarHash.IsNotBlank())
+                {
+                    // Animated
+                    if (IsAvatarAnimated)
+                        return $"https://cdn.discordapp.com/avatars/{Id}/{AvatarHash}.gif";
+
+                    // Non-animated
+                    return $"https://cdn.discordapp.com/avatars/{Id}/{AvatarHash}.png";
+                }
+
+                // Default avatar
+                return $"https://cdn.discordapp.com/embed/avatars/{DefaultAvatarHash}.png";
+            }
+        }
 
         public User(string id, int discriminator, string name, string avatarHash)
         {
@@ -28,9 +50,12 @@ namespace DiscordChatExporter.Core.Models
             AvatarHash = avatarHash;
         }
 
-        public override string ToString()
-        {
-            return FullName;
-        }
+        public override string ToString() => FullName;
+    }
+
+    public partial class User
+    {
+        public static User CreateUnknownUser(string id) =>
+            new User(id, 0, "Unknown", null);
     }
 }

DiscordChatExporter.Core/Resources/ExportService/DarkTheme.css

@@ -1,142 +0,0 @@
-body {
-    background-color: #36393E;
-    color: rgba(255, 255, 255, 0.7);
-    font-family: Whitney, Helvetica Neue, Helvetica, Arial, sans-serif;
-    font-size: 16px;
-}
-
-a {
-    color: #0096CF;
-    text-decoration: none;
-}
-
-a:hover {
-     text-decoration: underline;
-}
-
-div.pre {
-    background-color: #2F3136;
-    color: rgb(131, 148, 150);
-    font-family: Consolas, Courier New, Courier, Monospace;
-    margin-top: 4px;
-    padding: 8px;
-    white-space: pre-wrap;
-}
-
-span.pre {
-    background-color: #2F3136;
-    font-family: Consolas, Courier New, Courier, Monospace;
-    padding-left: 2px;
-    padding-right: 2px;
-    white-space: pre-wrap;
-}
-
-div#info {
-    display: flex;
-    margin-bottom: 10px;
-    margin-left: 5px;
-    margin-right: 5px;
-    max-width: 100%;
-}
-
-div#log {
-     max-width: 100%;
-}
-
-img.guild-icon {
-    max-height: 64px;
-    max-width: 64px;
-}
-
-div.info-right {
-    flex: 1;
-    margin-left: 10px;
-}
-
-div.guild-name {
-    color: #FFFFFF;
-    font-size: 1.4em;
-}
-
-div.channel-name {
-    color: #FFFFFF;
-    font-size: 1.2em;
-}
-
-div.channel-topic {
-    margin-top: 2px;
-    color: #FFFFFF;
-}
-
-div.channel-messagecount {
-    margin-top: 2px;
-}
-
-div.msg {
-    border-top: 1px solid rgba(255, 255, 255, 0.04);
-    display: flex;
-    margin-left: 10px;
-    margin-right: 10px;
-    padding-bottom: 15px;
-    padding-top: 15px;
-}
-
-div.msg-left {
-    height: 40px;
-    width: 40px;
-}
-
-img.msg-avatar {
-    border-radius: 50%;
-    height: 40px;
-    width: 40px;
-}
-
-div.msg-right {
-    flex: 1;
-    margin-left: 20px;
-    min-width: 50%;
-}
-
-span.msg-user {
-    color: #FFFFFF;
-    font-size: 1em;
-}
-
-span.msg-date {
-    color: rgba(255, 255, 255, 0.2);
-    font-size: .75em;
-    margin-left: 5px;
-}
-
-span.msg-edited {
-    color: rgba(255, 255, 255, 0.2);
-    font-size: .8em;
-    margin-left: 5px;
-}
-
-div.msg-content {
-    font-size: .9375em;
-    padding-top: 5px;
-    word-wrap: break-word;
-}
-
-div.msg-attachment {
-    margin-bottom: 5px;
-    margin-top: 5px;
-}
-
-img.msg-attachment {
-    max-height: 500px;
-    max-width: 50%;
-}
-
-img.emoji {
-    height: 24px;
-    width: 24px;
-    vertical-align: -.4em;
-}
-
-span.mention {
-    font-weight: 600;
-}

DiscordChatExporter.Core/Resources/ExportService/LightTheme.css

@@ -1,142 +0,0 @@
-body {
-    background-color: #FFFFFF;
-    color: #737F8D;
-    font-family: Whitney, Helvetica Neue, Helvetica, Arial, sans-serif;
-    font-size: 16px;
-}
-
-a {
-    color: #00B0F4;
-    text-decoration: none;
-}
-
-a:hover {
-     text-decoration: underline;
-}
-
-div.pre {
-    background-color: #F9F9F9;
-    color: rgb(101, 123, 131);
-    font-family: Consolas, Courier New, Courier, Monospace;
-    margin-top: 4px;
-    padding: 8px;
-    white-space: pre-wrap;
-}
-
-span.pre {
-    background-color: #F9F9F9;
-    font-family: Consolas, Courier New, Courier, Monospace;
-    padding-left: 2px;
-    padding-right: 2px;
-    white-space: pre-wrap;
-}
-
-div#info {
-    display: flex;
-    margin-bottom: 10px;
-    margin-left: 5px;
-    margin-right: 5px;
-    max-width: 100%;
-}
-
-div#log {
-     max-width: 100%;
-}
-
-img.guild-icon {
-    max-height: 64px;
-    max-width: 64px;
-}
-
-div.info-right {
-    flex: 1;
-    margin-left: 10px;
-}
-
-div.guild-name {
-    color: #2F3136;
-    font-size: 1.4em;
-}
-
-div.channel-name {
-    color: #2F3136;
-    font-size: 1.2em;
-}
-
-div.channel-topic {
-    margin-top: 2px;
-    color: #2F3136;
-}
-
-div.channel-messagecount {
-    margin-top: 2px;
-}
-
-div.msg {
-    border-top: 1px solid #ECEEEF;
-    display: flex;
-    margin-left: 10px;
-    margin-right: 10px;
-    padding-bottom: 15px;
-    padding-top: 15px;
-}
-
-div.msg-left {
-    height: 40px;
-    width: 40px;
-}
-
-img.msg-avatar {
-    border-radius: 50%;
-    height: 40px;
-    width: 40px;
-}
-
-div.msg-right {
-    flex: 1;
-    margin-left: 20px;
-    min-width: 50%;
-}
-
-span.msg-user {
-    color: #2F3136;
-    font-size: 1em;
-}
-
-span.msg-date {
-    color: #99AAB5;
-    font-size: .75em;
-    margin-left: 5px;
-}
-
-span.msg-edited {
-    color: #99AAB5;
-    font-size: .8em;
-    margin-left: 5px;
-}
-
-div.msg-content {
-    font-size: .9375em;
-    padding-top: 5px;
-    word-wrap: break-word;
-}
-
-div.msg-attachment {
-    margin-bottom: 5px;
-    margin-top: 5px;
-}
-
-img.msg-attachment {
-    max-height: 500px;
-    max-width: 50%;
-}
-
-img.emoji {
-    height: 24px;
-    width: 24px;
-    vertical-align: -.4em;
-}
-
-span.mention {
-    font-weight: 600;
-}

DiscordChatExporter.Core/Resources/ExportTemplates/Csv/Template.csv

@@ -0,0 +1,10 @@
+Author;Date;Content;Attachments;
+{{~ for message in Model.Messages -}}
+  {{- }}"{{ message.Author.FullName }}";
+
+  {{- }}"{{ message.Timestamp | FormatDate }}";
+
+  {{- }}"{{ message.Content | FormatMarkdown | string.replace "\"" "\"\"" }}";
+
+  {{- }}"{{ message.Attachments | array.map "Url" | array.join "," }}";
+{{~ end -}}

DiscordChatExporter.Core/Resources/ExportTemplates/HtmlDark/Template.html

@@ -0,0 +1,2 @@
+{{~ ThemeStyleSheet = include "HtmlDark.Theme.css" ~}}
+{{~ include "HtmlShared.Main.html" ~}}

DiscordChatExporter.Core/Resources/ExportTemplates/HtmlDark/Theme.css

@@ -0,0 +1,100 @@
+/* === GENERAL === */
+
+body {
+    background-color: #36393e;
+    color: #dcddde;
+}
+
+a {
+    color: #0096cf;
+}
+
+.spoiler {
+    background-color: rgba(255, 255, 255, 0.1);
+}
+
+.pre {
+    background-color: #2f3136;
+}
+
+.pre--multiline {
+    border-color: #282b30;
+    color: #839496;
+}
+
+.mention {
+    color: #7289da;
+}
+
+/* === INFO === */
+
+.info__guild-name {
+    color: #ffffff;
+}
+
+.info__channel-name {
+    color: #ffffff;
+}
+
+.info__channel-topic {
+    color: #ffffff;
+}
+
+/* === CHATLOG === */
+
+.chatlog__message-group {
+    border-color: rgba(255, 255, 255, 0.1);
+}
+
+.chatlog__author-name {
+    color: #ffffff;
+}
+
+.chatlog__timestamp {
+    color: rgba(255, 255, 255, 0.2);
+}
+
+.chatlog__edited-timestamp {
+    color: rgba(255, 255, 255, 0.2);
+}
+
+.chatlog__embed-content-container {
+    background-color: rgba(46, 48, 54, 0.3);
+    border-color: rgba(46, 48, 54, 0.6);
+}
+
+.chatlog__embed-author-name {
+    color: #ffffff;
+}
+
+.chatlog__embed-author-name-link {
+    color: #ffffff;
+}
+
+.chatlog__embed-title {
+    color: #ffffff;
+}
+
+.chatlog__embed-description {
+    color: rgba(255, 255, 255, 0.6);
+}
+
+.chatlog__embed-field-name {
+    color: #ffffff;
+}
+
+.chatlog__embed-field-value {
+    color: rgba(255, 255, 255, 0.6);
+}
+
+.chatlog__embed-footer {
+    color: rgba(255, 255, 255, 0.6);
+}
+
+.chatlog__reaction {
+    background-color: rgba(255, 255, 255, 0.05);
+}
+
+.chatlog__reaction-count {
+    color: rgba(255, 255, 255, 0.3);
+}

DiscordChatExporter.Core/Resources/ExportTemplates/HtmlLight/Template.html

@@ -0,0 +1,2 @@
+{{~ ThemeStyleSheet = include "HtmlLight.Theme.css" ~}}
+{{~ include "HtmlShared.Main.html" ~}}

DiscordChatExporter.Core/Resources/ExportTemplates/HtmlLight/Theme.css

@@ -0,0 +1,101 @@
+/* === GENERAL === */
+
+body {
+    background-color: #ffffff;
+    color: #747f8d;
+}
+
+a {
+    color: #00b0f4;
+}
+
+.spoiler {
+    background-color: rgba(0, 0, 0, 0.1);
+}
+
+.pre {
+    background-color: #f9f9f9;
+}
+
+.pre--multiline {
+    border-color: #f3f3f3;
+    color: #657b83;
+}
+
+.mention {
+    background-color: #f1f3fb;
+    color: #7289da;
+}
+
+/* === INFO === */
+
+.info__guild-name {
+    color: #2f3136;
+}
+
+.info__channel-name {
+    color: #2f3136;
+}
+
+.info__channel-topic {
+    color: #2f3136;
+}
+
+/* === CHATLOG === */
+
+.chatlog__message-group {
+    border-color: #eceeef;
+}
+
+.chatlog__author-name {
+    color: #2f3136;
+}
+
+.chatlog__timestamp {
+    color: #99aab5;
+}
+
+.chatlog__edited-timestamp {
+    color: #99aab5;
+}
+
+.chatlog__embed-content-container {
+    background-color: rgba(249, 249, 249, 0.3);
+    border-color: rgba(204, 204, 204, 0.3);
+}
+
+.chatlog__embed-author-name {
+    color: #4f545c;
+}
+
+.chatlog__embed-author-name-link {
+    color: #4f545c;
+}
+
+.chatlog__embed-title {
+    color: #4f545c;
+}
+
+.chatlog__embed-description {
+    color: #737f8d;
+}
+
+.chatlog__embed-field-name {
+    color: #36393e;
+}
+
+.chatlog__embed-field-value {
+    color: #737f8d;
+}
+
+.chatlog__embed-footer {
+    color: rgba(79, 83, 91, 0.4);
+}
+
+.chatlog__reaction {
+    background-color: rgba(79, 84, 92, 0.06);
+}
+
+.chatlog__reaction-count {
+    color: #99aab5;
+}

DiscordChatExporter.Core/Resources/ExportTemplates/HtmlShared/Main.css

@@ -0,0 +1,311 @@
+/* === GENERAL === */
+
+body {
+    font-family: "Whitney", "Helvetica Neue", Helvetica, Arial, sans-serif;
+    font-size: 16px;
+}
+
+a {
+    text-decoration: none;
+}
+
+a:hover {
+    text-decoration: underline;
+}
+
+img {
+    object-fit: contain;
+}
+
+.markdown {
+    white-space: pre-wrap;
+    line-height: 1.3;
+    overflow-wrap: break-word;
+}
+
+.spoiler {
+    border-radius: 3px;
+}
+
+.pre {
+    font-family: "Consolas", "Courier New", Courier, Monospace;
+}
+
+.pre--multiline {
+    margin-top: 4px;
+    padding: 8px;
+    border: 2px solid;
+    border-radius: 5px;    
+}
+
+.pre--inline {
+    padding: 2px;
+    border-radius: 3px;
+}
+
+.mention {
+    font-weight: 500;
+}
+
+.emoji {
+    width: 1.45em;
+    height: 1.45em;
+    margin: 0 1px;
+    vertical-align: -0.4em;
+}
+
+.emoji--small {
+    width: 1rem;
+    height: 1rem;
+}
+
+.emoji--large {
+    width: 2rem;
+    height: 2rem;
+}
+
+/* === INFO === */
+
+.info {
+    display: flex;
+    max-width: 100%;
+    margin: 0 5px 10px 5px;    
+}
+
+.info__guild-icon-container {
+    flex: 0;
+}
+
+.info__guild-icon {
+    max-width: 88px;
+    max-height: 88px;
+}
+
+.info__metadata {
+    flex: 1;
+    margin-left: 10px;
+}
+
+.info__guild-name {
+    font-size: 1.4em;
+}
+
+.info__channel-name {
+    font-size: 1.2em;
+}
+
+.info__channel-topic {
+    margin-top: 2px;
+}
+
+.info__channel-message-count {
+    margin-top: 2px;
+}
+
+.info__channel-date-range {
+    margin-top: 2px;
+}
+
+/* === CHATLOG === */
+
+.chatlog {
+    max-width: 100%;
+}
+
+.chatlog__message-group {
+    display: flex;
+    margin: 0 10px;
+    padding: 15px 0;
+    border-top: 1px solid;
+}
+
+.chatlog__author-avatar-container {
+    flex: 0;
+    width: 40px;
+    height: 40px;
+}
+
+.chatlog__author-avatar {
+    border-radius: 50%;
+    height: 40px;
+    width: 40px;
+}
+
+.chatlog__messages {
+    flex: 1;
+    min-width: 50%;
+    margin-left: 20px;
+}
+
+.chatlog__author-name {
+    font-size: 1em;
+    font-weight: 500;
+}
+
+.chatlog__timestamp {
+    margin-left: 5px;
+    font-size: .75em;
+}
+
+.chatlog__content {
+    padding-top: 5px;
+    font-size: .9375em;
+    word-wrap: break-word;
+}
+
+.chatlog__edited-timestamp {
+    margin-left: 3px;
+    font-size: .8em;
+}
+
+.chatlog__attachment {
+    margin: 5px 0;
+}
+
+.chatlog__attachment-thumbnail {
+    max-width: 50%;
+    max-height: 500px;
+    border-radius: 3px;
+}
+
+.chatlog__embed {
+    display: flex;
+    max-width: 520px;
+    margin-top: 5px;
+}
+
+.chatlog__embed-color-pill {
+    flex-shrink: 0;
+    width: 4px;
+    border-top-left-radius: 3px;
+    border-bottom-left-radius: 3px;
+}
+
+.chatlog__embed-content-container {
+    display: flex;
+    flex-direction: column;
+    padding: 8px 10px;
+    border: 1px solid;
+    border-top-right-radius: 3px;
+    border-bottom-right-radius: 3px;
+}
+
+.chatlog__embed-content {
+    width: 100%;
+    display: flex;
+}
+
+.chatlog__embed-text {
+    flex: 1;
+}
+
+.chatlog__embed-author {
+    display: flex;
+    align-items: center;
+    margin-bottom: 5px;
+}
+
+.chatlog__embed-author-icon {
+    width: 20px;
+    height: 20px;
+    margin-right: 9px;
+    border-radius: 50%;
+}
+
+.chatlog__embed-author-name {
+    font-size: .875em;
+    font-weight: 600;
+}
+
+.chatlog__embed-title {
+    margin-bottom: 4px;
+    font-size: .875em;
+    font-weight: 600;
+}
+
+.chatlog__embed-description {
+    font-weight: 500;
+    font-size: 14px;
+}
+
+.chatlog__embed-fields {
+    display: flex;
+    flex-wrap: wrap;
+}
+
+.chatlog__embed-field {
+    flex: 0;
+    min-width: 100%;
+    max-width: 506px;
+    padding-top: 10px;
+}
+
+.chatlog__embed-field--inline {
+    flex: 1;
+    flex-basis: auto;
+    min-width: 150px;
+}
+
+.chatlog__embed-field-name {
+    margin-bottom: 4px;
+    font-size: .875em;
+    font-weight: 600;
+}
+
+.chatlog__embed-field-value {
+    font-size: .875em;
+    font-weight: 500;
+}
+
+.chatlog__embed-thumbnail {
+    flex: 0;
+    margin-left: 20px;
+    max-width: 80px;
+    max-height: 80px;
+    border-radius: 3px;
+}
+
+.chatlog__embed-image-container {
+    margin-top: 10px;
+}
+
+.chatlog__embed-image {    
+    max-width: 500px;
+    max-height: 400px;
+    border-radius: 3px;
+}
+
+.chatlog__embed-footer {
+    margin-top: 10px;
+}
+
+.chatlog__embed-footer-icon {
+    margin-right: 4px;
+    width: 20px;
+    height: 20px;
+    border-radius: 50%;
+    vertical-align: middle;
+}
+
+.chatlog__embed-footer-text {
+    font-weight: 600;
+    font-size: .75em;
+}
+
+.chatlog__reactions {
+    display: flex;
+}
+
+.chatlog__reaction {
+    display: flex;
+    align-items: center;
+    margin: 6px 2px 2px 2px;
+    padding: 3px 6px;
+    border-radius: 3px;
+}
+
+.chatlog__reaction-count {
+    min-width: 9px;
+    margin-left: 6px;
+    font-size: .875em;
+}

DiscordChatExporter.Core/Resources/ExportTemplates/HtmlShared/Main.html

@@ -0,0 +1,211 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <title>{{ Model.Guild.Name | html.escape }} - {{ Model.Channel.Name | html.escape }}</title>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width" />
+    <style>
+        {{ include "HtmlShared.Main.css" }}
+    </style>
+    <style>
+        {{ ThemeStyleSheet }}
+    </style>
+</head>
+<body>
+    
+{{~ # Info ~}}
+<div class="info">
+    <div class="info__guild-icon-container">
+        <img class="info__guild-icon" src="{{ Model.Guild.IconUrl }}" />
+    </div>
+    <div class="info__metadata">
+        <div class="info__guild-name">{{ Model.Guild.Name | html.escape }}</div>
+        <div class="info__channel-name">{{ Model.Channel.Name | html.escape }}</div>
+        
+        {{~ if Model.Channel.Topic ~}}
+            <div class="info__channel-topic">{{ Model.Channel.Topic | html.escape }}</div>
+        {{~ end ~}}
+
+        <div class="info__channel-message-count">{{ Model.Messages | array.size | Format "N0" }} messages</div>
+        
+        {{~ if Model.From || Model.To ~}}
+            <div class="info__channel-date-range">
+                {{~ if Model.From && Model.To ~}}
+                    Between {{ Model.From | FormatDate | html.escape }} and {{ Model.To | FormatDate | html.escape }}
+                {{~ else if Model.From ~}}
+                    After {{ Model.From | FormatDate | html.escape }}
+                {{~ else if Model.To ~}}
+                    Before {{ Model.To | FormatDate | html.escape }}
+                {{~ end ~}}
+            </div>
+        {{~ end ~}}
+    </div>
+</div>
+
+{{~ # Log ~}}
+<div class="chatlog">
+    {{~ for group in Model.Messages | GroupMessages ~}}
+        <div class="chatlog__message-group">
+            {{~ # Avatar ~}}
+            <div class="chatlog__author-avatar-container">
+                <img class="chatlog__author-avatar" src="{{ group.Author.AvatarUrl }}" />
+            </div>            
+            <div class="chatlog__messages">
+                {{~ # Author name and timestamp ~}}
+                <span class="chatlog__author-name" title="{{ group.Author.FullName | html.escape }}">{{ group.Author.Name | html.escape }}</span>
+                <span class="chatlog__timestamp">{{ group.Timestamp | FormatDate | html.escape }}</span>
+
+                {{~ # Messages ~}}
+                {{~ for message in group.Messages ~}}
+                    {{~ # Content ~}}
+                    {{~ if message.Content ~}}
+                        <div class="chatlog__content">
+                            <span class="markdown">{{ message.Content | FormatMarkdown }}</span>
+
+                            {{~ # Edited timestamp ~}}
+                            {{~ if message.EditedTimestamp ~}}
+                                <span class="chatlog__edited-timestamp" title="{{ message.EditedTimestamp | FormatDate | html.escape }}">(edited)</span>
+                            {{~ end ~}}
+                        </div>
+                    {{~ end ~}}
+
+                    {{~ # Attachments ~}}
+                    {{~ for attachment in message.Attachments ~}}
+                        <div class="chatlog__attachment">
+                            <a href="{{ attachment.Url }}">
+                                {{ # Image }}
+                                {{~ if attachment.IsImage ~}}
+                                    <img class="chatlog__attachment-thumbnail" src="{{ attachment.Url }}" />
+                                {{~ # Non-image ~}}
+                                {{~ else ~}}
+                                    Attachment: {{ attachment.FileName }} ({{ attachment.FileSize }})
+                                {{~ end ~}}
+                            </a>
+                        </div>
+                    {{~ end ~}}
+
+                    {{~ # Embeds ~}}
+                    {{~ for embed in message.Embeds ~}}
+                        <div class="chatlog__embed">
+                            <div class="chatlog__embed-color-pill" style="background-color: rgba({{ embed.Color.R }},{{ embed.Color.G }},{{ embed.Color.B }},{{ embed.Color.A }})"></div>
+                            <div class="chatlog__embed-content-container">
+                                <div class="chatlog__embed-content">
+                                    <div class="chatlog__embed-text">
+                                        {{~ # Author ~}}
+                                        {{~ if embed.Author ~}}
+                                            <div class="chatlog__embed-author">
+                                                {{~ if embed.Author.IconUrl ~}}
+                                                    <img class="chatlog__embed-author-icon" src="{{ embed.Author.IconUrl }}" />
+                                                {{~ end ~}}
+
+                                                {{~ if embed.Author.Name ~}}
+                                                    <span class="chatlog__embed-author-name">
+                                                        {{~ if embed.Author.Url ~}}
+                                                            <a class="chatlog__embed-author-name-link" href="{{ embed.Author.Url }}">{{ embed.Author.Name | html.escape }}</a>
+                                                        {{~ else ~}}
+                                                            {{ embed.Author.Name | html.escape }}
+                                                        {{~ end ~}}
+                                                    </span>
+                                                {{~ end ~}}
+                                            </div>
+                                        {{~ end ~}}
+
+                                        {{~ # Title ~}}
+                                        {{~ if embed.Title ~}}
+                                            <div class="chatlog__embed-title">
+                                                {{~ if embed.Url ~}}
+                                                    <a class="chatlog__embed-title-link" href="{{ embed.Url }}"><span class="markdown">{{ embed.Title | FormatMarkdown }}</span></a>
+                                                {{~ else ~}}
+                                                    <span class="markdown">{{ embed.Title | FormatMarkdown }}</span>
+                                                {{~ end ~}}
+                                            </div>
+                                        {{~ end ~}}
+
+                                        {{~ # Description ~}}
+                                        {{~ if embed.Description ~}}
+                                        <div class="chatlog__embed-description"><span class="markdown">{{ embed.Description | FormatMarkdown }}</span></div>
+                                        {{~ end ~}}
+
+                                        {{~ # Fields ~}}
+                                        {{~ if embed.Fields | array.size > 0 ~}}
+                                            <div class="chatlog__embed-fields">
+                                                {{~ for field in embed.Fields ~}}
+                                                    <div class="chatlog__embed-field {{ if field.IsInline }} chatlog__embed-field--inline {{ end }}">
+                                                        {{~ if field.Name ~}}
+                                                            <div class="chatlog__embed-field-name"><span class="markdown">{{ field.Name | FormatMarkdown }}</span></div>
+                                                        {{~ end ~}}
+                                                        {{~ if field.Value ~}}
+                                                            <div class="chatlog__embed-field-value"><span class="markdown">{{ field.Value | FormatMarkdown }}</span></div>
+                                                        {{~ end ~}}
+                                                    </div>
+                                                {{~ end ~}}
+                                            </div>
+                                        {{~ end ~}}
+                                    </div>
+
+                                    {{~ # Thumbnail ~}}
+                                    {{~ if embed.Thumbnail ~}}
+                                        <div class="chatlog__embed-thumbnail-container">
+                                            <a class="chatlog__embed-thumbnail-link" href="{{ embed.Thumbnail.Url }}">
+                                                <img class="chatlog__embed-thumbnail" src="{{ embed.Thumbnail.Url }}" />
+                                            </a>
+                                        </div>
+                                    {{~ end ~}}
+                                </div>    
+
+                                {{~ # Image ~}} 
+                                {{~ if embed.Image ~}}
+                                    <div class="chatlog__embed-image-container">
+                                        <a class="chatlog__embed-image-link" href="{{ embed.Image.Url }}">
+                                            <img class="chatlog__embed-image" src="{{ embed.Image.Url }}" />
+                                        </a>
+                                    </div>
+                                {{~ end ~}}
+
+                                {{~ # Footer ~}}
+                                {{~ if embed.Footer || embed.Timestamp ~}}
+                                    <div class="chatlog__embed-footer">
+                                        {{~ if embed.Footer ~}}
+                                            {{~ if embed.Footer.Text && embed.Footer.IconUrl ~}}
+                                                <img class="chatlog__embed-footer-icon" src="{{ embed.Footer.IconUrl }}" />
+                                            {{~ end ~}}
+                                        {{~ end ~}}
+                                        
+                                        <span class="chatlog__embed-footer-text">
+                                            {{~ if embed.Footer ~}}
+                                                {{~ if embed.Footer.Text ~}}
+                                                    {{ embed.Footer.Text | html.escape }}
+                                                    {{ if embed.Timestamp }} • {{ end }}
+                                                {{~ end ~}}
+                                            {{~ end ~}}
+
+                                            {{~ if embed.Timestamp ~}}
+                                                {{ embed.Timestamp | FormatDate | html.escape }}
+                                            {{~ end ~}}
+                                        </span>
+                                    </div>
+                                {{~ end ~}}
+                            </div>
+                        </div>
+                    {{~ end ~}}
+
+                    {{~ # Reactions ~}}
+                    {{~ if message.Reactions | array.size > 0 ~}}
+                        <div class="chatlog__reactions">
+                            {{~ for reaction in message.Reactions ~}}
+                                <div class="chatlog__reaction">
+                                    <img class="emoji emoji--small" title="{{ reaction.Emoji.Name }}" src="{{ reaction.Emoji.ImageUrl }}" />
+                                    <span class="chatlog__reaction-count">{{ reaction.Count }}</span>
+                                </div>
+                            {{~ end ~}}
+                        </div>
+                    {{~ end ~}}
+                {{~ end ~}}
+            </div>
+        </div>
+    {{~ end ~}}
+</div>
+
+</body>
+</html>

DiscordChatExporter.Core/Resources/ExportTemplates/PlainText/Template.txt

@@ -0,0 +1,21 @@
+{{~ # Info ~}}
+==============================================================
+Guild:    {{ Model.Guild.Name }}
+Channel:  {{ Model.Channel.Name }}
+Topic:    {{ Model.Channel.Topic }}
+Messages: {{ Model.Messages | array.size | Format "N0" }}
+Range:    {{ if Model.From }}{{ Model.From | FormatDate }} {{ end }}{{ if Model.From || Model.To }}->{{ end }}{{ if Model.To }} {{ Model.To | FormatDate }}{{ end }}
+==============================================================
+
+{{~ # Log ~}}
+{{~ for message in Model.Messages ~}}
+  {{~ # Author name and timestamp ~}}
+  {{~ }}[{{ message.Timestamp | FormatDate }}] {{ message.Author.FullName }}
+  {{~ # Content ~}}
+  {{~ message.Content | FormatMarkdown }}
+  {{~ # Attachments ~}}
+  {{~ for attachment in message.Attachments ~}}
+    {{~ attachment.Url }}
+  {{~ end ~}}
+
+{{~ end ~}}

DiscordChatExporter.Core/Services/DataService.Parsers.cs

@@ -0,0 +1,208 @@
+using System;
+using System.Drawing;
+using System.Linq;
+using ByteSizeLib;
+using DiscordChatExporter.Core.Internal;
+using DiscordChatExporter.Core.Models;
+using Newtonsoft.Json.Linq;
+using Tyrrrz.Extensions;
+
+namespace DiscordChatExporter.Core.Services
+{
+    public partial class DataService
+    {
+        private User ParseUser(JToken json)
+        {
+            var id = json["id"].Value<string>();
+            var discriminator = json["discriminator"].Value<int>();
+            var name = json["username"].Value<string>();
+            var avatarHash = json["avatar"].Value<string>();
+
+            return new User(id, discriminator, name, avatarHash);
+        }
+
+        private Guild ParseGuild(JToken json)
+        {
+            var id = json["id"].Value<string>();
+            var name = json["name"].Value<string>();
+            var iconHash = json["icon"].Value<string>();
+
+            return new Guild(id, name, iconHash);
+        }
+
+        private Channel ParseChannel(JToken json)
+        {
+            // Get basic data
+            var id = json["id"].Value<string>();
+            var parentId = json["parent_id"]?.Value<string>();
+            var type = (ChannelType) json["type"].Value<int>();
+            var topic = json["topic"]?.Value<string>();
+
+            // Try to extract guild ID
+            var guildId = json["guild_id"]?.Value<string>();
+
+            // If the guild ID is blank, it's direct messages
+            if (guildId.IsBlank())
+                guildId = Guild.DirectMessages.Id;
+
+            // Try to extract name
+            var name = json["name"]?.Value<string>();
+
+            // If the name is blank, it's direct messages
+            if (name.IsBlank())
+                name = json["recipients"].Select(ParseUser).Select(u => u.Name).JoinToString(", ");
+
+            return new Channel(id, parentId, guildId, name, topic, type);
+        }
+
+        private Role ParseRole(JToken json)
+        {
+            var id = json["id"].Value<string>();
+            var name = json["name"].Value<string>();
+
+            return new Role(id, name);
+        }
+
+        private Attachment ParseAttachment(JToken json)
+        {
+            var id = json["id"].Value<string>();
+            var url = json["url"].Value<string>();
+            var width = json["width"]?.Value<int>();
+            var height = json["height"]?.Value<int>();
+            var fileName = json["filename"].Value<string>();
+            var fileSizeBytes = json["size"].Value<long>();
+
+            var fileSize = ByteSize.FromBytes(fileSizeBytes);
+
+            return new Attachment(id, width, height, url, fileName, fileSize);
+        }
+
+        private EmbedAuthor ParseEmbedAuthor(JToken json)
+        {
+            var name = json["name"]?.Value<string>();
+            var url = json["url"]?.Value<string>();
+            var iconUrl = json["icon_url"]?.Value<string>();
+
+            return new EmbedAuthor(name, url, iconUrl);
+        }
+
+        private EmbedField ParseEmbedField(JToken json)
+        {
+            var name = json["name"].Value<string>();
+            var value = json["value"].Value<string>();
+            var isInline = json["inline"]?.Value<bool>() ?? false;
+
+            return new EmbedField(name, value, isInline);
+        }
+
+        private EmbedImage ParseEmbedImage(JToken json)
+        {
+            var url = json["url"]?.Value<string>();
+            var width = json["width"]?.Value<int>();
+            var height = json["height"]?.Value<int>();
+
+            return new EmbedImage(url, width, height);
+        }
+
+        private EmbedFooter ParseEmbedFooter(JToken json)
+        {
+            var text = json["text"].Value<string>();
+            var iconUrl = json["icon_url"]?.Value<string>();
+
+            return new EmbedFooter(text, iconUrl);
+        }
+
+        private Embed ParseEmbed(JToken json)
+        {
+            // Get basic data
+            var title = json["title"]?.Value<string>();
+            var description = json["description"]?.Value<string>();
+            var url = json["url"]?.Value<string>();
+            var timestamp = json["timestamp"]?.Value<DateTime>();
+
+            // Get color
+            var color = json["color"] != null
+                ? Color.FromArgb(json["color"].Value<int>()).ResetAlpha()
+                : Color.FromArgb(79, 84, 92); // default color
+
+            // Get author
+            var author = json["author"] != null ? ParseEmbedAuthor(json["author"]) : null;
+
+            // Get fields
+            var fields = json["fields"].EmptyIfNull().Select(ParseEmbedField).ToArray();
+
+            // Get thumbnail
+            var thumbnail = json["thumbnail"] != null ? ParseEmbedImage(json["thumbnail"]) : null;
+
+            // Get image
+            var image = json["image"] != null ? ParseEmbedImage(json["image"]) : null;
+
+            // Get footer
+            var footer = json["footer"] != null ? ParseEmbedFooter(json["footer"]) : null;
+
+            return new Embed(title, url, timestamp, color, author, description, fields, thumbnail, image, footer);
+        }
+
+        private Emoji ParseEmoji(JToken json)
+        {
+            var id = json["id"]?.Value<string>();
+            var name = json["name"]?.Value<string>();
+            var isAnimated = json["animated"]?.Value<bool>() ?? false;
+
+            return new Emoji(id, name, isAnimated);
+        }
+
+        private Reaction ParseReaction(JToken json)
+        {
+            var count = json["count"].Value<int>();
+            var emoji = ParseEmoji(json["emoji"]);
+
+            return new Reaction(count, emoji);
+        }
+
+        private Message ParseMessage(JToken json)
+        {
+            // Get basic data
+            var id = json["id"].Value<string>();
+            var channelId = json["channel_id"].Value<string>();
+            var timestamp = json["timestamp"].Value<DateTime>();
+            var editedTimestamp = json["edited_timestamp"]?.Value<DateTime?>();
+            var content = json["content"].Value<string>();
+            var type = (MessageType) json["type"].Value<int>();
+
+            // Workarounds for non-default types
+            if (type == MessageType.RecipientAdd)
+                content = "Added a recipient.";
+            else if (type == MessageType.RecipientRemove)
+                content = "Removed a recipient.";
+            else if (type == MessageType.Call)
+                content = "Started a call.";
+            else if (type == MessageType.ChannelNameChange)
+                content = "Changed the channel name.";
+            else if (type == MessageType.ChannelIconChange)
+                content = "Changed the channel icon.";
+            else if (type == MessageType.ChannelPinnedMessage)
+                content = "Pinned a message.";
+            else if (type == MessageType.GuildMemberJoin)
+                content = "Joined the server.";
+
+            // Get author
+            var author = ParseUser(json["author"]);
+
+            // Get attachments
+            var attachments = json["attachments"].EmptyIfNull().Select(ParseAttachment).ToArray();
+
+            // Get embeds
+            var embeds = json["embeds"].EmptyIfNull().Select(ParseEmbed).ToArray();
+
+            // Get reactions
+            var reactions = json["reactions"].EmptyIfNull().Select(ParseReaction).ToArray();
+
+            // Get mentioned users
+            var mentionedUsers = json["mentions"].EmptyIfNull().Select(ParseUser).ToArray();
+
+            return new Message(id, channelId, type, author, timestamp, editedTimestamp, content, attachments, embeds,
+                reactions, mentionedUsers);
+        }
+    }
+}

DiscordChatExporter.Core/Services/DataService.cs

@@ -1,326 +1,257 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Net;
 using System.Net.Http;
-using System.Text.RegularExpressions;
+using System.Net.Http.Headers;
 using System.Threading.Tasks;
 using DiscordChatExporter.Core.Exceptions;
 using DiscordChatExporter.Core.Models;
 using Newtonsoft.Json.Linq;
+using DiscordChatExporter.Core.Internal;
+using Failsafe;
 using Tyrrrz.Extensions;
 
 namespace DiscordChatExporter.Core.Services
 {
-    public partial class DataService : IDataService, IDisposable
+    public partial class DataService : IDisposable
     {
-        private const string ApiRoot = "https://discordapp.com/api/v6";
-
         private readonly HttpClient _httpClient = new HttpClient();
-        private readonly Dictionary<string, Role> _roleCache = new Dictionary<string, Role>();
-        private readonly Dictionary<string, Channel> _channelCache = new Dictionary<string, Channel>();
 
-        private User ParseUser(JToken token)
+        private async Task<JToken> GetApiResponseAsync(AuthToken token, string resource, string endpoint,
+            params string[] parameters)
         {
-            var id = token["id"].Value<string>();
-            var discriminator = token["discriminator"].Value<int>();
-            var name = token["username"].Value<string>();
-            var avatarHash = token["avatar"].Value<string>();
+            // Create retry policy
+            var retry = Retry.Create()
+                .Catch<HttpErrorStatusCodeException>(false, e => e.StatusCode == HttpStatusCode.ServiceUnavailable)
+                .Catch<HttpErrorStatusCodeException>(false, e => (int) e.StatusCode == 429)
+                .WithMaxTryCount(10)
+                .WithDelay(TimeSpan.FromSeconds(0.4));
 
-            return new User(id, discriminator, name, avatarHash);
-        }
-
-        private Role ParseRole(JToken token)
-        {
-            var id = token["id"].Value<string>();
-            var name = token["name"].Value<string>();
-
-            return new Role(id, name);
-        }
-
-        private Guild ParseGuild(JToken token)
-        {
-            var id = token["id"].Value<string>();
-            var name = token["name"].Value<string>();
-            var iconHash = token["icon"].Value<string>();
-            var roles = token["roles"].Select(ParseRole).ToArray();
-
-            return new Guild(id, name, iconHash, roles);
-        }
-
-        private Channel ParseChannel(JToken token)
-        {
-            // Get basic data
-            var id = token["id"].Value<string>();
-            var guildId = token["guild_id"]?.Value<string>();
-            var type = (ChannelType) token["type"].Value<int>();
-            var topic = token["topic"]?.Value<string>();
-
-            // Extract name based on type
-            string name;
-            if (type.IsEither(ChannelType.DirectTextChat, ChannelType.DirectGroupTextChat))
+            // Send request
+            return await retry.ExecuteAsync(async () =>
             {
-                guildId = Guild.DirectMessages.Id;
+                // Create request
+                const string apiRoot = "https://discordapp.com/api/v6";
+                using (var request = new HttpRequestMessage(HttpMethod.Get, $"{apiRoot}/{resource}/{endpoint}"))
+                {
+                    // Set authorization header
+                    request.Headers.Authorization = token.Type == AuthTokenType.Bot
+                        ? new AuthenticationHeaderValue("Bot", token.Value)
+                        : new AuthenticationHeaderValue(token.Value);
 
-                // Try to get name if it's set
-                name = token["name"]?.Value<string>();
+                    // Add parameters
+                    foreach (var parameter in parameters.ExceptBlank())
+                    {
+                        var key = parameter.SubstringUntil("=");
+                        var value = parameter.SubstringAfter("=");
 
-                // Otherwise use recipients as the name
-                if (name.IsBlank())
-                    name = token["recipients"].Select(ParseUser).Select(u => u.Name).JoinToString(", ");
-            }
-            else
-            {
-                name = token["name"].Value<string>();
-            }
+                        // Skip empty values
+                        if (value.IsBlank())
+                            continue;
 
-            return new Channel(id, guildId, name, topic, type);
+                        request.RequestUri = request.RequestUri.SetQueryParameter(key, value);
+                    }
+
+                    // Get response
+                    using (var response = await _httpClient.SendAsync(request))
+                    {
+                        // Check status code
+                        // We throw our own exception here because default one doesn't have status code
+                        if (!response.IsSuccessStatusCode)
+                            throw new HttpErrorStatusCodeException(response.StatusCode, response.ReasonPhrase);
+
+                        // Get content
+                        var raw = await response.Content.ReadAsStringAsync();
+
+                        // Parse
+                        return JToken.Parse(raw);
+                    }
+                }
+            });
         }
 
-        private Message ParseMessage(JToken token)
+        public async Task<Guild> GetGuildAsync(AuthToken token, string guildId)
         {
-            // Get basic data
-            var id = token["id"].Value<string>();
-            var channelId = token["channel_id"].Value<string>();
-            var timeStamp = token["timestamp"].Value<DateTime>();
-            var editedTimeStamp = token["edited_timestamp"]?.Value<DateTime?>();
-            var content = token["content"].Value<string>();
-            var type = (MessageType) token["type"].Value<int>();
+            // Special case for direct messages pseudo-guild
+            if (guildId == Guild.DirectMessages.Id)
+                return Guild.DirectMessages;
 
-            // Workarounds for non-default types
-            if (type == MessageType.RecipientAdd)
-                content = "Added a recipient.";
-            else if (type == MessageType.RecipientRemove)
-                content = "Removed a recipient.";
-            else if (type == MessageType.Call)
-                content = "Started a call.";
-            else if (type == MessageType.ChannelNameChange)
-                content = "Changed the channel name.";
-            else if (type == MessageType.ChannelIconChange)
-                content = "Changed the channel icon.";
-            else if (type == MessageType.ChannelPinnedMessage)
-                content = "Pinned a message.";
-            else if (type == MessageType.GuildMemberJoin)
-                content = "Joined the server.";
-
-            // Get author
-            var author = ParseUser(token["author"]);
-
-            // Get attachment
-            var attachments = new List<Attachment>();
-            foreach (var attachmentJson in token["attachments"].EmptyIfNull())
-            {
-                var attachmentId = attachmentJson["id"].Value<string>();
-                var attachmentUrl = attachmentJson["url"].Value<string>();
-                var attachmentType = attachmentJson["width"] != null
-                    ? AttachmentType.Image
-                    : AttachmentType.Other;
-                var attachmentFileName = attachmentJson["filename"].Value<string>();
-                var attachmentFileSize = attachmentJson["size"].Value<long>();
-
-                var attachment = new Attachment(
-                    attachmentId, attachmentType, attachmentUrl,
-                    attachmentFileName, attachmentFileSize);
-                attachments.Add(attachment);
-            }
-
-            // Get user mentions
-            var mentionedUsers = token["mentions"].Select(ParseUser).ToArray();
-
-            // Get role mentions
-            var mentionedRoles = token["mention_roles"]
-                .Values<string>()
-                .Select(i => _roleCache.GetOrDefault(i) ?? Role.CreateDeletedRole(id))
-                .ToArray();
-
-            // Get channel mentions
-            var mentionedChannels = Regex.Matches(content, "<#(\\d+)>")
-                .Cast<Match>()
-                .Select(m => m.Groups[1].Value)
-                .ExceptBlank()
-                .Select(i => _channelCache.GetOrDefault(i) ?? Channel.CreateDeletedChannel(id))
-                .ToArray();
-
-            return new Message(id, channelId, type, author, timeStamp, editedTimeStamp, content, attachments,
-                mentionedUsers, mentionedRoles, mentionedChannels);
-        }
-
-        private async Task<string> GetStringAsync(string url)
-        {
-            using (var response = await _httpClient.GetAsync(url))
-            {
-                // Check status code
-                // We throw our own exception here because default one doesn't have status code
-                if (!response.IsSuccessStatusCode)
-                    throw new HttpErrorStatusCodeException(response.StatusCode);
-
-                // Get content
-                return await response.Content.ReadAsStringAsync();
-            }
-        }
-
-        public async Task<Guild> GetGuildAsync(string token, string guildId)
-        {
-            // Form request url
-            var url = $"{ApiRoot}/guilds/{guildId}?token={token}";
-
-            // Get response
-            var content = await GetStringAsync(url);
-
-            // Parse
-            var guild = ParseGuild(JToken.Parse(content));
-
-            // Add roles to cache
-            foreach (var role in guild.Roles)
-                _roleCache[role.Id] = role;
+            var response = await GetApiResponseAsync(token, "guilds", guildId);
+            var guild = ParseGuild(response);
 
             return guild;
         }
 
-        public async Task<Channel> GetChannelAsync(string token, string channelId)
+        public async Task<Channel> GetChannelAsync(AuthToken token, string channelId)
         {
-            // Form request url
-            var url = $"{ApiRoot}/channels/{channelId}?token={token}";
-
-            // Get response
-            var content = await GetStringAsync(url);
-
-            // Parse
-            var channel = ParseChannel(JToken.Parse(content));
-
-            // Add channel to cache
-            _channelCache[channel.Id] = channel;
+            var response = await GetApiResponseAsync(token, "channels", channelId);
+            var channel = ParseChannel(response);
 
             return channel;
         }
 
-        public async Task<IReadOnlyList<Channel>> GetGuildChannelsAsync(string token, string guildId)
+        public async Task<IReadOnlyList<Guild>> GetUserGuildsAsync(AuthToken token)
         {
-            // Form request url
-            var url = $"{ApiRoot}/guilds/{guildId}/channels?token={token}";
-
-            // Get response
-            var content = await GetStringAsync(url);
-
-            // Parse
-            var channels = JArray.Parse(content).Select(ParseChannel).ToArray();
-
-            // Add channels to cache
-            foreach (var channel in channels)
-                _channelCache[channel.Id] = channel;
-
-            return channels;
-        }
-
-        public async Task<IReadOnlyList<Guild>> GetUserGuildsAsync(string token)
-        {
-            // Form request url
-            var url = $"{ApiRoot}/users/@me/guilds?token={token}&limit=100";
-
-            // Get response
-            var content = await GetStringAsync(url);
-
-            // Parse IDs
-            var guildIds = JArray.Parse(content).Select(t => t["id"].Value<string>());
-
-            // Get full guild infos
-            var guilds = new List<Guild>();
-            foreach (var guildId in guildIds)
-            {
-                var guild = await GetGuildAsync(token, guildId);
-                guilds.Add(guild);
-            }
+            var response = await GetApiResponseAsync(token, "users", "@me/guilds", "limit=100");
+            var guilds = response.Select(ParseGuild).ToArray();
 
             return guilds;
         }
 
-        public async Task<IReadOnlyList<Channel>> GetDirectMessageChannelsAsync(string token)
+        public async Task<IReadOnlyList<Channel>> GetDirectMessageChannelsAsync(AuthToken token)
         {
-            // Form request url
-            var url = $"{ApiRoot}/users/@me/channels?token={token}";
-
-            // Get response
-            var content = await GetStringAsync(url);
-
-            // Parse
-            var channels = JArray.Parse(content).Select(ParseChannel).ToArray();
+            var response = await GetApiResponseAsync(token, "users", "@me/channels");
+            var channels = response.Select(ParseChannel).ToArray();
 
             return channels;
         }
 
-        public async Task<IReadOnlyList<Message>> GetChannelMessagesAsync(string token, string channelId,
-            DateTime? from, DateTime? to)
+        public async Task<IReadOnlyList<Channel>> GetGuildChannelsAsync(AuthToken token, string guildId)
+        {
+            var response = await GetApiResponseAsync(token, "guilds", $"{guildId}/channels");
+            var channels = response.Select(ParseChannel).ToArray();
+
+            return channels;
+        }
+
+        public async Task<IReadOnlyList<Role>> GetGuildRolesAsync(AuthToken token, string guildId)
+        {
+            var response = await GetApiResponseAsync(token, "guilds", $"{guildId}/roles");
+            var roles = response.Select(ParseRole).ToArray();
+
+            return roles;
+        }
+
+        public async Task<IReadOnlyList<Message>> GetChannelMessagesAsync(AuthToken token, string channelId,
+            DateTime? from = null, DateTime? to = null, IProgress<double> progress = null)
         {
             var result = new List<Message>();
 
-            // We are going backwards from last message to first
-            // collecting everything between them in batches
-            var beforeId = to != null ? DateTimeToSnowflake(to.Value) : null;
-            while (true)
+            // Get the last message
+            var response = await GetApiResponseAsync(token, "channels", $"{channelId}/messages",
+                "limit=1", $"before={to?.ToSnowflake()}");
+            var lastMessage = response.Select(ParseMessage).FirstOrDefault();
+
+            // If the last message doesn't exist or it's outside of range - return
+            if (lastMessage == null || lastMessage.Timestamp < from)
             {
-                // Form request url
-                var url = $"{ApiRoot}/channels/{channelId}/messages?token={token}&limit=100";
-                if (beforeId.IsNotBlank())
-                    url += $"&before={beforeId}";
-
-                // Get response
-                var content = await GetStringAsync(url);
-
-                // Parse
-                var messages = JArray.Parse(content).Select(ParseMessage);
-
-                // Add messages to list
-                string currentMessageId = null;
-                foreach (var message in messages)
-                {
-                    // Break when the message is older than from date
-                    if (from != null && message.TimeStamp < from)
-                    {
-                        currentMessageId = null;
-                        break;
-                    }
-
-                    // Add message
-                    result.Add(message);
-                    currentMessageId = message.Id;
-                }
-
-                // If no messages - break
-                if (currentMessageId == null)
-                    break;
-
-                // Otherwise offset the next request
-                beforeId = currentMessageId;
+                progress?.Report(1);
+                return result;
             }
 
-            // Messages appear newest first, we need to reverse
-            result.Reverse();
+            // Get other messages
+            var offsetId = from?.ToSnowflake() ?? "0";
+            while (true)
+            {
+                // Get message batch
+                response = await GetApiResponseAsync(token, "channels", $"{channelId}/messages",
+                    "limit=100", $"after={offsetId}");
+
+                // Parse
+                var messages = response
+                    .Select(ParseMessage)
+                    .Reverse() // reverse because messages appear newest first
+                    .ToArray();
+
+                // Break if there are no messages (can happen if messages are deleted during execution)
+                if (!messages.Any())
+                    break;
+
+                // Trim messages to range (until last message)
+                var messagesInRange = messages
+                    .TakeWhile(m => m.Id != lastMessage.Id && m.Timestamp < lastMessage.Timestamp)
+                    .ToArray();
+
+                // Add to result
+                result.AddRange(messagesInRange);
+
+                // Break if messages were trimmed (which means the last message was encountered)
+                if (messagesInRange.Length != messages.Length)
+                    break;
+
+                // Report progress (based on the time range of parsed messages compared to total)
+                progress?.Report((result.Last().Timestamp - result.First().Timestamp).TotalSeconds /
+                                 (lastMessage.Timestamp - result.First().Timestamp).TotalSeconds);
+
+                // Move offset
+                offsetId = result.Last().Id;
+            }
+
+            // Add last message
+            result.Add(lastMessage);
+
+            // Report progress
+            progress?.Report(1);
 
             return result;
         }
 
-        protected virtual void Dispose(bool disposing)
+        public async Task<Mentionables> GetMentionablesAsync(AuthToken token, string guildId,
+            IEnumerable<Message> messages)
         {
-            if (disposing)
+            // Get channels and roles
+            var channels = guildId != Guild.DirectMessages.Id
+                ? await GetGuildChannelsAsync(token, guildId)
+                : Array.Empty<Channel>();
+            var roles = guildId != Guild.DirectMessages.Id
+                ? await GetGuildRolesAsync(token, guildId)
+                : Array.Empty<Role>();
+
+            // Get users
+            var userMap = new Dictionary<string, User>();
+            foreach (var message in messages)
             {
-                _httpClient.Dispose();
+                // Author
+                userMap[message.Author.Id] = message.Author;
+
+                // Mentioned users
+                foreach (var mentionedUser in message.MentionedUsers)
+                    userMap[mentionedUser.Id] = mentionedUser;
             }
+
+            var users = userMap.Values.ToArray();
+
+            return new Mentionables(users, channels, roles);
+        }
+
+        public async Task<ChatLog> GetChatLogAsync(AuthToken token, Guild guild, Channel channel,
+            DateTime? from = null, DateTime? to = null, IProgress<double> progress = null)
+        {
+            // Get messages
+            var messages = await GetChannelMessagesAsync(token, channel.Id, from, to, progress);
+
+            // Get mentionables
+            var mentionables = await GetMentionablesAsync(token, guild.Id, messages);
+
+            return new ChatLog(guild, channel, from, to, messages, mentionables);
+        }
+
+        public async Task<ChatLog> GetChatLogAsync(AuthToken token, Channel channel,
+            DateTime? from = null, DateTime? to = null, IProgress<double> progress = null)
+        {
+            // Get guild
+            var guild = channel.GuildId == Guild.DirectMessages.Id
+                ? Guild.DirectMessages
+                : await GetGuildAsync(token, channel.GuildId);
+
+            // Get the chat log
+            return await GetChatLogAsync(token, guild, channel, from, to, progress);
+        }
+
+        public async Task<ChatLog> GetChatLogAsync(AuthToken token, string channelId,
+            DateTime? from = null, DateTime? to = null, IProgress<double> progress = null)
+        {
+            // Get channel
+            var channel = await GetChannelAsync(token, channelId);
+
+            // Get the chat log
+            return await GetChatLogAsync(token, channel, from, to, progress);
         }
 
         public void Dispose()
         {
-            Dispose(true);
-            GC.SuppressFinalize(this);
-        }
-    }
-
-    public partial class DataService
-    {
-        private static string DateTimeToSnowflake(DateTime dateTime)
-        {
-            const long epoch = 62135596800000;
-            var unixTime = dateTime.ToUniversalTime().Ticks / TimeSpan.TicksPerMillisecond - epoch;
-            var value = ((ulong) unixTime - 1420070400000UL) << 22;
-            return value.ToString();
+            _httpClient.Dispose();
         }
     }
 }

DiscordChatExporter.Core/Services/ExportService.Html.cs

@@ -1,208 +0,0 @@
-using System.IO;
-using System.Text.RegularExpressions;
-using System.Threading.Tasks;
-using DiscordChatExporter.Core.Models;
-using Tyrrrz.Extensions;
-
-namespace DiscordChatExporter.Core.Services
-{
-    public partial class ExportService
-    {
-        private string FormatMessageContentHtml(Message message)
-        {
-            // A lot of these regexes were inspired by or taken from MarkdownSharp
-
-            var content = message.Content;
-
-            // HTML-encode content
-            content = HtmlEncode(content);
-
-            // Encode multiline codeblocks (```text```)
-            content = Regex.Replace(content,
-                @"```+(?:[^`]*?\n)?([^`]+)\n?```+",
-                m => $"\x1AM{Base64Encode(m.Groups[1].Value)}\x1AM");
-
-            // Encode inline codeblocks (`text`)
-            content = Regex.Replace(content,
-                @"`([^`]+)`",
-                m => $"\x1AI{Base64Encode(m.Groups[1].Value)}\x1AI");
-
-            // Encode URLs
-            content = Regex.Replace(content,
-                @"((https?|ftp)://[-a-zA-Z0-9+&@#/%?=~_|!:,\.\[\]\(\);]*[-a-zA-Z0-9+&@#/%=~_|\[\])])(?=$|\W)",
-                m => $"\x1AL{Base64Encode(m.Groups[1].Value)}\x1AL");
-
-            // Process bold (**text**)
-            content = Regex.Replace(content, @"(\*\*)(?=\S)(.+?[*_]*)(?<=\S)\1", "<b>$2</b>");
-
-            // Process underline (__text__)
-            content = Regex.Replace(content, @"(__)(?=\S)(.+?)(?<=\S)\1", "<u>$2</u>");
-
-            // Process italic (*text* or _text_)
-            content = Regex.Replace(content, @"(\*|_)(?=\S)(.+?)(?<=\S)\1", "<i>$2</i>");
-
-            // Process strike through (~~text~~)
-            content = Regex.Replace(content, @"(~~)(?=\S)(.+?)(?<=\S)\1", "<s>$2</s>");
-
-            // Decode and process multiline codeblocks
-            content = Regex.Replace(content, "\x1AM(.*?)\x1AM",
-                m => $"<div class=\"pre\">{Base64Decode(m.Groups[1].Value)}</div>");
-
-            // Decode and process inline codeblocks
-            content = Regex.Replace(content, "\x1AI(.*?)\x1AI",
-                m => $"<span class=\"pre\">{Base64Decode(m.Groups[1].Value)}</span>");
-
-            // Decode and process URLs
-            content = Regex.Replace(content, "\x1AL(.*?)\x1AL",
-                m => $"<a href=\"{Base64Decode(m.Groups[1].Value)}\">{Base64Decode(m.Groups[1].Value)}</a>");
-
-            // New lines
-            content = content.Replace("\n", "<br />");
-
-            // Meta mentions (@everyone)
-            content = content.Replace("@everyone", "<span class=\"mention\">@everyone</span>");
-
-            // Meta mentions (@here)
-            content = content.Replace("@here", "<span class=\"mention\">@here</span>");
-
-            // User mentions (<@id> and <@!id>)
-            foreach (var mentionedUser in message.MentionedUsers)
-            {
-                content = Regex.Replace(content, $"&lt;@!?{mentionedUser.Id}&gt;",
-                    $"<span class=\"mention\" title=\"{HtmlEncode(mentionedUser.FullName)}\">" +
-                    $"@{HtmlEncode(mentionedUser.Name)}" +
-                    "</span>");
-            }
-
-            // Role mentions (<@&id>)
-            foreach (var mentionedRole in message.MentionedRoles)
-            {
-                content = content.Replace($"&lt;@&amp;{mentionedRole.Id}&gt;",
-                    "<span class=\"mention\">" +
-                    $"@{HtmlEncode(mentionedRole.Name)}" +
-                    "</span>");
-            }
-
-            // Channel mentions (<#id>)
-            foreach (var mentionedChannel in message.MentionedChannels)
-            {
-                content = content.Replace($"&lt;#{mentionedChannel.Id}&gt;",
-                    "<span class=\"mention\">" +
-                    $"#{HtmlEncode(mentionedChannel.Name)}" +
-                    "</span>");
-            }
-
-            // Custom emojis (<:name:id>)
-            content = Regex.Replace(content, "&lt;(:.*?:)(\\d*)&gt;",
-                "<img class=\"emoji\" title=\"$1\" src=\"https://cdn.discordapp.com/emojis/$2.png\" />");
-
-            return content;
-        }
-
-        private async Task ExportAsHtmlAsync(ChannelChatLog log, TextWriter output, string css)
-        {
-            // Generation info
-            await output.WriteLineAsync("<!-- https://github.com/Tyrrrz/DiscordChatExporter -->");
-
-            // Html start
-            await output.WriteLineAsync("<!DOCTYPE html>");
-            await output.WriteLineAsync("<html lang=\"en\">");
-
-            // HEAD
-            await output.WriteLineAsync("<head>");
-            await output.WriteLineAsync($"<title>{log.Guild.Name} - {log.Channel.Name}</title>");
-            await output.WriteLineAsync("<meta charset=\"utf-8\" />");
-            await output.WriteLineAsync("<meta name=\"viewport\" content=\"width=device-width\" />");
-            await output.WriteLineAsync($"<style>{css}</style>");
-            await output.WriteLineAsync("</head>");
-
-            // Body start
-            await output.WriteLineAsync("<body>");
-
-            // Guild and channel info
-            await output.WriteLineAsync("<div id=\"info\">");
-            await output.WriteLineAsync("<div class=\"info-left\">");
-            await output.WriteLineAsync($"<img class=\"guild-icon\" src=\"{log.Guild.IconUrl}\" />");
-            await output.WriteLineAsync("</div>"); // info-left
-            await output.WriteLineAsync("<div class=\"info-right\">");
-            await output.WriteLineAsync($"<div class=\"guild-name\">{log.Guild.Name}</div>");
-            await output.WriteLineAsync($"<div class=\"channel-name\">{log.Channel.Name}</div>");
-            await output.WriteLineAsync($"<div class=\"channel-topic\">{log.Channel.Topic}</div>");
-            await output.WriteLineAsync(
-                $"<div class=\"channel-messagecount\">{log.TotalMessageCount:N0} messages</div>");
-            await output.WriteLineAsync("</div>"); // info-right
-            await output.WriteLineAsync("</div>"); // info
-
-            // Chat log
-            await output.WriteLineAsync("<div id=\"log\">");
-            foreach (var group in log.MessageGroups)
-            {
-                await output.WriteLineAsync("<div class=\"msg\">");
-                await output.WriteLineAsync("<div class=\"msg-left\">");
-                await output.WriteLineAsync($"<img class=\"msg-avatar\" src=\"{group.Author.AvatarUrl}\" />");
-                await output.WriteLineAsync("</div>");
-
-                await output.WriteLineAsync("<div class=\"msg-right\">");
-                await output.WriteAsync(
-                    $"<span class=\"msg-user\" title=\"{HtmlEncode(group.Author.FullName)}\">");
-                await output.WriteAsync(HtmlEncode(group.Author.Name));
-                await output.WriteLineAsync("</span>");
-                var timeStampFormatted = HtmlEncode(group.TimeStamp.ToString(_settingsService.DateFormat));
-                await output.WriteLineAsync($"<span class=\"msg-date\">{timeStampFormatted}</span>");
-
-                // Messages
-                foreach (var message in group.Messages)
-                {
-                    // Content
-                    if (message.Content.IsNotBlank())
-                    {
-                        await output.WriteLineAsync("<div class=\"msg-content\">");
-                        var contentFormatted = FormatMessageContentHtml(message);
-                        await output.WriteAsync(contentFormatted);
-
-                        // Edited timestamp
-                        if (message.EditedTimeStamp != null)
-                        {
-                            var editedTimeStampFormatted =
-                                HtmlEncode(message.EditedTimeStamp.Value.ToString(_settingsService.DateFormat));
-                            await output.WriteAsync(
-                                $"<span class=\"msg-edited\" title=\"{editedTimeStampFormatted}\">(edited)</span>");
-                        }
-
-                        await output.WriteLineAsync("</div>"); // msg-content
-                    }
-
-                    // Attachments
-                    foreach (var attachment in message.Attachments)
-                    {
-                        if (attachment.Type == AttachmentType.Image)
-                        {
-                            await output.WriteLineAsync("<div class=\"msg-attachment\">");
-                            await output.WriteLineAsync($"<a href=\"{attachment.Url}\">");
-                            await output.WriteLineAsync($"<img class=\"msg-attachment\" src=\"{attachment.Url}\" />");
-                            await output.WriteLineAsync("</a>");
-                            await output.WriteLineAsync("</div>");
-                        }
-                        else
-                        {
-                            await output.WriteLineAsync("<div class=\"msg-attachment\">");
-                            await output.WriteLineAsync($"<a href=\"{attachment.Url}\">");
-                            var fileSizeFormatted = FormatFileSize(attachment.FileSize);
-                            await output.WriteLineAsync($"Attachment: {attachment.FileName} ({fileSizeFormatted})");
-                            await output.WriteLineAsync("</a>");
-                            await output.WriteLineAsync("</div>");
-                        }
-                    }
-                }
-
-                await output.WriteLineAsync("</div>"); // msg-right
-                await output.WriteLineAsync("</div>"); // msg
-            }
-
-            await output.WriteLineAsync("</div>"); // log
-
-            await output.WriteLineAsync("</body>");
-            await output.WriteLineAsync("</html>");
-        }
-    }
-}

DiscordChatExporter.Core/Services/ExportService.MessageGroup.cs

@@ -0,0 +1,25 @@
+using System;
+using System.Collections.Generic;
+using DiscordChatExporter.Core.Models;
+
+namespace DiscordChatExporter.Core.Services
+{
+    public partial class ExportService
+    {
+        private class MessageGroup
+        {
+            public User Author { get; }
+
+            public DateTime Timestamp { get; }
+
+            public IReadOnlyList<Message> Messages { get; }
+
+            public MessageGroup(User author, DateTime timestamp, IReadOnlyList<Message> messages)
+            {
+                Author = author;
+                Timestamp = timestamp;
+                Messages = messages;
+            }
+        }
+    }
+}

DiscordChatExporter.Core/Services/ExportService.PlainText.cs

@@ -1,79 +0,0 @@
-using System;
-using System.IO;
-using System.Text.RegularExpressions;
-using System.Threading.Tasks;
-using DiscordChatExporter.Core.Models;
-using Tyrrrz.Extensions;
-
-namespace DiscordChatExporter.Core.Services
-{
-    public partial class ExportService
-    {
-        private string FormatMessageContentPlainText(Message message)
-        {
-            var content = message.Content;
-
-            // New lines
-            content = content.Replace("\n", Environment.NewLine);
-
-            // User mentions (<@id> and <@!id>)
-            foreach (var mentionedUser in message.MentionedUsers)
-                content = Regex.Replace(content, $"<@!?{mentionedUser.Id}>", $"@{mentionedUser}");
-
-            // Role mentions (<@&id>)
-            foreach (var mentionedRole in message.MentionedRoles)
-                content = content.Replace($"<@&{mentionedRole.Id}>", $"@{mentionedRole.Name}");
-
-            // Channel mentions (<#id>)
-            foreach (var mentionedChannel in message.MentionedChannels)
-                content = content.Replace($"<#{mentionedChannel.Id}>", $"#{mentionedChannel.Name}");
-
-            // Custom emojis (<:name:id>)
-            content = Regex.Replace(content, "<(:.*?:)\\d*>", "$1");
-
-            return content;
-        }
-
-        private async Task ExportAsPlainTextAsync(ChannelChatLog log, TextWriter output)
-        {
-            // Generation info
-            await output.WriteLineAsync("https://github.com/Tyrrrz/DiscordChatExporter");
-            await output.WriteLineAsync();
-
-            // Guild and channel info
-            await output.WriteLineAsync('='.Repeat(48));
-            await output.WriteLineAsync($"Guild: {log.Guild.Name}");
-            await output.WriteLineAsync($"Channel: {log.Channel.Name}");
-            await output.WriteLineAsync($"Topic: {log.Channel.Topic}");
-            await output.WriteLineAsync($"Messages: {log.TotalMessageCount:N0}");
-            await output.WriteLineAsync('='.Repeat(48));
-            await output.WriteLineAsync();
-
-            // Chat log
-            foreach (var group in log.MessageGroups)
-            {
-                var timeStampFormatted = group.TimeStamp.ToString(_settingsService.DateFormat);
-                await output.WriteLineAsync($"{group.Author.FullName}  [{timeStampFormatted}]");
-
-                // Messages
-                foreach (var message in group.Messages)
-                {
-                    // Content
-                    if (message.Content.IsNotBlank())
-                    {
-                        var contentFormatted = FormatMessageContentPlainText(message);
-                        await output.WriteLineAsync(contentFormatted);
-                    }
-
-                    // Attachments
-                    foreach (var attachment in message.Attachments)
-                    {
-                        await output.WriteLineAsync(attachment.Url);
-                    }
-                }
-
-                await output.WriteLineAsync();
-            }
-        }
-    }
-}

DiscordChatExporter.Core/Services/ExportService.TemplateLoader.cs

@@ -0,0 +1,37 @@
+using System.Reflection;
+using DiscordChatExporter.Core.Models;
+using Scriban;
+using Scriban.Parsing;
+using Scriban.Runtime;
+using Tyrrrz.Extensions;
+
+namespace DiscordChatExporter.Core.Services
+{
+    public partial class ExportService
+    {
+        private class TemplateLoader : ITemplateLoader
+        {
+            private const string ResourceRootNamespace = "DiscordChatExporter.Core.Resources.ExportTemplates";
+
+            public string GetPath(TemplateContext context, SourceSpan callerSpan, string templateName)
+            {
+                return $"{ResourceRootNamespace}.{templateName}";
+            }
+
+            public string GetPath(ExportFormat format)
+            {
+                return $"{ResourceRootNamespace}.{format}.Template.{format.GetFileExtension()}";
+            }
+
+            public string Load(TemplateContext context, SourceSpan callerSpan, string templatePath)
+            {
+                return Assembly.GetExecutingAssembly().GetManifestResourceString(templatePath);
+            }
+
+            public string Load(ExportFormat format)
+            {
+                return Assembly.GetExecutingAssembly().GetManifestResourceString(GetPath(format));
+            }
+        }
+    }
+}

DiscordChatExporter.Core/Services/ExportService.TemplateModel.cs

@@ -0,0 +1,254 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Text;
+using DiscordChatExporter.Core.Internal;
+using DiscordChatExporter.Core.Markdown;
+using DiscordChatExporter.Core.Models;
+using Scriban.Runtime;
+using Tyrrrz.Extensions;
+
+namespace DiscordChatExporter.Core.Services
+{
+    public partial class ExportService
+    {
+        private class TemplateModel
+        {
+            private readonly ExportFormat _format;
+            private readonly ChatLog _log;
+            private readonly string _dateFormat;
+            private readonly int _messageGroupLimit;
+
+            public TemplateModel(ExportFormat format, ChatLog log, string dateFormat, int messageGroupLimit)
+            {
+                _format = format;
+                _log = log;
+                _dateFormat = dateFormat;
+                _messageGroupLimit = messageGroupLimit;
+            }
+
+            private IEnumerable<MessageGroup> GroupMessages(IEnumerable<Message> messages)
+            {
+                // Group adjacent messages by timestamp and author
+                var buffer = new List<Message>();
+                foreach (var message in messages)
+                {
+                    // Get first message of the group
+                    var groupFirstMessage = buffer.FirstOrDefault();
+
+                    // Group break condition
+                    var breakCondition =
+                        groupFirstMessage != null &&
+                        (
+                            message.Author.Id != groupFirstMessage.Author.Id || // when author changes
+                            (message.Timestamp - groupFirstMessage.Timestamp).TotalHours > 1 || // when difference in timestamps is an hour or more
+                            message.Timestamp.Hour != groupFirstMessage.Timestamp.Hour || // when the timestamp's hour changes
+                            buffer.Count >= _messageGroupLimit // when group is full
+                        );
+
+                    // If condition is true - flush buffer
+                    if (breakCondition)
+                    {
+                        var group = new MessageGroup(groupFirstMessage.Author, groupFirstMessage.Timestamp, buffer);
+
+                        // Reset the buffer instead of clearing to avoid mutations on existing references
+                        buffer = new List<Message>();
+
+                        yield return group;
+                    }
+
+                    // Add message to buffer
+                    buffer.Add(message);
+                }
+
+                // Add what's remaining in buffer
+                if (buffer.Any())
+                {
+                    var groupFirstMessage = buffer.First();
+                    var group = new MessageGroup(groupFirstMessage.Author, groupFirstMessage.Timestamp, buffer);
+
+                    yield return group;
+                }
+            }
+
+            private string Format(IFormattable obj, string format) =>
+                obj.ToString(format, CultureInfo.InvariantCulture);
+
+            private string FormatDate(DateTime dateTime) => Format(dateTime, _dateFormat);
+
+            private string FormatMarkdownPlainText(IReadOnlyList<Node> nodes)
+            {
+                var buffer = new StringBuilder();
+
+                foreach (var node in nodes)
+                {
+                    if (node is FormattedNode formattedNode)
+                    {
+                        var innerText = FormatMarkdownPlainText(formattedNode.Children);
+                        buffer.Append($"{formattedNode.Token}{innerText}{formattedNode.Token}");
+                    }
+
+                    else if (node is MentionNode mentionNode && mentionNode.Type != MentionType.Meta)
+                    {
+                        if (mentionNode.Type == MentionType.User)
+                        {
+                            var user = _log.Mentionables.GetUser(mentionNode.Id);
+                            buffer.Append($"@{user.Name}");
+                        }
+
+                        else if (mentionNode.Type == MentionType.Channel)
+                        {
+                            var channel = _log.Mentionables.GetChannel(mentionNode.Id);
+                            buffer.Append($"#{channel.Name}");
+                        }
+
+                        else if (mentionNode.Type == MentionType.Role)
+                        {
+                            var role = _log.Mentionables.GetRole(mentionNode.Id);
+                            buffer.Append($"@{role.Name}");
+                        }
+                    }
+
+                    else if (node is EmojiNode emojiNode)
+                    {
+                        buffer.Append(emojiNode.IsCustomEmoji ? $":{emojiNode.Name}:" : node.Lexeme);
+                    }
+
+                    else
+                    {
+                        buffer.Append(node.Lexeme);
+                    }
+                }
+
+                return buffer.ToString();
+            }
+
+            private string FormatMarkdownPlainText(string input)
+                => FormatMarkdownPlainText(MarkdownParser.Parse(input));
+
+            private string FormatMarkdownHtml(IReadOnlyList<Node> nodes, int depth = 0)
+            {
+                var buffer = new StringBuilder();
+
+                foreach (var node in nodes)
+                {
+                    if (node is TextNode textNode)
+                    {
+                        buffer.Append(textNode.Text.HtmlEncode());
+                    }
+
+                    else if (node is FormattedNode formattedNode)
+                    {
+                        var innerHtml = FormatMarkdownHtml(formattedNode.Children, depth + 1);
+
+                        if (formattedNode.Formatting == TextFormatting.Bold)
+                            buffer.Append($"<strong>{innerHtml}</strong>");
+
+                        else if (formattedNode.Formatting == TextFormatting.Italic)
+                            buffer.Append($"<em>{innerHtml}</em>");
+
+                        else if (formattedNode.Formatting == TextFormatting.Underline)
+                            buffer.Append($"<u>{innerHtml}</u>");
+
+                        else if (formattedNode.Formatting == TextFormatting.Strikethrough)
+                            buffer.Append($"<s>{innerHtml}</s>");
+
+                        else if (formattedNode.Formatting == TextFormatting.Spoiler)
+                            buffer.Append($"<span class=\"spoiler\">{innerHtml}</span>");
+                    }
+
+                    else if (node is InlineCodeBlockNode inlineCodeBlockNode)
+                    {
+                        buffer.Append($"<span class=\"pre pre--inline\">{inlineCodeBlockNode.Code.HtmlEncode()}</span>");
+                    }
+
+                    else if (node is MultilineCodeBlockNode multilineCodeBlockNode)
+                    {
+                        // Set language class for syntax highlighting
+                        var languageCssClass = multilineCodeBlockNode.Language.IsNotBlank()
+                            ? "language-" + multilineCodeBlockNode.Language
+                            : null;
+
+                        buffer.Append(
+                            $"<div class=\"pre pre--multiline {languageCssClass}\">{multilineCodeBlockNode.Code.HtmlEncode()}</div>");
+                    }
+
+                    else if (node is MentionNode mentionNode)
+                    {
+                        if (mentionNode.Type == MentionType.Meta)
+                        {
+                            buffer.Append($"<span class=\"mention\">@{mentionNode.Id.HtmlEncode()}</span>");
+                        }
+
+                        else if (mentionNode.Type == MentionType.User)
+                        {
+                            var user = _log.Mentionables.GetUser(mentionNode.Id);
+                            buffer.Append($"<span class=\"mention\" title=\"{user.FullName}\">@{user.Name.HtmlEncode()}</span>");
+                        }
+
+                        else if (mentionNode.Type == MentionType.Channel)
+                        {
+                            var channel = _log.Mentionables.GetChannel(mentionNode.Id);
+                            buffer.Append($"<span class=\"mention\">#{channel.Name.HtmlEncode()}</span>");
+                        }
+
+                        else if (mentionNode.Type == MentionType.Role)
+                        {
+                            var role = _log.Mentionables.GetRole(mentionNode.Id);
+                            buffer.Append($"<span class=\"mention\">@{role.Name.HtmlEncode()}</span>");
+                        }
+                    }
+
+                    else if (node is EmojiNode emojiNode)
+                    {
+                        // Get emoji image URL
+                        var emojiImageUrl = new Emoji(emojiNode.Id, emojiNode.Name, emojiNode.IsAnimated).ImageUrl;
+
+                        // Emoji can be jumboable if it's the only top-level node
+                        var jumboableCssClass = depth == 0 && nodes.Count == 1
+                            ? "emoji--large"
+                            : null;
+
+                        buffer.Append($"<img class=\"emoji {jumboableCssClass}\" title=\"{emojiNode.Name}\" src=\"{emojiImageUrl}\" />");
+                    }
+
+                    else if (node is LinkNode linkNode)
+                    {
+                        var escapedUrl = Uri.EscapeUriString(linkNode.Url);
+                        buffer.Append($"<a href=\"{escapedUrl}\">{linkNode.Title.HtmlEncode()}</a>");
+                    }
+                }
+
+                return buffer.ToString();
+            }
+
+            private string FormatMarkdownHtml(string input) 
+                => FormatMarkdownHtml(MarkdownParser.Parse(input));
+
+            private string FormatMarkdown(string input)
+            {
+                return _format == ExportFormat.HtmlDark || _format == ExportFormat.HtmlLight
+                    ? FormatMarkdownHtml(input)
+                    : FormatMarkdownPlainText(input);
+            }
+
+            public ScriptObject GetScriptObject()
+            {
+                // Create instance
+                var scriptObject = new ScriptObject();
+
+                // Import model
+                scriptObject.SetValue("Model", _log, true);
+
+                // Import functions
+                scriptObject.Import(nameof(GroupMessages), new Func<IEnumerable<Message>, IEnumerable<MessageGroup>>(GroupMessages));
+                scriptObject.Import(nameof(Format), new Func<IFormattable, string, string>(Format));
+                scriptObject.Import(nameof(FormatDate), new Func<DateTime, string>(FormatDate));
+                scriptObject.Import(nameof(FormatMarkdown), new Func<string, string>(FormatMarkdown));
+
+                return scriptObject;
+            }
+        }
+    }
+}

DiscordChatExporter.Core/Services/ExportService.cs

@@ -1,81 +1,130 @@
-using System;
+using System.Collections.Generic;
 using System.IO;
-using System.Net;
-using System.Reflection;
-using System.Threading.Tasks;
-using DiscordChatExporter.Core.Internal;
 using DiscordChatExporter.Core.Models;
+using Scriban;
+using Scriban.Runtime;
 using Tyrrrz.Extensions;
 
 namespace DiscordChatExporter.Core.Services
 {
-    public partial class ExportService : IExportService
+    public partial class ExportService
     {
-        private readonly ISettingsService _settingsService;
+        private readonly SettingsService _settingsService;
 
-        public ExportService(ISettingsService settingsService)
+        public ExportService(SettingsService settingsService)
         {
             _settingsService = settingsService;
         }
 
-        public async Task ExportAsync(ExportFormat format, string filePath, ChannelChatLog log)
+        private void ExportChatLogSingle(ChatLog chatLog, string filePath, ExportFormat format)
         {
+            // Create template loader
+            var loader = new TemplateLoader();
+
+            // Get template
+            var templateCode = loader.Load(format);
+            var template = Template.Parse(templateCode);
+
+            // Create template context
+            var context = new TemplateContext
+            {
+                TemplateLoader = loader,
+                MemberRenamer = m => m.Name,
+                MemberFilter = m => true,
+                LoopLimit = int.MaxValue,
+                StrictVariables = true
+            };
+
+            // Create template model
+            var templateModel = new TemplateModel(format, chatLog,
+                _settingsService.DateFormat, _settingsService.MessageGroupLimit);
+
+            context.PushGlobal(templateModel.GetScriptObject());
+
+            // Create directory
+            var dirPath = Path.GetDirectoryName(filePath);
+            if (dirPath.IsNotBlank())
+                Directory.CreateDirectory(dirPath);
+
+            // Render output
             using (var output = File.CreateText(filePath))
             {
-                if (format == ExportFormat.PlainText)
-                {
-                    await ExportAsPlainTextAsync(log, output);
-                }
+                // Configure output
+                context.PushOutput(new TextWriterOutput(output));
 
-                else if (format == ExportFormat.HtmlDark)
-                {
-                    var css = Assembly.GetExecutingAssembly()
-                        .GetManifestResourceString("DiscordChatExporter.Core.Resources.ExportService.DarkTheme.css");
-                    await ExportAsHtmlAsync(log, output, css);
-                }
-
-                else if (format == ExportFormat.HtmlLight)
-                {
-                    var css = Assembly.GetExecutingAssembly()
-                        .GetManifestResourceString("DiscordChatExporter.Core.Resources.ExportService.LightTheme.css");
-                    await ExportAsHtmlAsync(log, output, css);
-                }
-
-                else throw new ArgumentOutOfRangeException(nameof(format));
+                // Render output
+                context.Evaluate(template.Page);
             }
         }
-    }
 
-    public partial class ExportService
-    {
-        private static string Base64Encode(string str)
+        private void ExportChatLogPartitioned(IReadOnlyList<ChatLog> partitions, string filePath, ExportFormat format)
         {
-            return str.GetBytes().ToBase64();
-        }
+            // Split file path into components
+            var dirPath = Path.GetDirectoryName(filePath);
+            var fileNameWithoutExt = Path.GetFileNameWithoutExtension(filePath);
+            var fileExt = Path.GetExtension(filePath);
 
-        private static string Base64Decode(string str)
-        {
-            return str.FromBase64().GetString();
-        }
-
-        private static string HtmlEncode(string str)
-        {
-            return WebUtility.HtmlEncode(str);
-        }
-
-        private static string FormatFileSize(long fileSize)
-        {
-            string[] units = {"B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"};
-            double size = fileSize;
-            var unit = 0;
-
-            while (size >= 1024)
+            // Export each partition separately
+            var partitionNumber = 1;
+            foreach (var partition in partitions)
             {
-                size /= 1024;
-                ++unit;
+                // Compose new file name
+                var partitionFilePath = $"{fileNameWithoutExt} [{partitionNumber} of {partitions.Count}]{fileExt}";
+
+                // Compose full file path
+                if (dirPath.IsNotBlank())
+                    partitionFilePath = Path.Combine(dirPath, partitionFilePath);
+
+                // Export
+                ExportChatLogSingle(partition, partitionFilePath, format);
+
+                // Increment partition number
+                partitionNumber++;
+            }
+        }
+
+        private IReadOnlyList<ChatLog> SplitIntoPartitions(ChatLog chatLog, int partitionLimit)
+        {
+            var result = new List<ChatLog>();
+
+            // Loop through all messages with an increment of partition limit
+            for (var i = 0; i < chatLog.Messages.Count; i += partitionLimit)
+            {
+                // Calculate how many messages left in total
+                var remainingMessageCount = chatLog.Messages.Count - i;
+
+                // Decide how many messages are going into this partition
+                // Each partition will have the same number of messages except the last one that might have fewer (all remaining messages)
+                var partitionMessageCount = partitionLimit.ClampMax(remainingMessageCount);
+
+                // Get messages that belong to this partition
+                var partitionMessages = new List<Message>();
+                for (var j = i; j < i + partitionMessageCount; j++)
+                    partitionMessages.Add(chatLog.Messages[j]);
+
+                // Create a partition and add to list
+                var partition = new ChatLog(chatLog.Guild, chatLog.Channel, chatLog.From, chatLog.To, partitionMessages,
+                    chatLog.Mentionables);
+                result.Add(partition);
             }
 
-            return $"{size:0.#} {units[unit]}";
+            return result;
+        }
+
+        public void ExportChatLog(ChatLog chatLog, string filePath, ExportFormat format,
+            int? partitionLimit = null)
+        {
+            // If partitioning is disabled or there are fewer messages in chat log than the limit - process it without partitioning
+            if (partitionLimit == null || partitionLimit <= 0 || chatLog.Messages.Count <= partitionLimit)
+            {
+                ExportChatLogSingle(chatLog, filePath, format);
+            }
+            // Otherwise split into partitions and export separately
+            else
+            {
+                var partitions = SplitIntoPartitions(chatLog, partitionLimit.Value);
+                ExportChatLogPartitioned(partitions, filePath, format);
+            }
         }
     }
 }

DiscordChatExporter.Core/Services/IDataService.cs

@@ -1,23 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using DiscordChatExporter.Core.Models;
-
-namespace DiscordChatExporter.Core.Services
-{
-    public interface IDataService
-    {
-        Task<Guild> GetGuildAsync(string token, string guildId);
-
-        Task<Channel> GetChannelAsync(string token, string channelId);
-
-        Task<IReadOnlyList<Channel>> GetGuildChannelsAsync(string token, string guildId);
-
-        Task<IReadOnlyList<Guild>> GetUserGuildsAsync(string token);
-
-        Task<IReadOnlyList<Channel>> GetDirectMessageChannelsAsync(string token);
-
-        Task<IReadOnlyList<Message>> GetChannelMessagesAsync(string token, string channelId,
-            DateTime? from, DateTime? to);
-    }
-}

DiscordChatExporter.Core/Services/IExportService.cs

@@ -1,10 +0,0 @@
-using System.Threading.Tasks;
-using DiscordChatExporter.Core.Models;
-
-namespace DiscordChatExporter.Core.Services
-{
-    public interface IExportService
-    {
-        Task ExportAsync(ExportFormat format, string filePath, ChannelChatLog log);
-    }
-}

DiscordChatExporter.Core/Services/IMessageGroupService.cs

@@ -1,10 +0,0 @@
-using System.Collections.Generic;
-using DiscordChatExporter.Core.Models;
-
-namespace DiscordChatExporter.Core.Services
-{
-    public interface IMessageGroupService
-    {
-        IReadOnlyList<MessageGroup> GroupMessages(IReadOnlyList<Message> messages);
-    }
-}

DiscordChatExporter.Core/Services/ISettingsService.cs

@@ -1,18 +0,0 @@
-using DiscordChatExporter.Core.Models;
-
-namespace DiscordChatExporter.Core.Services
-{
-    public interface ISettingsService
-    {
-        bool IsAutoUpdateEnabled { get; set; }
-
-        string DateFormat { get; set; }
-        int MessageGroupLimit { get; set; }
-
-        string LastToken { get; set; }
-        ExportFormat LastExportFormat { get; set; }
-
-        void Load();
-        void Save();
-    }
-}

DiscordChatExporter.Core/Services/IUpdateService.cs

@@ -1,14 +0,0 @@
-using System;
-using System.Threading.Tasks;
-
-namespace DiscordChatExporter.Core.Services
-{
-    public interface IUpdateService
-    {
-        bool NeedRestart { get; set; }
-
-        Task<Version> CheckPrepareUpdateAsync();
-
-        void FinalizeUpdate();
-    }
-}

DiscordChatExporter.Core/Services/MessageGroupService.cs

@@ -1,59 +0,0 @@
-using System.Collections.Generic;
-using System.Linq;
-using DiscordChatExporter.Core.Models;
-
-namespace DiscordChatExporter.Core.Services
-{
-    public class MessageGroupService : IMessageGroupService
-    {
-        private readonly ISettingsService _settingsService;
-
-        public MessageGroupService(ISettingsService settingsService)
-        {
-            _settingsService = settingsService;
-        }
-
-        public IReadOnlyList<MessageGroup> GroupMessages(IReadOnlyList<Message> messages)
-        {
-            var result = new List<MessageGroup>();
-
-            // Group adjacent messages by timestamp and author
-            var groupBuffer = new List<Message>();
-            foreach (var message in messages)
-            {
-                var groupFirst = groupBuffer.FirstOrDefault();
-
-                // Group break condition
-                var breakCondition =
-                    groupFirst != null &&
-                    (
-                        message.Author.Id != groupFirst.Author.Id ||
-                        (message.TimeStamp - groupFirst.TimeStamp).TotalHours > 1 ||
-                        message.TimeStamp.Hour != groupFirst.TimeStamp.Hour ||
-                        groupBuffer.Count >= _settingsService.MessageGroupLimit
-                    );
-
-                // If condition is true - flush buffer
-                if (breakCondition)
-                {
-                    var group = new MessageGroup(groupFirst.Author, groupFirst.TimeStamp, groupBuffer.ToArray());
-                    result.Add(group);
-                    groupBuffer.Clear();
-                }
-
-                // Add message to buffer
-                groupBuffer.Add(message);
-            }
-
-            // Add what's remaining in buffer
-            if (groupBuffer.Any())
-            {
-                var groupFirst = groupBuffer.First();
-                var group = new MessageGroup(groupFirst.Author, groupFirst.TimeStamp, groupBuffer.ToArray());
-                result.Add(group);
-            }
-
-            return result;
-        }
-    }
-}

DiscordChatExporter.Core/Services/SettingsService.cs

@@ -3,15 +3,16 @@ using Tyrrrz.Settings;
 
 namespace DiscordChatExporter.Core.Services
 {
-    public class SettingsService : SettingsManager, ISettingsService
+    public class SettingsService : SettingsManager
     {
         public bool IsAutoUpdateEnabled { get; set; } = true;
 
         public string DateFormat { get; set; } = "dd-MMM-yy hh:mm tt";
         public int MessageGroupLimit { get; set; } = 20;
 
-        public string LastToken { get; set; }
+        public AuthToken LastToken { get; set; }
         public ExportFormat LastExportFormat { get; set; } = ExportFormat.HtmlDark;
+        public int? LastPartitionLimit { get; set; }
 
         public SettingsService()
         {

DiscordChatExporter.Core/Services/UpdateService.cs

@@ -5,23 +5,20 @@ using Onova.Services;
 
 namespace DiscordChatExporter.Core.Services
 {
-    public class UpdateService : IUpdateService
+    public class UpdateService
     {
-        private readonly ISettingsService _settingsService;
-        private readonly IUpdateManager _manager;
+        private readonly SettingsService _settingsService;
+
+        private readonly IUpdateManager _updateManager = new UpdateManager(
+            new GithubPackageResolver("Tyrrrz", "DiscordChatExporter", "DiscordChatExporter.zip"),
+            new ZipPackageExtractor());
 
         private Version _updateVersion;
-        private bool _updateFinalized;
+        private bool _updaterLaunched;
 
-        public bool NeedRestart { get; set; }
-
-        public UpdateService(ISettingsService settingsService)
+        public UpdateService(SettingsService settingsService)
         {
             _settingsService = settingsService;
-
-            _manager = new UpdateManager(
-                new GithubPackageResolver("Tyrrrz", "DiscordChatExporter", "DiscordChatExporter.zip"),
-                new ZipPackageExtractor());
         }
 
         public async Task<Version> CheckPrepareUpdateAsync()
@@ -31,33 +28,33 @@ namespace DiscordChatExporter.Core.Services
                 return null;
 
             // Cleanup leftover files
-            _manager.Cleanup();
+            _updateManager.Cleanup();
 
             // Check for updates
-            var check = await _manager.CheckForUpdatesAsync();
+            var check = await _updateManager.CheckForUpdatesAsync();
             if (!check.CanUpdate)
                 return null;
 
             // Prepare the update
-            if (!_manager.IsUpdatePrepared(check.LastVersion))
-                await _manager.PrepareUpdateAsync(check.LastVersion);
+            if (!_updateManager.IsUpdatePrepared(check.LastVersion))
+                await _updateManager.PrepareUpdateAsync(check.LastVersion);
 
             return _updateVersion = check.LastVersion;
         }
 
-        public void FinalizeUpdate()
+        public void FinalizeUpdate(bool needRestart)
         {
             // Check if an update is pending
             if (_updateVersion == null)
                 return;
 
-            // Check if the update has already been finalized
-            if (_updateFinalized)
+            // Check if the updater has already been launched
+            if (_updaterLaunched)
                 return;
 
             // Launch the updater
-            _manager.LaunchUpdater(_updateVersion, NeedRestart);
-            _updateFinalized = true;
+            _updateManager.LaunchUpdater(_updateVersion, needRestart);
+            _updaterLaunched = true;
         }
     }
 }

DiscordChatExporter.Gui/App.ammy

@@ -1,69 +0,0 @@
-Application "DiscordChatExporter.Gui.App" {
-  StartupUri: "Views/MainWindow.g.xaml"
-  Startup: App_Startup
-  Exit: App_Exit
-
-  Resources: ResourceDictionary {
-    // Material Design
-    #MergeDictionary("pack://application:,,,/MaterialDesignThemes.Wpf;component/Themes/MaterialDesignTheme.Light.xaml")
-    #MergeDictionary("pack://application:,,,/MaterialDesignThemes.Wpf;component/Themes/MaterialDesignTheme.Defaults.xaml")
-
-    // Colors
-    Color Key="PrimaryColor" { "#343838" }
-    Color Key="PrimaryLightColor" { "#5E6262" }
-    Color Key="PrimaryDarkColor" { "#0D1212" }
-    Color Key="AccentColor" { "#F9A825" }
-    Color Key="TextColor" { "#000000" }
-    Color Key="InverseTextColor" { "#FFFFFF" }
-
-    // Brushes
-    SolidColorBrush Key="PrimaryHueLightBrush" { Color: resource dyn "PrimaryLightColor" }
-    SolidColorBrush Key="PrimaryHueLightForegroundBrush" { Color: resource dyn "InverseTextColor" }
-    SolidColorBrush Key="PrimaryHueMidBrush" { Color: resource dyn "PrimaryColor" }
-    SolidColorBrush Key="PrimaryHueMidForegroundBrush" { Color: resource dyn "InverseTextColor" }
-    SolidColorBrush Key="PrimaryHueDarkBrush" { Color: resource dyn "PrimaryDarkColor" }
-    SolidColorBrush Key="PrimaryHueDarkForegroundBrush" { Color: resource dyn "InverseTextColor" }
-    SolidColorBrush Key="SecondaryAccentBrush" { Color: resource dyn "AccentColor" }
-    SolidColorBrush Key="SecondaryAccentForegroundBrush" { Color: resource dyn "TextColor" }
-    SolidColorBrush Key="PrimaryTextBrush" { Color: resource dyn "TextColor", Opacity: 0.87 }
-    SolidColorBrush Key="SecondaryTextBrush" { Color: resource dyn "TextColor", Opacity: 0.64 }
-    SolidColorBrush Key="DimTextBrush" { Color: resource dyn "TextColor", Opacity: 0.45 }
-    SolidColorBrush Key="PrimaryInverseTextBrush" { Color: resource dyn "InverseTextColor", Opacity: 1 }
-    SolidColorBrush Key="SecondaryInverseTextBrush" { Color: resource dyn "InverseTextColor", Opacity: 0.7 }
-    SolidColorBrush Key="DimInverseTextBrush" { Color: resource dyn "InverseTextColor", Opacity: 0.52 }
-    SolidColorBrush Key="AccentTextBrush" { Color: resource dyn "AccentColor", Opacity: 1 }
-    SolidColorBrush Key="DividerBrush" { Color: resource dyn "TextColor", Opacity: 0.12 }
-    SolidColorBrush Key="InverseDividerBrush" { Color: resource dyn "InverseTextColor", Opacity: 0.12 }
-
-    // Styles
-    Style {
-      TargetType: "Image"
-      #Setter("RenderOptions.BitmapScalingMode", "HighQuality")
-    }
-
-    Style {
-      TargetType: "ProgressBar"
-      BasedOn: resource "MaterialDesignLinearProgressBar"
-      #Setter("Foreground", resource dyn "SecondaryAccentBrush")
-      #Setter("Height", 2)
-      #Setter("Minimum", 0)
-      #Setter("Maximum", 1)
-      #Setter("BorderThickness", 0)
-    }
-
-    Style {
-      TargetType: "TextBox"
-      BasedOn: resource "MaterialDesignTextBox"
-      #Setter("Foreground", resource dyn "PrimaryTextBrush")
-    }
-
-    Style {
-      TargetType: "ComboBox"
-      BasedOn: resource "MaterialDesignComboBox"
-      #Setter("Foreground", resource dyn "PrimaryTextBrush")
-    }
-
-    // Container
-    Container Key="Container" { }
-  }
-}

DiscordChatExporter.Gui/App.ammy.cs

@@ -1,19 +0,0 @@
-using System.Windows;
-
-namespace DiscordChatExporter.Gui
-{
-    public partial class App
-    {
-        private Container Container => (Container) Resources["Container"];
-
-        private void App_Startup(object sender, StartupEventArgs e)
-        {
-            Container.Init();
-        }
-
-        private void App_Exit(object sender, ExitEventArgs e)
-        {
-            Container.Cleanup();
-        }
-    }
-}

DiscordChatExporter.Gui/App.xaml

@@ -0,0 +1,139 @@
+<Application
+    x:Class="DiscordChatExporter.Gui.App"
+    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    xmlns:local="clr-namespace:DiscordChatExporter.Gui"
+    xmlns:s="https://github.com/canton7/Stylet">
+    <Application.Resources>
+        <s:ApplicationLoader>
+            <!--  Bootstrapper  -->
+            <s:ApplicationLoader.Bootstrapper>
+                <local:Bootstrapper />
+            </s:ApplicationLoader.Bootstrapper>
+
+            <!--  Merged dictionaries  -->
+            <ResourceDictionary.MergedDictionaries>
+                <ResourceDictionary Source="pack://application:,,,/MaterialDesignThemes.Wpf;component/Themes/MaterialDesignTheme.Light.xaml" />
+                <ResourceDictionary Source="pack://application:,,,/MaterialDesignThemes.Wpf;component/Themes/MaterialDesignTheme.Defaults.xaml" />
+            </ResourceDictionary.MergedDictionaries>
+
+            <!--  Colors  -->
+            <Color x:Key="PrimaryColor">#343838</Color>
+            <Color x:Key="PrimaryLightColor">#5E6262</Color>
+            <Color x:Key="PrimaryDarkColor">#0D1212</Color>
+            <Color x:Key="AccentColor">#F9A825</Color>
+            <Color x:Key="AccentDarkColor">#C17900</Color>
+            <Color x:Key="TextColor">#000000</Color>
+            <Color x:Key="InverseTextColor">#FFFFFF</Color>
+
+            <SolidColorBrush x:Key="PrimaryHueLightBrush" Color="{DynamicResource PrimaryLightColor}" />
+            <SolidColorBrush x:Key="PrimaryHueLightForegroundBrush" Color="{DynamicResource InverseTextColor}" />
+            <SolidColorBrush x:Key="PrimaryHueMidBrush" Color="{DynamicResource PrimaryColor}" />
+            <SolidColorBrush x:Key="PrimaryHueMidForegroundBrush" Color="{DynamicResource InverseTextColor}" />
+            <SolidColorBrush x:Key="PrimaryHueDarkBrush" Color="{DynamicResource PrimaryDarkColor}" />
+            <SolidColorBrush x:Key="PrimaryHueDarkForegroundBrush" Color="{DynamicResource InverseTextColor}" />
+            <SolidColorBrush x:Key="SecondaryAccentBrush" Color="{DynamicResource AccentColor}" />
+            <SolidColorBrush x:Key="SecondaryAccentForegroundBrush" Color="{DynamicResource TextColor}" />
+
+            <SolidColorBrush
+                x:Key="PrimaryTextBrush"
+                Opacity="0.87"
+                Color="{DynamicResource TextColor}" />
+            <SolidColorBrush
+                x:Key="SecondaryTextBrush"
+                Opacity="0.64"
+                Color="{DynamicResource TextColor}" />
+            <SolidColorBrush
+                x:Key="DimTextBrush"
+                Opacity="0.45"
+                Color="{DynamicResource TextColor}" />
+            <SolidColorBrush
+                x:Key="PrimaryInverseTextBrush"
+                Opacity="1"
+                Color="{DynamicResource InverseTextColor}" />
+            <SolidColorBrush
+                x:Key="SecondaryInverseTextBrush"
+                Opacity="0.7"
+                Color="{DynamicResource InverseTextColor}" />
+            <SolidColorBrush
+                x:Key="DimInverseTextBrush"
+                Opacity="0.52"
+                Color="{DynamicResource InverseTextColor}" />
+            <SolidColorBrush
+                x:Key="AccentTextBrush"
+                Opacity="1"
+                Color="{DynamicResource AccentColor}" />
+            <SolidColorBrush
+                x:Key="AccentDarkTextBrush"
+                Opacity="1"
+                Color="{DynamicResource AccentDarkColor}" />
+            <SolidColorBrush
+                x:Key="DividerBrush"
+                Opacity="0.12"
+                Color="{DynamicResource TextColor}" />
+            <SolidColorBrush
+                x:Key="InverseDividerBrush"
+                Opacity="0.12"
+                Color="{DynamicResource InverseTextColor}" />
+
+            <!--  Styles  -->
+            <Style x:Key="MaterialDesignRoot" TargetType="{x:Type Control}">
+                <Setter Property="FontFamily" Value="{DynamicResource MaterialDesignFont}" />
+                <Setter Property="RenderOptions.BitmapScalingMode" Value="HighQuality" />
+                <Setter Property="SnapsToDevicePixels" Value="True" />
+                <Setter Property="TextElement.FontSize" Value="13" />
+                <Setter Property="TextElement.FontWeight" Value="Regular" />
+                <Setter Property="TextElement.Foreground" Value="{DynamicResource SecondaryTextBrush}" />
+                <Setter Property="TextOptions.TextFormattingMode" Value="Ideal" />
+                <Setter Property="TextOptions.TextRenderingMode" Value="Auto" />
+                <Setter Property="UseLayoutRounding" Value="True" />
+            </Style>
+
+            <Style BasedOn="{StaticResource MaterialDesignLinearProgressBar}" TargetType="{x:Type ProgressBar}">
+                <Setter Property="BorderThickness" Value="0" />
+                <Setter Property="Foreground" Value="{DynamicResource SecondaryAccentBrush}" />
+                <Setter Property="Height" Value="2" />
+                <Setter Property="Maximum" Value="1" />
+                <Setter Property="Minimum" Value="0" />
+            </Style>
+
+            <Style BasedOn="{StaticResource MaterialDesignTextBox}" TargetType="{x:Type TextBox}">
+                <Setter Property="Foreground" Value="{DynamicResource PrimaryTextBrush}" />
+            </Style>
+
+            <Style BasedOn="{StaticResource MaterialDesignComboBox}" TargetType="{x:Type ComboBox}">
+                <Setter Property="Foreground" Value="{DynamicResource PrimaryTextBrush}" />
+            </Style>
+
+            <Style BasedOn="{StaticResource MaterialDesignDatePicker}" TargetType="{x:Type DatePicker}">
+                <Setter Property="Foreground" Value="{DynamicResource PrimaryTextBrush}" />
+            </Style>
+
+            <Style
+                x:Key="MaterialDesignFlatDarkButton"
+                BasedOn="{StaticResource MaterialDesignFlatButton}"
+                TargetType="{x:Type Button}">
+                <Style.Resources>
+                    <SolidColorBrush x:Key="MaterialDesignFlatButtonClick" Color="#4C4C4C" />
+                </Style.Resources>
+
+                <Setter Property="Foreground" Value="{DynamicResource PrimaryHueMidForegroundBrush}" />
+            </Style>
+
+            <Style
+                x:Key="MaterialDesignFlatActionToggleButton"
+                BasedOn="{StaticResource MaterialDesignActionToggleButton}"
+                TargetType="{x:Type ToggleButton}">
+                <Setter Property="Background" Value="Transparent" />
+                <Setter Property="Foreground" Value="{DynamicResource PrimaryHueMidBrush}" />
+
+                <Style.Triggers>
+                    <Trigger Property="IsMouseOver" Value="True">
+                        <Setter Property="Background" Value="{DynamicResource MaterialDesignFlatButtonClick}" />
+                        <Setter Property="BorderBrush" Value="{DynamicResource MaterialDesignFlatButtonClick}" />
+                    </Trigger>
+                </Style.Triggers>
+            </Style>
+        </s:ApplicationLoader>
+    </Application.Resources>
+</Application>

DiscordChatExporter.Gui/App.xaml.cs

@@ -0,0 +1,6 @@
+namespace DiscordChatExporter.Gui
+{
+    public partial class App
+    {        
+    }
+}

DiscordChatExporter.Gui/Behaviors/ChannelViewModelMultiSelectionListBoxBehavior.cs

@@ -0,0 +1,8 @@
+using DiscordChatExporter.Gui.ViewModels.Components;
+
+namespace DiscordChatExporter.Gui.Behaviors
+{
+    public class ChannelViewModelMultiSelectionListBoxBehavior : MultiSelectionListBoxBehavior<ChannelViewModel>
+    {
+    }
+}

DiscordChatExporter.Gui/Behaviors/MultiSelectionListBoxBehavior.cs

@@ -0,0 +1,92 @@
+using System.Collections;
+using System.Collections.Specialized;
+using System.Linq;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Interactivity;
+
+namespace DiscordChatExporter.Gui.Behaviors
+{
+    public class MultiSelectionListBoxBehavior<T> : Behavior<ListBox>
+    {
+        public static readonly DependencyProperty SelectedItemsProperty =
+            DependencyProperty.Register(nameof(SelectedItems), typeof(IList),
+                typeof(MultiSelectionListBoxBehavior<T>),
+                new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault,
+                    OnSelectedItemsChanged));
+
+        private static void OnSelectedItemsChanged(DependencyObject sender, DependencyPropertyChangedEventArgs args)
+        {
+            var behavior = (MultiSelectionListBoxBehavior<T>) sender;
+            if (behavior._modelHandled) return;
+
+            if (behavior.AssociatedObject == null)
+                return;
+
+            behavior._modelHandled = true;
+            behavior.SelectItems();
+            behavior._modelHandled = false;
+        }
+
+        private bool _viewHandled;
+        private bool _modelHandled;
+
+        public IList SelectedItems
+        {
+            get => (IList) GetValue(SelectedItemsProperty);
+            set => SetValue(SelectedItemsProperty, value);
+        }
+
+        // Propagate selected items from model to view
+        private void SelectItems()
+        {
+            _viewHandled = true;
+
+            AssociatedObject.SelectedItems.Clear();
+            if (SelectedItems != null)
+            {
+                foreach (var item in SelectedItems)
+                    AssociatedObject.SelectedItems.Add(item);
+            }
+
+            _viewHandled = false;
+        }
+
+        // Propagate selected items from view to model
+        private void OnListBoxSelectionChanged(object sender, SelectionChangedEventArgs args)
+        {
+            if (_viewHandled) return;
+            if (AssociatedObject.Items.SourceCollection == null) return;
+
+            SelectedItems = AssociatedObject.SelectedItems.Cast<T>().ToArray();
+        }
+
+        // Re-select items when the set of items changes
+        private void OnListBoxItemsChanged(object sender, NotifyCollectionChangedEventArgs args)
+        {
+            if (_viewHandled) return;
+            if (AssociatedObject.Items.SourceCollection == null) return;
+            SelectItems();
+        }
+
+        protected override void OnAttached()
+        {
+            base.OnAttached();
+
+            AssociatedObject.SelectionChanged += OnListBoxSelectionChanged;
+            ((INotifyCollectionChanged) AssociatedObject.Items).CollectionChanged += OnListBoxItemsChanged;
+        }
+
+        /// <inheritdoc />
+        protected override void OnDetaching()
+        {
+            base.OnDetaching();
+
+            if (AssociatedObject != null)
+            {
+                AssociatedObject.SelectionChanged -= OnListBoxSelectionChanged;
+                ((INotifyCollectionChanged) AssociatedObject.Items).CollectionChanged -= OnListBoxItemsChanged;
+            }
+        }
+    }
+}

DiscordChatExporter.Gui/Bootstrapper.cs

@@ -0,0 +1,34 @@
+using System.Windows;
+using System.Windows.Threading;
+using DiscordChatExporter.Core.Services;
+using DiscordChatExporter.Gui.ViewModels;
+using DiscordChatExporter.Gui.ViewModels.Framework;
+using Stylet;
+using StyletIoC;
+
+namespace DiscordChatExporter.Gui
+{
+    public class Bootstrapper : Bootstrapper<RootViewModel>
+    {
+        protected override void ConfigureIoC(IStyletIoCBuilder builder)
+        {
+            base.ConfigureIoC(builder);
+
+            // Autobind services in the .Core assembly
+            builder.Autobind(typeof(DataService).Assembly);
+
+            // Bind settings as singleton
+            builder.Bind<SettingsService>().ToSelf().InSingletonScope();
+
+            // Bind view model factory
+            builder.Bind<IViewModelFactory>().ToAbstractFactory();
+        }
+
+        protected override void OnUnhandledException(DispatcherUnhandledExceptionEventArgs e)
+        {
+            base.OnUnhandledException(e);
+
+            MessageBox.Show(e.Exception.ToString(), "Error occured", MessageBoxButton.OK, MessageBoxImage.Error);
+        }
+    }
+}

DiscordChatExporter.Gui/Container.cs

@@ -1,41 +0,0 @@
-using CommonServiceLocator;
-using DiscordChatExporter.Core.Services;
-using DiscordChatExporter.Gui.ViewModels;
-using GalaSoft.MvvmLight.Ioc;
-
-namespace DiscordChatExporter.Gui
-{
-    public class Container
-    {
-        public IExportSetupViewModel ExportSetupViewModel => Resolve<IExportSetupViewModel>();
-        public IMainViewModel MainViewModel => Resolve<IMainViewModel>();
-        public ISettingsViewModel SettingsViewModel => Resolve<ISettingsViewModel>();
-
-        private T Resolve<T>(string key = null)
-        {
-            return ServiceLocator.Current.GetInstance<T>(key);
-        }
-
-        public void Init()
-        {
-            ServiceLocator.SetLocatorProvider(() => SimpleIoc.Default);
-            SimpleIoc.Default.Reset();
-
-            // Services
-            SimpleIoc.Default.Register<IDataService, DataService>();
-            SimpleIoc.Default.Register<IExportService, ExportService>();
-            SimpleIoc.Default.Register<IMessageGroupService, MessageGroupService>();
-            SimpleIoc.Default.Register<ISettingsService, SettingsService>();
-            SimpleIoc.Default.Register<IUpdateService, UpdateService>();
-
-            // View models
-            SimpleIoc.Default.Register<IExportSetupViewModel, ExportSetupViewModel>(true);
-            SimpleIoc.Default.Register<IMainViewModel, MainViewModel>(true);
-            SimpleIoc.Default.Register<ISettingsViewModel, SettingsViewModel>(true);
-        }
-
-        public void Cleanup()
-        {
-        }
-    }
-}

DiscordChatExporter.Gui/Converters/ExportFormatToStringConverter.cs

@@ -0,0 +1,24 @@
+using System;
+using System.Globalization;
+using System.Windows.Data;
+using DiscordChatExporter.Core.Models;
+
+namespace DiscordChatExporter.Gui.Converters
+{
+    [ValueConversion(typeof(ExportFormat), typeof(string))]
+    public class ExportFormatToStringConverter : IValueConverter
+    {
+        public static ExportFormatToStringConverter Instance { get; } = new ExportFormatToStringConverter();
+
+        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
+        {
+            var format = value as ExportFormat?;
+            return format?.GetDisplayName();
+        }
+
+        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}