director/iCalHoopJumping.cs

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using Ical.Net;
using Ical.Net.CalendarComponents;
using Ical.Net.Serialization;

namespace director
{
    public class iCalHoopJumping
    {
        private static DateTime searchStart = DateTime.Now; //is it slower to just call datetime.now every time? /shrug
        private static DateTime searchEnd = DateTime.Now.AddDays(21);
        public static readonly ConcurrentDictionary<string, Calendar> Calendars = new ConcurrentDictionary<string, Calendar>();
        public static string LoadCalendar(string calendarString)
        {
            var cal = Calendar.Load(calendarString);
            var key = cal.Properties["X-WR-CALNAME"].Value.ToString();
            Calendars[key] = cal;
            return key;
        }

        //I don't understand why the entire .net ecosystem insists on ignoring ToString(). Is it really that much fun writing ThingSerializerFactory? ...java programmers.
        private static EventSerializer ser = new EventSerializer();
        public static CalendarEvent parseEvent(string calendarLabel, string eventStr)
        {
            //return new CalendarEvent(eventStr); //lol no
            //return CalendarEvent.Parse(eventStr); //lol no

            var cal = Calendar.Load(Program.scratch.Calendars[calendarLabel]);
            foreach (var evt in cal.Events)
            {
                if (ser.SerializeToString(evt) == eventStr)
                {
                    return evt;
                }
                foreach (var occ in evt.GetOccurrences(DateTime.Now - TimeSpan.FromDays(365), DateTime.Now + TimeSpan.FromDays(365)))
                {
                    var newEvent = occ.Source as Ical.Net.CalendarComponents.CalendarEvent;

                    if (ser.SerializeToString(newEvent) == eventStr)
                    {
                        return newEvent;
                    }
                }
            }
            return null;
        }

        internal static string Event_ToString(CalendarEvent asEvent)
        {
            //return asEvent.ToString(); //lol no
            if (asEvent == null) { return null; }
            return ser.SerializeToString(asEvent);
        }
        internal static CalendarEvent Event_FromString(string asString)
        {
            if (string.IsNullOrWhiteSpace(asString)) { return null; }

            var toReturn = Calendar.Load<CalendarEvent>(asString)?.FirstOrDefault();
            return toReturn as CalendarEvent;
        }
        public static IEnumerable<CalendarOccurrence> getOccurrences(string calLabel)
        {
            var usefulList = new List<CalendarOccurrence>();
            foreach (var icalOcc in Calendars[calLabel].GetOccurrences(searchStart, searchEnd))
            {
                var asEvent = icalOcc.Source as Ical.Net.CalendarComponents.CalendarEvent;
                var newCO = new CalendarOccurrence();
                newCO.CalendarSourceName = calLabel;
                newCO._event = asEvent;
                newCO.OccurrenceStart = icalOcc.Period.StartTime.AsSystemLocal;
                newCO.OccurrenceEnd = icalOcc.Period.EndTime.AsSystemLocal;
                usefulList.Add(newCO);
            }
            return usefulList;
        }
        public class CalendarOccurrence
        {
            public string CalendarSourceName { get; set; }
            internal CalendarEvent _event { get; set; }
            public string Event
            {
                get
                {
                    return iCalHoopJumping.Event_ToString(_event);
                }
                set
                {
                    _event = iCalHoopJumping.Event_FromString(value);
                }
            }
            public DateTime OccurrenceStart { get; set; }
            public DateTime OccurrenceEnd { get; set; }
        }
    }
}