DiscordEventsTemplateBase.tt

<#@ assembly name="System.Core" #>
<#@ import namespace="System.Linq" #>
<#@ import namespace="System.IO" #>
<#@ import namespace="System.Text" #>
<#@ assembly name="Newtonsoft.Json" #>
<#@ import namespace="Newtonsoft.Json" #>
<#@ import namespace="System.Text.RegularExpressions" #>
<#@ import namespace="System.Collections.ObjectModel" #>
<#@ assembly name="System.Net.Http" #>
<#@ import namespace="System.Net.Http" #>
<#@ import namespace="System.Collections.Generic" #>
<#+
    public static string AutomaticNamespaceLine => $"namespace {AutomaticNamespace};";
    public static string AutomaticNamespace => System.Runtime.Remoting.Messaging.CallContext.LogicalGetData("NamespaceHint")?.ToString() ?? throw new InvalidProgramException("No SolutionDirectoryAvailable!");

    #nullable enable
    private static readonly TimeSpan maxFileAge = TimeSpan.FromHours(6);

    private const string cacheName = "DiscordClientEventsCache.json";
    

    public static string CacheDirectory => @"C:\Users\ruhoffman\source\repos\BetterHosting";
    //public static string CacheDirectory => @"C:\Users\ruhoffman\source\repos\BetterHosting\";
    private static string CacheFilePath => Path.Combine(CacheDirectory, cacheName);

    public static EventNaming FirstEvent => EventsList[0];
    public static EventNaming LastEvent
    {
        get
        {
            var localList = EventsList;
            return localList[localList.Count - 1];
        }
    }
    
    public static IEnumerable<EventNaming> SkipFirst => EventsList.Skip(1);
    public static IEnumerable<EventNaming> MiddleEvents => SkipLast.Skip(1);
    public static IEnumerable<EventNaming> SkipLast
    {
        get
        {
            var localList = EventsList;
            return localList.Take(localList.Count - 1);
        }
    }

    private static List<EventNaming>? eventsList;
    public static List<EventNaming> EventsList
    {
        get
        {
            try
            {
                if(eventsList != null) return eventsList;
                string cacheFilePath = CacheFilePath;
                FileInfo file_info = new(cacheFilePath);
                if(file_info.Exists)
                {
                    if(file_info.CreationTime < DateTime.Now &&  (DateTime.Now - file_info.CreationTime) > maxFileAge)
                    {
                        return eventsList = LoadEventsFromFile(cacheFilePath);
                    }
                }

                var newResult = DownloadAndParse();
                SerializeToFile(newResult, cacheFilePath);
                eventsList = newResult;
                return newResult;
            }
            catch(Exception ex)
            {
                throw new InvalidProgramException("Oops!", ex);
            }
        }
    }

    private static List<EventNaming> LoadEventsFromFile(string cacheFilePath)
    {
        try
        {
            string json;
            using (FileStream fs = File.OpenRead(cacheFilePath))
            using (StreamReader reader = new(fs))
            {
                json = reader.ReadToEnd();
            }
            return Newtonsoft.Json.JsonConvert.DeserializeObject<List<EventNaming>>(json)!;
        }
        catch(Exception ex)
        {
            throw new InvalidProgramException("Oops!", ex);
        }
    }
    private static void SerializeToFile(List<EventNaming> events, string cacheFilePath)
    {
        try
        {
            string json = Newtonsoft.Json.JsonConvert.SerializeObject(events, Formatting.Indented)!;
            File.WriteAllText(json, cacheFilePath);
        }
        catch(Exception ex)
        {
            throw new InvalidProgramException("Oops!", ex);
        }
    }
    
    private static readonly Regex regex = new("^ *public event AsyncEventHandler<DiscordClient, (?<EventArgType>.+?)> (?<EventName>.+?)$", RegexOptions.ExplicitCapture | RegexOptions.Multiline);

    private static List<EventNaming> DownloadAndParse()
    {
        const string downloadURL = "https://raw.githubusercontent.com/DSharpPlus/DSharpPlus/master/DSharpPlus/Clients/DiscordClient.Events.cs";
        using HttpClient client = new();
    #if false
        Stream stream = client.GetStreamAsync(downloadURL).GetAwaiter().GetResult();
        IEnumerable<string> lines = StreamToLines(stream);
        IEnumerable<Match> matches = lines.Select(l => regex.Match(l)).Where(m => m.Success);
        return matches.Select(m => new EventNaming(m.Groups["EventName"].Value, m.Groups["EventArgType"].Value)).ToList().AsReadOnly();

        static IEnumerable<string> StreamToLines(Stream input)
        {
            using System.IO.StreamReader reader = new System.IO.StreamReader(input);
            string? line;
            while ((line = reader.ReadLine()) != null)
                yield return line;
        }
    #endif

        string sourceString = client.GetStringAsync(downloadURL).GetAwaiter().GetResult();
        MatchCollection matchResults = regex.Matches(sourceString);

        List<EventNaming> resultList = new();
        foreach (Match m in matchResults)
        {
            if(!m.Success) continue;

            resultList.Add(new EventNaming(m.Groups["EventName"].Value, m.Groups["EventArgType"].Value));
        }
        return resultList;
    }

public partial class EventNaming
{
    public EventNaming(string eventName, string argumentType)
    {
        EventName = eventName;
        ArgumentType = argumentType;
    }
    public readonly string EventName;
    public readonly string ArgumentType;
    public string MethodName => $"On{EventName}";
    public string InterfaceName => $"I{EventName}EventHandler";
    public string WithHandlerSuffix => $"{EventName}Handler";
}
#>