/*
 *
 * (c) Copyright Ascensio System Limited 2010-2018
 *
 * This program is freeware. You can redistribute it and/or modify it under the terms of the GNU 
 * General Public License (GPL) version 3 as published by the Free Software Foundation (https://www.gnu.org/copyleft/gpl.html). 
 * In accordance with Section 7(a) of the GNU GPL its Section 15 shall be amended to the effect that 
 * Ascensio System SIA expressly excludes the warranty of non-infringement of any third-party rights.
 *
 * THIS PROGRAM IS DISTRIBUTED WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF MERCHANTABILITY OR
 * FITNESS FOR A PARTICULAR PURPOSE. For more details, see GNU GPL at https://www.gnu.org/copyleft/gpl.html
 *
 * You can contact Ascensio System SIA by email at sales@onlyoffice.com
 *
 * The interactive user interfaces in modified source and object code versions of ONLYOFFICE must display 
 * Appropriate Legal Notices, as required under Section 5 of the GNU GPL version 3.
 *
 * Pursuant to Section 7 § 3(b) of the GNU GPL you must retain the original ONLYOFFICE logo which contains 
 * relevant author attributions when distributing the software. If the display of the logo in its graphic 
 * form is not reasonably feasible for technical reasons, you must include the words "Powered by ONLYOFFICE" 
 * in every copy of the program you distribute. 
 * Pursuant to Section 7 § 3(e) we decline to grant you any rights under trademark law for use of our trademarks.
 *
*/


using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;

namespace ASC.Web.Core.Calendars
{

    internal static class DateTimeExtension
    {
        public static int GetWeekOfYear(this DateTime date, DayOfWeek firstDayOfWeek)
        {
            return System.Threading.Thread.CurrentThread.CurrentCulture.Calendar.GetWeekOfYear(date,
                                System.Globalization.CalendarWeekRule.FirstFourDayWeek, firstDayOfWeek);
        }

        public static int GetWeekOfYearCount(this DateTime date, DayOfWeek firstDayOfWeek)
        {
            return new DateTime(date.Year, 12, 31).GetWeekOfYear(firstDayOfWeek);
        }

        public static int GetDaysInMonth(this DateTime date)
        {
            return System.Threading.Thread.CurrentThread.CurrentCulture.Calendar.GetDaysInMonth(date.Year, date.Month);
        }

        public static int GetDaysInYear(this DateTime date)
        {
            return System.Threading.Thread.CurrentThread.CurrentCulture.Calendar.GetDaysInYear(date.Year);
        }

        public static int GetDayOfWeekInMonth(this DateTime date)
        {
            var count = 0;
            var d = date;
            while (date.Month == d.Month)
            {
                count++;
                d = d.AddDays(-7);
            }
            d = date.AddDays(7);
            while (date.Month == d.Month)
            {
                count++;
                d = d.AddDays(7);
            }
            return count;
        }
    }

    public enum Frequency
    {
        Never = 0,
        Daily = 3,
        Weekly = 4,
        Monthly = 5,
        Yearly = 6,
        Secondly = 7,
        Minutely = 8,
        Hourly = 9
    }

    public class RecurrenceRule : IiCalFormatView, ICloneable
    {
        public static RecurrenceRule Parse(EventRepeatType repeatType)
        {
            return repeatType switch
            {
                EventRepeatType.EveryDay => new RecurrenceRule() { Freq = Frequency.Daily },

                EventRepeatType.EveryMonth => new RecurrenceRule() { Freq = Frequency.Monthly },

                EventRepeatType.EveryWeek => new RecurrenceRule() { Freq = Frequency.Weekly },

                EventRepeatType.EveryYear => new RecurrenceRule() { Freq = Frequency.Yearly },

                EventRepeatType.Never => new RecurrenceRule() { Freq = Frequency.Never },

                _ => new RecurrenceRule() { Freq = Frequency.Never },
            };
        }
        public class WeekDay
        {
            public string Id { get; set; }
            public int? Number { get; set; }
            public DayOfWeek DayOfWeek
            {
                get
                {
                    return ((Id ?? "").ToLower()) switch
                    {
                        "su" => DayOfWeek.Sunday,
                        "mo" => DayOfWeek.Monday,
                        "tu" => DayOfWeek.Tuesday,
                        "we" => DayOfWeek.Wednesday,
                        "th" => DayOfWeek.Thursday,
                        "fr" => DayOfWeek.Friday,
                        "sa" => DayOfWeek.Saturday,
                        _ => DayOfWeek.Monday,
                    };
                }
            }

            private WeekDay() { }

            public List<DateTime> GetDates(DateTime startDate, bool monthly)
            {
                var dates = new List<DateTime>();
                var date = startDate;
                var count = 0;
                while ((monthly && date.Month == startDate.Month) || (!monthly && date.Year == startDate.Year))
                {
                    if (date.DayOfWeek == this.DayOfWeek)
                    {
                        count++;
                        if (!monthly && (!this.Number.HasValue || count == this.Number || this.Number == (count - (date.GetWeekOfYearCount(DayOfWeek.Monday) + 1))))
                            dates.Add(date);

                        else if (monthly && (!this.Number.HasValue || count == this.Number || this.Number == (count - (date.GetDayOfWeekInMonth() + 1))))
                            dates.Add(date);

                        date = date.AddDays(7);
                    }
                    else
                        date = date.AddDays(1);
                }
                return dates;
            }

            public static WeekDay Parse(string iCalStrValue)
            {
                var d = new WeekDay();

                if (iCalStrValue.Length > 2)
                {
                    d.Id = iCalStrValue.Substring(iCalStrValue.Length - 2).ToLower();
                    d.Number = Convert.ToInt32(iCalStrValue[0..^2]);
                }
                else
                {
                    d.Id = iCalStrValue;
                    d.Number = null;
                }
                return d;
            }

            public override string ToString()
            {
                return (Number.HasValue ? Number.ToString() : "") + this.Id;
            }
        }

        public Frequency Freq { get; set; }
        public DateTime Until { get; set; }
        public int Count { get; set; }
        public int Interval { get; set; }

        public int[] BySecond { get; set; } //0 - 59
        public int[] ByMinute { get; set; } //0 - 59
        public int[] ByHour { get; set; } //0 - 23

        public WeekDay[] ByDay { get; set; } //
        public int[] ByMonthDay { get; set; } //1 -31 +-
        public int[] ByYearDay { get; set; } //1 -366 +-
        public int[] ByWeekNo { get; set; } // 1 - 53 +- 
        public int[] ByMonth { get; set; } // 1 - 12     

        public int[] BySetPos { get; set; } //- 366 +-
        public WeekDay WKST { get; set; }

        public struct ExDate
        {
            public DateTime Date { get; set; }
            public bool isDateTime { get; set; }
        }

        public List<ExDate> ExDates { get; set; }

        public RecurrenceRule()
        {
            this.Freq = Frequency.Never;
            this.Until = DateTime.MinValue;
            this.Count = -1;
            this.Interval = 1;
            this.WKST = WeekDay.Parse("mo");
            this.ExDates = new List<ExDate>();
        }

        private bool CheckDate(DateTime d)
        {
            if (ByMonth != null && !ByMonth.Contains(d.Month))
                return false;

            //only for YEARLY
            if (ByWeekNo != null)
            {
                var weekOfYear = d.GetWeekOfYear(this.WKST.DayOfWeek);
                if (!ByWeekNo.Contains(weekOfYear) && !ByWeekNo.Contains(weekOfYear - (d.GetWeekOfYearCount(this.WKST.DayOfWeek) + 1)))
                    return false;
            }

            if (ByYearDay != null && !ByYearDay.Contains(d.DayOfYear) && !ByYearDay.Contains(d.DayOfYear - (d.GetDaysInYear() + 1)))
                return false;

            if (ByMonthDay != null && !ByMonthDay.Contains(d.Day) && !ByMonthDay.Contains(d.Day - d.GetDaysInMonth() + 1))
                return false;

            if (ByDay != null && !ByDay.ToList().Exists(item => item.DayOfWeek == d.DayOfWeek))
                return false;

            return true;
        }

        public List<DateTime> GetDates(DateTime utcStartDate, DateTime fromDate, int maxCount)
        {
            return GetDates(utcStartDate, fromDate, DateTime.MaxValue, maxCount);
        }
        public List<DateTime> GetDates(DateTime utcStartDate, DateTime fromDate, DateTime toDate)
        {
            return GetDates(utcStartDate, fromDate, toDate, int.MaxValue);
        }
        public List<DateTime> GetDates(DateTime utcStartDate, DateTime fromDate, DateTime toDate, int maxCount, bool removeExDates = true)
        {
            var dates = new List<DateTime>();
            var endDate = (this.Until == DateTime.MinValue ? toDate : (toDate > this.Until ? this.Until : toDate));

            //push start date           
            dates.Add(utcStartDate);

            DateTime d;
            switch (Freq)
            {
                case Frequency.Secondly:

                    #region Secondly
                    d = utcStartDate.AddSeconds(this.Interval);
                    while (d <= endDate && CheckCount(dates, fromDate, maxCount))
                    {
                        if (CheckDate(d) && (ByHour == null || (ByHour != null && ByHour.Contains(d.Hour)))
                            && (ByMinute == null || (ByMinute != null && ByMinute.Contains(d.Minute)))
                            && (BySecond == null || (BySecond != null && BySecond.Contains(d.Second))))
                        {

                            if (d >= utcStartDate && d <= endDate && !dates.Contains(d))
                                dates.Add(d);
                        }

                        d = d.AddMinutes(this.Interval);
                    }
                    break;
                #endregion

                case Frequency.Minutely:

                    #region Minutely
                    d = utcStartDate.AddMinutes(this.Interval);
                    while (d <= endDate && CheckCount(dates, fromDate, maxCount))
                    {
                        if (CheckDate(d) && (ByHour == null || (ByHour != null && ByHour.Contains(d.Hour)))
                            && (ByMinute == null || (ByMinute != null && ByMinute.Contains(d.Minute))))
                        {
                            //seconds
                            var seconds = new List<int>();
                            if (BySecond != null)
                                seconds.AddRange(BySecond);
                            else
                                seconds.Add(d.Second);

                            foreach (var s in seconds)
                            {
                                var newDate = new DateTime(d.Year, d.Month, d.Day, d.Hour, d.Minute, s);
                                if (newDate >= utcStartDate && newDate <= endDate && !dates.Contains(newDate))
                                    dates.Add(newDate);
                            }

                        }

                        d = d.AddMinutes(this.Interval);
                    }
                    break;
                #endregion

                case Frequency.Hourly:

                    #region Hourly
                    d = utcStartDate.AddHours(this.Interval);
                    while (d <= endDate && CheckCount(dates, fromDate, maxCount))
                    {
                        if (CheckDate(d) && (ByHour == null || (ByHour != null && ByHour.Contains(d.Hour))))
                        {
                            //minutes
                            var minutes = new List<int>();
                            if (ByMinute != null)
                                minutes.AddRange(ByMinute);
                            else
                                minutes.Add(d.Minute);

                            //seconds
                            var seconds = new List<int>();
                            if (BySecond != null)
                                seconds.AddRange(BySecond);
                            else
                                seconds.Add(d.Second);

                            foreach (var m in minutes)
                            {
                                foreach (var s in seconds)
                                {
                                    var newDate = new DateTime(d.Year, d.Month, d.Day, d.Hour, m, s);
                                    if (newDate >= utcStartDate && newDate <= endDate && !dates.Contains(newDate))
                                        dates.Add(newDate);
                                }
                            }
                        }

                        d = d.AddHours(this.Interval);
                    }
                    break;
                #endregion

                case Frequency.Daily:

                    #region Daily
                    d = utcStartDate.AddDays(this.Interval);
                    while (d <= endDate && CheckCount(dates, fromDate, maxCount))
                    {
                        if (CheckDate(d))
                            GetDatesWithTime(ref dates, utcStartDate, endDate, d, new List<DateTime>() { d });

                        d = d.AddDays(this.Interval);
                    }
                    break;
                #endregion

                case Frequency.Weekly:

                    #region Weekly

                    d = utcStartDate;
                    while (d <= endDate && CheckCount(dates, fromDate, maxCount))
                    {
                        var dateRange = new List<DateTime>();
                        for (var i = 0; i < 7; i++)
                            dateRange.Add(d.AddDays(i));

                        if (ByMonth != null)
                            dateRange.RemoveAll(date => !ByMonth.Contains(date.Month));

                        if (ByYearDay != null)
                            dateRange.RemoveAll(date => (!ByYearDay.Contains(date.DayOfYear) && !ByYearDay.Contains(date.DayOfYear - (date.GetDaysInYear() + 1))));

                        if (ByMonthDay != null)
                            dateRange.RemoveAll(date => (!ByMonthDay.Contains(date.Day) && !ByMonthDay.Contains(date.Day - (date.GetDaysInMonth() + 1))));

                        if (ByDay != null)
                            dateRange.RemoveAll(date => !ByDay.ToList().Exists(wd => wd.DayOfWeek == date.DayOfWeek));

                        if (ByDay == null && ByMonthDay == null && ByYearDay == null)
                            dateRange.RemoveAll(date => date.Day != d.Day);

                        GetDatesWithTime(ref dates, utcStartDate, endDate, d, dateRange);

                        d = d.AddDays(7 * this.Interval);

                    }
                    break;
                #endregion

                case Frequency.Monthly:

                    #region Monthly

                    d = utcStartDate;
                    while (d <= endDate && CheckCount(dates, fromDate, maxCount))
                    {
                        var dateRange = new List<DateTime>();
                        if (ByMonth != null && !ByMonth.Contains(d.Month))
                        {
                            d = d.AddMonths(this.Interval);
                            continue;
                        }

                        var day = new DateTime(d.Year, d.Month, 1);
                        while (day.Month == d.Month)
                        {
                            dateRange.Add(day);
                            day = day.AddDays(1);
                        }

                        if (ByYearDay != null)
                            dateRange.RemoveAll(date => (!ByYearDay.Contains(date.DayOfYear) && !ByYearDay.Contains(date.DayOfYear - (date.GetDaysInYear() + 1))));

                        if (ByMonthDay != null)
                            dateRange.RemoveAll(date => (!ByMonthDay.Contains(date.Day) && !ByMonthDay.Contains(date.Day - (date.GetDaysInMonth() + 1))));

                        //only for MONTHLY or YEARLY
                        if (ByDay != null)
                        {
                            var listDates = new List<DateTime>();
                            foreach (var date in ByDay)
                                listDates.AddRange(date.GetDates(new DateTime(d.Year, d.Month, 1), true));

                            dateRange.RemoveAll(date => !listDates.Contains(date));
                        }

                        if (ByDay == null && ByMonthDay == null && ByYearDay == null)
                            dateRange.RemoveAll(date => date.Day != d.Day);

                        GetDatesWithTime(ref dates, utcStartDate, endDate, d, dateRange);

                        d = d.AddMonths(this.Interval);

                    }
                    break;
                #endregion

                case Frequency.Yearly:

                    #region Yearly

                    d = utcStartDate;

                    if (d.Month == 2 && d.Day == 29)
                    {
                        if (Interval == 1 && ByMonth == null && ByWeekNo == null && ByYearDay == null && ByMonthDay == null && ByDay == null)
                        {
                            Interval = 4;
                        }
                    }

                    while (d.Year <= endDate.Year && CheckCount(dates, fromDate, maxCount))
                    {
                        var dateRange = new List<DateTime>();
                        var isFirst = true;

                        if (ByMonth != null)
                        {
                            foreach (var m in ByMonth)
                            {
                                var date = new DateTime(d.Year, m, 1);
                                while (date.Month == m)
                                {
                                    dateRange.Add(date);
                                    date = date.AddDays(1);
                                }
                            }
                            isFirst = false;
                        }

                        //only for YEARLY
                        if (ByWeekNo != null)
                        {
                            if (isFirst)
                            {

                                var date = new DateTime(d.Year, 1, 1);
                                while (date.Year == d.Year)
                                {
                                    var weekOfYear = date.GetWeekOfYear(this.WKST.DayOfWeek);
                                    if (ByWeekNo.Contains(weekOfYear) || ByWeekNo.Contains(weekOfYear - (date.GetWeekOfYearCount(this.WKST.DayOfWeek) + 1)))
                                        dateRange.Add(date);

                                    date = date.AddDays(1);
                                }
                            }
                            else
                            {
                                dateRange.RemoveAll(date =>
                                {
                                    var weekOfYear = date.GetWeekOfYear(this.WKST.DayOfWeek);
                                    return ((!ByWeekNo.Contains(weekOfYear) && !ByWeekNo.Contains(weekOfYear - (date.GetWeekOfYearCount(this.WKST.DayOfWeek) + 1))));
                                });
                            }
                            isFirst = false;
                        }

                        if (ByYearDay != null)
                        {
                            if (isFirst)
                            {
                                foreach (var yearDay in ByYearDay)
                                    dateRange.Add(new DateTime(d.Year, 1, 1).AddDays((yearDay > 0 ? yearDay : (d.GetDaysInYear() + yearDay)) - 1));
                            }
                            else
                                dateRange.RemoveAll(date => (!ByYearDay.Contains(date.DayOfYear) && !ByYearDay.Contains(date.DayOfYear - (date.GetDaysInYear() + 1))));

                            isFirst = false;
                        }


                        if (ByMonthDay != null)
                        {
                            if (isFirst)
                            {
                                for (var m = 1; m <= 12; m++)
                                {
                                    foreach (var day in ByMonthDay)
                                    {
                                        var dd = new DateTime(d.Year, m, 1);
                                        dateRange.Add(dd.AddDays((day > 0 ? day : (dd.GetDaysInMonth() + day)) - 1));
                                    }
                                }
                            }
                            else
                                dateRange.RemoveAll(date => (!ByMonthDay.Contains(date.Day) && !ByMonthDay.Contains(date.Day - (date.GetDaysInMonth() + 1))));

                            isFirst = false;
                        }

                        //only for MONTHLY or YEARLY
                        if (ByDay != null)
                        {
                            var listDates = new List<DateTime>();
                            foreach (var day in ByDay)
                                listDates.AddRange(day.GetDates(new DateTime(d.Year, 1, 1), false));

                            listDates.Sort();

                            if (isFirst)
                                dateRange.AddRange(listDates);
                            else
                                dateRange.RemoveAll(date => !listDates.Contains(date));

                            isFirst = false;
                        }

                        if (ByDay == null && ByMonthDay == null && ByYearDay == null && ByWeekNo == null)
                            dateRange.RemoveAll(date => date.Day != d.Day);

                        //add yearly same date
                        if (isFirst)
                            dateRange.Add(d);

                        GetDatesWithTime(ref dates, utcStartDate, endDate, d, dateRange);

                        d = d.AddYears(this.Interval);

                    }
                    break;
                    #endregion
            }

            if (Count >= 0)
            {
                var count = this.Count;
                dates = dates.FindAll(date => (--count) >= 0);
            }

            if (removeExDates && ExDates != null)
            {
                foreach (var exDate in ExDates)
                    dates.RemoveAll(dt => (exDate.isDateTime && dt == exDate.Date) || (!exDate.isDateTime && dt.Date == exDate.Date));
            }

            dates.RemoveAll(dt => dt < fromDate || dt > endDate);

            return dates;
        }

        private bool CheckCount(List<DateTime> dates, DateTime fromDate, int maxCount)
        {
            if (Count >= 0)
                return dates.Count <= this.Count;

            if (maxCount != int.MaxValue)
            {
                if (ExDates != null && ExDates.Count > 0)
                {
                    return dates.FindAll(dt => dt >= fromDate && !ExDates.Exists(exDate => (exDate.isDateTime && dt == exDate.Date) || (!exDate.isDateTime && dt.Date == exDate.Date)))
                        .Count < maxCount;
                }
                else
                    return dates.FindAll(d => d >= fromDate).Count < maxCount;

            }

            return true;
        }

        private void GetDatesWithTime(ref List<DateTime> dates, DateTime startDate, DateTime endDate, DateTime d, List<DateTime> dateRange)
        {
            //hours
            var hours = new List<int>();
            if (ByHour != null)
                hours.AddRange(ByHour);
            else
                hours.Add(d.Hour);

            //minutes
            var minutes = new List<int>();
            if (ByMinute != null)
                minutes.AddRange(ByMinute);
            else
                minutes.Add(d.Minute);

            //seconds
            var seconds = new List<int>();
            if (BySecond != null)
                seconds.AddRange(BySecond);
            else
                seconds.Add(d.Second);

            if (BySetPos != null && (ByDay != null || ByMonth != null || ByMonthDay != null || ByWeekNo != null || ByYearDay != null))
            {
                var newDateRange = new List<DateTime>();
                foreach (var pos in BySetPos)
                {
                    if (pos >= 1 && pos <= dateRange.Count)
                        newDateRange.Add(dateRange[pos - 1]);
                    else if (pos < 0 && (pos * (-1)) <= dateRange.Count)
                        newDateRange.Add(dateRange[dateRange.Count + pos]);
                }
                newDateRange.Sort();
                dateRange = newDateRange;
            }


            foreach (var date in dateRange)
            {
                foreach (var h in hours)
                {
                    foreach (var m in minutes)
                    {
                        foreach (var s in seconds)
                        {
                            var newDate = new DateTime(date.Year, date.Month, date.Day, h, m, s);
                            if (newDate >= startDate && newDate <= endDate && !dates.Contains(newDate))
                                dates.Add(newDate);
                        }
                    }
                }
            }

        }

        public override string ToString()
        {
            return ToString(false);
        }
        public string ToString(bool iCal)
        {
            var sb = new StringBuilder();
            switch (Freq)
            {
                case Frequency.Secondly:
                    sb.Append("secondly");
                    break;

                case Frequency.Minutely:
                    sb.Append("minutely");
                    break;

                case Frequency.Hourly:
                    sb.Append("hourly");
                    break;

                case Frequency.Daily:
                    sb.Append("daily");
                    break;

                case Frequency.Weekly:
                    sb.Append("weekly");
                    break;

                case Frequency.Monthly:
                    sb.Append("monthly");
                    break;

                case Frequency.Yearly:
                    sb.Append("yearly");
                    break;
            }

            if (Until != DateTime.MinValue)
            {
                sb.AppendFormat(";until={0}", Until.ToString("yyyyMMdd'T'HHmmss'Z'"));
            }
            else if (Count >= 0)
            {
                sb.AppendFormat(";count={0}", Count);
            }

            if (Interval > 1)
            {
                sb.AppendFormat(";interval={0}", Interval);
            }

            if (BySecond != null && BySecond.Length > 0)
            {
                sb.Append(";bysecond=");
                foreach (var s in BySecond)
                    sb.AppendFormat("{0},", s);

                sb.Remove(sb.Length - 1, 1);
            }

            if (ByMinute != null && ByMinute.Length > 0)
            {
                sb.Append(";byminute=");
                foreach (var m in ByMinute)
                    sb.AppendFormat("{0},", m);

                sb.Remove(sb.Length - 1, 1);
            }

            if (ByHour != null && ByHour.Length > 0)
            {
                sb.Append(";byhour=");
                foreach (var h in ByHour)
                    sb.AppendFormat("{0},", h);

                sb.Remove(sb.Length - 1, 1);
            }

            if (ByDay != null && ByDay.Length > 0)
            {
                sb.Append(";byday=");
                foreach (var d in ByDay)
                    sb.AppendFormat("{0},", d);

                sb.Remove(sb.Length - 1, 1);
            }


            if (ByMonthDay != null && ByMonthDay.Length > 0)
            {
                sb.Append(";bymonthday=");
                foreach (var d in ByMonthDay)
                    sb.AppendFormat("{0},", d);

                sb.Remove(sb.Length - 1, 1);
            }

            if (ByYearDay != null && ByYearDay.Length > 0)
            {
                sb.Append(";byyearday=");
                foreach (var d in ByYearDay)
                    sb.AppendFormat("{0},", d);

                sb.Remove(sb.Length - 1, 1);
            }

            if (ByWeekNo != null && ByWeekNo.Length > 0)
            {
                sb.Append(";byweekno=");
                foreach (var w in ByWeekNo)
                    sb.AppendFormat("{0},", w);

                sb.Remove(sb.Length - 1, 1);
            }

            if (ByMonth != null && ByMonth.Length > 0)
            {
                sb.Append(";bymonth=");
                foreach (var m in ByMonth)
                    sb.AppendFormat("{0},", m);

                sb.Remove(sb.Length - 1, 1);
            }

            if (BySetPos != null && BySetPos.Length > 0)
            {
                sb.Append(";bysetpos=");
                foreach (var p in BySetPos)
                    sb.AppendFormat("{0},", p);

                sb.Remove(sb.Length - 1, 1);
            }

            if (WKST.DayOfWeek != DayOfWeek.Monday)
                sb.AppendFormat(";wkst={0}", WKST.Id);

            if (!iCal && ExDates != null && ExDates.Count > 0)
            {
                sb.AppendFormat(";exdates=");
                foreach (var d in this.ExDates)
                {
                    if (d.isDateTime)
                        sb.Append(d.Date.ToString("yyyyMMdd'T'HHmmssK") + ",");
                    else
                        sb.Append(d.Date.ToString("yyyyMMdd") + ",");
                }
                sb.Remove(sb.Length - 1, 1);
            }

            if (sb.Length > 0)
                sb.Insert(0, "freq=");

            return sb.ToString();
        }

        private static readonly string[] _dateTimeFormats = new[]
                                                       {
                                                           "o",
                                                           "yyyyMMdd'T'HHmmssK",
                                                           "yyyyMMdd",
                                                           "yyyy'-'MM'-'dd'T'HH'-'mm'-'ss'.'fffffffK",
                                                           "yyyy'-'MM'-'dd'T'HH'-'mm'-'ss'.'fffK",
                                                           "yyyy'-'MM'-'dd'T'HH':'mm':'ss'.'fffK",
                                                           "yyyy'-'MM'-'dd'T'HH'-'mm'-'ssK",
                                                           "yyyy'-'MM'-'dd'T'HH':'mm':'ssK",
                                                           "yyyy'-'MM'-'dd"
                                                       };

        public static Frequency ParseFrequency(string frequency)
        {
            return (frequency.ToLower()) switch
            {
                "monthly" => Frequency.Monthly,

                "secondly" => Frequency.Secondly,

                "daily" => Frequency.Daily,

                "hourly" => Frequency.Hourly,

                "minutely" => Frequency.Minutely,

                "weekly" => Frequency.Weekly,

                "yearly" => Frequency.Yearly,

                _ => Frequency.Never,
            };
        }

        public static RecurrenceRule Parse(string serializedString)
        {
            var rr = new RecurrenceRule();
            var parts = serializedString.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
            foreach (var pair in parts)
            {
                var name = pair.Split('=')[0].Trim().ToLower();
                var val = pair.Split('=')[1].Trim().ToLower();
                switch (name)
                {
                    case "freq":
                        rr.Freq = ParseFrequency(val);

                        break;
                    case "until":
                        DateTime d;
                        if (DateTime.TryParseExact(val.ToUpper(), _dateTimeFormats, CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal, out d))
                            rr.Until = d;

                        break;

                    case "count":
                        rr.Count = Convert.ToInt32(val);
                        break;

                    case "interval":
                        rr.Interval = Convert.ToInt32(val);
                        break;

                    case "bysecond":
                        rr.BySecond = val.Split(',').Select(v => Convert.ToInt32(v)).ToArray();
                        break;

                    case "byminute":
                        rr.ByMinute = val.Split(',').Select(v => Convert.ToInt32(v)).ToArray();
                        break;

                    case "byhour":
                        rr.ByHour = val.Split(',').Select(v => Convert.ToInt32(v)).ToArray();
                        break;

                    case "byday":
                        rr.ByDay = val.Split(',').Select(v => RecurrenceRule.WeekDay.Parse(v)).ToArray();
                        break;

                    case "bymonthday":
                        rr.ByMonthDay = val.Split(',').Select(v => Convert.ToInt32(v)).ToArray();
                        break;

                    case "byyearday":
                        rr.ByYearDay = val.Split(',').Select(v => Convert.ToInt32(v)).ToArray();
                        break;

                    case "byweekno":
                        rr.ByWeekNo = val.Split(',').Select(v => Convert.ToInt32(v)).ToArray();
                        break;

                    case "bymonth":
                        rr.ByMonth = val.Split(',').Select(v => Convert.ToInt32(v)).ToArray();
                        break;

                    case "bysetpos":
                        rr.BySetPos = val.Split(',').Select(v => Convert.ToInt32(v)).ToArray();
                        break;

                    case "wkst":
                        rr.WKST = RecurrenceRule.WeekDay.Parse(val);
                        break;

                    case "exdates":

                        foreach (var date in val.Split(','))
                        {
                            if (DateTime.TryParseExact(date.ToUpper(), _dateTimeFormats, CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal, out var dt))
                                rr.ExDates.Add(new ExDate() { Date = dt, isDateTime = (date.ToLower().IndexOf('t') >= 0) });

                        }
                        break;
                }
            }

            return rr;
        }

        #region IiCalFormatView Members

        public string ToiCalFormat()
        {
            if (this.Freq == Frequency.Never)
                return string.Empty;

            var sb = new StringBuilder();
            sb.Append("RRULE:" + this.ToString(true));

            if (this.ExDates.Count > 0)
            {
                sb.Append("\r\nEXDATE");
                if (!this.ExDates[0].isDateTime)
                    sb.Append(";VALUE=DATE");

                sb.Append(":");
                foreach (var d in this.ExDates)
                {
                    if (d.isDateTime)
                        sb.Append(d.Date.ToString("yyyyMMdd'T'HHmmssK"));
                    else
                        sb.Append(d.Date.ToString("yyyyMMdd"));

                    sb.Append(",");
                }
                sb.Remove(sb.Length - 1, 1);
            }

            return sb.ToString().ToUpper();
        }

        #endregion

        #region ICloneable Members

        public object Clone()
        {
            var o = (RecurrenceRule)this.MemberwiseClone();

            o.ExDates = new List<ExDate>();
            this.ExDates.ForEach(d => o.ExDates.Add(d));

            if (ByDay != null)
            {
                var days = new List<WeekDay>();
                foreach (var d in ByDay)
                    days.Add(WeekDay.Parse(d.ToString()));

                o.ByDay = days.ToArray();
            }
            o.WKST = WeekDay.Parse(this.WKST.ToString());
            return o;
        }

        #endregion
    }
}