using System;

using System.Collections.Generic; 

using Express.Recurrence; 

public class Program

{

    public static void Main()

    {

        var dates = new List<DateTime>(); 

        var startDate = new DateTime(2023,4,1); 

        var endDate = new DateTime(2023,4,30); 

        //var maxOccurance = 10; 

        //CBP RecurrencePattern 

        var rp = new RecurrencePattern { Type = RecurrenceTypeEnum.Daily, Interval = 1 };

        //Base Pattern 

        var basePattern = new BasePattern { StartDate = startDate, EndDate = endDate, EndMode = ENDMODE.ByDate  }; 

        //DAILY Every day

        var daySettings1 = new DayReccurance

        {   

            Constrain = DAYCONSTRAIN.NDay,

            Next = rp.Interval // Every N 

        };

        Console.WriteLine($"****** Daily Every {daySettings1.Next} days until {endDate} ****** {Environment.NewLine}");

        dates = Reccurance.GenerateDays(basePattern, daySettings1).Values; 

        PrintDates(dates); 

        rp = new RecurrencePattern { Type = RecurrenceTypeEnum.Daily, Interval = 4 };

        //DAILY Every 2 Days  

        var daySettings2 = new DayReccurance

        {   

            Constrain = DAYCONSTRAIN.NDay,

            Next = rp.Interval // Every N 

        };

        Console.WriteLine($"****** Daily Every 2 Days until {endDate} ****** {Environment.NewLine}");

        dates = Reccurance.GenerateDays(basePattern, daySettings2).Values; 

        PrintDates(dates); 

        rp = new RecurrencePattern { Type = RecurrenceTypeEnum.Weekly, Interval = 1, 

                                     DaysOfWeek = new List<DayOfWeekEnum> { 

                                            DayOfWeekEnum.Tuesday, 

                                            DayOfWeekEnum.Thursday 

                                            }  

                                   };

        //WEEKLY 

        var weekSettings1 = new WeeklyReccurance 

        {

            Next = rp.Interval //Every N 

        }; 

        SetWeekDays(weekSettings1, rp); 

        Console.WriteLine($"****** Weekly Every Tuesday and Thursday until {endDate} ****** {Environment.NewLine}");

        dates = Reccurance.GenerateWeeks(basePattern, weekSettings1).Values; 

        PrintDates(dates); 

        rp = new RecurrencePattern { Type = RecurrenceTypeEnum.Weekly, Interval = 2, 

                                     DaysOfWeek = new List<DayOfWeekEnum> { 

                                            DayOfWeekEnum.Tuesday, 

                                            DayOfWeekEnum.Thursday 

                                            }  

                                   };

        //WEEKLY 

        var weekSettings2 = new WeeklyReccurance 

        {

            Next = rp.Interval, //Every N 

        }; 

        SetWeekDays(weekSettings2, rp); 

        Console.WriteLine($"****** Weekly Every 2 Weeks Tuesday and Thursday until {endDate} ****** {Environment.NewLine}");

        dates = Reccurance.GenerateWeeks(basePattern, weekSettings2).Values; 

        PrintDates(dates); 

        basePattern.EndDate = new DateTime(2024,1,30);

        rp = new RecurrencePattern { Type = RecurrenceTypeEnum.Monthly, Interval = 1, DayOfMonth = 13  };

        //Monthly 

        var monthlySettings = new MonthlyReccurance 

        {

            Next = rp.Interval, //Every N 

            Constrain = MONTHCONSTRAIN.SpecificDay, 

            DayOfMonth = rp.DayOfMonth

        }; 

        Console.WriteLine($"****** Monthly Every {rp.Interval} (Monthly) on Day {rp.DayOfMonth} until {basePattern.EndDate} ****** {Environment.NewLine}");

        dates = Reccurance.GenerateMonths(basePattern, monthlySettings).Values; 

        PrintDates(dates); 

        rp = new RecurrencePattern { Type = RecurrenceTypeEnum.Monthly, Interval = 2, DayOfMonth = 13  };

        //Monthly 

        var monthlySettings2 = new MonthlyReccurance 

        {

            Next = rp.Interval, //Every N 

            Constrain = MONTHCONSTRAIN.SpecificDay, 

            DayOfMonth = rp.DayOfMonth

        }; 

        Console.WriteLine($"****** Monthly Every {rp.Interval} Months on Day {rp.DayOfMonth} until {basePattern.EndDate} ****** {Environment.NewLine}");

        dates = Reccurance.GenerateMonths(basePattern, monthlySettings2).Values; 

        PrintDates(dates); 

        rp = new RecurrencePattern { Type = RecurrenceTypeEnum.Monthly, Interval = 1, Ordinal = 4, 

                                    DaysOfWeek = new List<DayOfWeekEnum> { DayOfWeekEnum.Friday }  };

        //Monthly 

        var monthlySettings3 = new MonthlyReccurance 

        {

            Next = rp.Interval, //Every N 

            Constrain = MONTHCONSTRAIN.Logical

        }; 

        SetOrdinal(monthlySettings3, rp); 

        SetWeekDays(monthlySettings3, rp); 

        Console.WriteLine($"****** Monthly Every {rp.Ordinal}th Friday until {basePattern.EndDate} ****** {Environment.NewLine}");

        dates = Reccurance.GenerateMonths(basePattern, monthlySettings3).Values; 

        PrintDates(dates); 

        rp = new RecurrencePattern { Type = RecurrenceTypeEnum.Monthly, Interval = 1, Ordinal = -1,

                                    DaysOfWeek = new List<DayOfWeekEnum> { DayOfWeekEnum.Friday }  };

        //Monthly 

        var monthlySettings4= new MonthlyReccurance 

        {

            Next = rp.Interval, //Every N 

            Constrain = MONTHCONSTRAIN.Logical

        }; 

        SetOrdinal(monthlySettings4, rp); 

        SetWeekDays(monthlySettings4, rp); 

        Console.WriteLine($"****** Monthly Every Last Friday until {basePattern.EndDate} ****** {Environment.NewLine}");

        dates = Reccurance.GenerateMonths(basePattern, monthlySettings4).Values; 

        PrintDates(dates); 

        rp = new RecurrencePattern { Type = RecurrenceTypeEnum.Monthly, Interval = 3, Ordinal = 4,

                                    DaysOfWeek = new List<DayOfWeekEnum> { DayOfWeekEnum.Friday }  };

        //Monthly 

        var monthlySettings5= new MonthlyReccurance 

        {

            Next = rp.Interval, //Every N 

            Constrain = MONTHCONSTRAIN.Logical

        }; 

        SetOrdinal(monthlySettings5, rp); 

        SetWeekDays(monthlySettings5, rp); 

        Console.WriteLine($"****** Monthly Every {rp.Interval} Months on {rp.Ordinal}th Friday until {basePattern.EndDate} ****** {Environment.NewLine}");

        dates = Reccurance.GenerateMonths(basePattern, monthlySettings5).Values; 

        PrintDates(dates); 

        basePattern.EndDate = new DateTime(2028,1,30);

        rp = new RecurrencePattern { Type = RecurrenceTypeEnum.Yearly, Interval = 1, DayOfMonth = 4, MonthOfYear = 7 };

        //Monthly 

        var yearlySettings= new YearlyReccurance 

        {

            Next = rp.Interval, //Every N 

            Constrain = YEARCONSTRAIN.Logical, 

            Month = MONTHS.Jul,

            LogicalStart= LOGICALSTART.First,

            AdjustDays = rp.DayOfMonth-1

        }; 

​

        Console.WriteLine($"****** Yearly on {rp.MonthOfYear}th Month, Day {rp.DayOfMonth} until {basePattern.EndDate} ****** {Environment.NewLine}");

        dates = Reccurance.GenerateYears(basePattern, yearlySettings).Values; 

        PrintDates(dates); 

    }

    public static void PrintDates(List<DateTime> dates)

    {

        foreach(var dt in dates)

        {

            Console.WriteLine(dt); 

        }

        Console.WriteLine(Environment.NewLine); 

    }

    public static void SetWeekDays(WeeklyReccurance wSettings, RecurrencePattern rp)

    {

        foreach(var w in rp.DaysOfWeek)

        {

            switch(w)

            {

                case DayOfWeekEnum.Monday: wSettings.Monday = true; break; 

                case DayOfWeekEnum.Tuesday: wSettings.Tuesday = true; break;

                case DayOfWeekEnum.Wednesday: wSettings.Wednesday = true; break;

                case DayOfWeekEnum.Thursday: wSettings.Thursday = true; break;

                case DayOfWeekEnum.Friday: wSettings.Friday = true; break;

                case DayOfWeekEnum.Saturday: wSettings.Saturday = true; break;

                case DayOfWeekEnum.Sunday: wSettings.Sunday = true; break;

            }

        }

    }

    public static void SetOrdinal(MonthlyReccurance mSettings, RecurrencePattern rp)

    {

        switch (rp.Ordinal)

        {

            case 1: mSettings.LogicalStart = LOGICALSTART.First; break;

            case 2: mSettings.LogicalStart = LOGICALSTART.Second; break;

            case 3: mSettings.LogicalStart = LOGICALSTART.Third; break;

            case 4: mSettings.LogicalStart = LOGICALSTART.Fourth; break;

            case -1: mSettings.LogicalStart = LOGICALSTART.Last; break; // Sepecial Condition for -1 

        }

    }

    public static void SetWeekDays(MonthlyReccurance mSettings, RecurrencePattern rp)

    {

        foreach(var w in rp.DaysOfWeek)

        {

            switch(w)

            {

                case DayOfWeekEnum.Monday: mSettings.LogicalDay = LOGICALDAY.Monday; break; 

                case DayOfWeekEnum.Tuesday: mSettings.LogicalDay = LOGICALDAY.Tuesday; break;

                case DayOfWeekEnum.Wednesday: mSettings.LogicalDay = LOGICALDAY.Wednesday; break;

                case DayOfWeekEnum.Thursday: mSettings.LogicalDay = LOGICALDAY.Thursday; break;

                case DayOfWeekEnum.Friday: mSettings.LogicalDay = LOGICALDAY.Friday; break;

                case DayOfWeekEnum.Saturday: mSettings.LogicalDay = LOGICALDAY.Saturday; break;

                case DayOfWeekEnum.Sunday: mSettings.LogicalDay = LOGICALDAY.Sunday; break;

            }

        }

    }

}

​

public enum RecurrenceTypeEnum {

    Daily, 

    Weekly, 

    Monthly, 

    Yearly

}

​

public enum DayOfWeekEnum{

    Monday, 

    Tuesday, 

    Wednesday, 

    Thursday, 

    Friday, 

    Saturday, 

    Sunday

}

​

public class RecurrencePattern

{

    // Used with : Daily, Weekly, Monthly, Yearly

    public RecurrenceTypeEnum Type { get; set; } // Daily, Weekly, Monthly, Yearly. RecurrenceType is enum 

    // Used with : Daily, Weekly, Monthly

    public int Interval { get; set; } // as in every 1 day, 4 days, 1 week, 2 weeks, 1 month, 2 , 3 months in our example 

    // Used with : Weekly, Monthly (case 2)

    public List<DayOfWeekEnum> DaysOfWeek { get; set; } //Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday. DayOfWeek is enum 

​

    // Used with : Monthly (case 2)

    public int Ordinal { get; set; } // as in 1st, 2nd, 3rd, 4th, 5th a special value -1 or 99 to represet "last"

​

    // Used with : Monthly (case 1), Yearly  

    public int DayOfMonth { get; set; } // 1-31 

​

    // Used with : Yearly 

    public int MonthOfYear { get; set; } // 1- 12 

​

    public DateTime TerminationDate { get; set; } // Recurrance Termination date or when do we stop 

}

​