/* =========================================================
   INPUT CONFIGURATION
   ========================================================= */
/* =========================================================
   DAILY TASKS
   ========================================================= */
;WITH DailyCTE AS (
    SELECT @DailyStart AS StartDate
    UNION ALL
    SELECT DATEADD(DAY, @DailyInterval, StartDate)
    FROM DailyCTE
    WHERE DATEADD(DAY, @DailyInterval, StartDate) <= @RepeatUntil
)
SELECT
    'DAILY' AS TaskType,
    StartDate,
    DATEADD(DAY, @DailyGap, StartDate) AS TargetDate
FROM DailyCTE

UNION ALL

/* =========================================================
   WEEKLY TASKS (Calendar Anchored)
   ========================================================= */
SELECT
    'WEEKLY' AS TaskType,
    DATEADD(
        DAY,
        wd.DayOfWeek - DATEPART(WEEKDAY, wk.WeekStart),
        wk.WeekStart
    ) AS StartDate,
    DATEADD(
        DAY,
        @WeeklyGap,
        DATEADD(
            DAY,
            wd.DayOfWeek - DATEPART(WEEKDAY, wk.WeekStart),
            wk.WeekStart
        )
    ) AS TargetDate
FROM (
    SELECT DATEADD(WEEK, v.number, @WeeklyStart) AS WeekStart
    FROM master..spt_values v
    WHERE v.type = 'P'
      AND DATEADD(WEEK, v.number, @WeeklyStart) <= @RepeatUntil
) wk
CROSS JOIN @WeeklyDays wd
WHERE DATEADD(
        DAY,
        wd.DayOfWeek - DATEPART(WEEKDAY, wk.WeekStart),
        wk.WeekStart
      ) BETWEEN @WeeklyStart AND @RepeatUntil

UNION ALL

/* =========================================================
   MONTHLY TASKS (Calendar Anchored – FINAL RULE)
   ========================================================= */
SELECT
    'MONTHLY' AS TaskType,
    DATEFROMPARTS(
        YEAR(m.MonthDate),
        MONTH(m.MonthDate),
        CASE
            WHEN @MonthlyDay <= DAY(EOMONTH(m.MonthDate))
                THEN @MonthlyDay
            ELSE DAY(EOMONTH(m.MonthDate)) - 1  -- 🔒 FINAL RULE
        END
    ) AS StartDate,
    DATEADD(
        DAY,
        @MonthlyGap,
        DATEFROMPARTS(
            YEAR(m.MonthDate),
            MONTH(m.MonthDate),
            CASE
                WHEN @MonthlyDay <= DAY(EOMONTH(m.MonthDate))
                    THEN @MonthlyDay
                ELSE DAY(EOMONTH(m.MonthDate)) - 1
            END
        )
    ) AS TargetDate
FROM (
    SELECT DATEADD(MONTH, v.number, @MonthlyStart) AS MonthDate
    FROM master..spt_values v
    WHERE v.type = 'P'
      AND DATEADD(MONTH, v.number, @MonthlyStart) <= @RepeatUntil
) m
WHERE DATEFROMPARTS(
        YEAR(m.MonthDate),
        MONTH(m.MonthDate),
        CASE
            WHEN @MonthlyDay <= DAY(EOMONTH(m.MonthDate))
                THEN @MonthlyDay
            ELSE DAY(EOMONTH(m.MonthDate)) - 1
        END
      ) BETWEEN @MonthlyStart AND @RepeatUntil

OPTION (MAXRECURSION 0);

using System;
using System.Collections.Generic;
using System.Linq;

namespace RepeatingTaskFinal
{
    class Program
    {
        static void Main()
        {
            // ===============================
            // DAILY EXAMPLE
            // ===============================
            Console.WriteLine("=================================");
            Console.WriteLine("DAILY EXAMPLE");
            Console.WriteLine("Every 6 days | Gap = 2 days");
            Console.WriteLine("=================================\n");

            var dailyTasks = RepeatEngine.GenerateDaily(
                startDate: new DateTime(2025, 1, 1),
                repeatUntil: new DateTime(2025, 2, 1),
                intervalDays: 6,
                gapDays: 2
            );

            Print(dailyTasks);

            // ===============================
            // WEEKLY EXAMPLE
            // ===============================
            Console.WriteLine("\n=================================");
            Console.WriteLine("WEEKLY EXAMPLE");
            Console.WriteLine("2 days per week (Mon & Thu) | Gap = 3 days");
            Console.WriteLine("=================================\n");

            var weeklyTasks = RepeatEngine.GenerateWeekly(
                startDate: new DateTime(2025, 1, 6), // Monday
                repeatUntil: new DateTime(2025, 2, 6),
                daysOfWeek: new List<DayOfWeek>
                {
                    DayOfWeek.Monday,
                    DayOfWeek.Thursday
                },
                gapDays: 3
            );

            Print(weeklyTasks);

            // ===============================
            // MONTHLY EXAMPLE
            // ===============================
            Console.WriteLine("\n=================================");
            Console.WriteLine("MONTHLY EXAMPLE");
            Console.WriteLine("30th of every month | Gap = 2 days");
            Console.WriteLine("=================================\n");

            var monthlyTasks = RepeatEngine.GenerateMonthly(
                startDate: new DateTime(2025, 1, 30),
                repeatUntil: new DateTime(2025, 6, 30),
                selectedDay: 30,
                gapDays: 2
            );

            Print(monthlyTasks);

            Console.WriteLine("\n=== DONE ===");
        }

        static void Print(List<TaskItem> tasks)
        {
            foreach (var t in tasks)
            {
                Console.WriteLine(
                    $"Start: {t.StartDate:dd-MMM-yyyy}  →  " +
                    $"Target: {t.TargetDate:dd-MMM-yyyy}"
                );
            }
        }
    }

    // =====================================================
    // TASK MODEL
    // =====================================================
    public class TaskItem
    {
        public DateTime StartDate { get; set; }
        public DateTime TargetDate { get; set; }
    }

    // =====================================================
    // REPEAT ENGINE (FINAL, BUSINESS-SAFE)
    // =====================================================
    public static class RepeatEngine
    {
        // ---------------- DAILY ----------------
        public static List<TaskItem> GenerateDaily(
            DateTime startDate,
            DateTime repeatUntil,
            int intervalDays,
            int gapDays
        )
        {
            var result = new List<TaskItem>();
            var cursor = startDate;

            while (cursor <= repeatUntil)
            {
                result.Add(new TaskItem
                {
                    StartDate = cursor,
                    TargetDate = cursor.AddDays(gapDays)
                });

                cursor = cursor.AddDays(intervalDays);
            }

            return result;
        }

        // ---------------- WEEKLY ----------------
        // Calendar-anchored (e.g. Mon & Thu)
        public static List<TaskItem> GenerateWeekly(
            DateTime startDate,
            DateTime repeatUntil,
            List<DayOfWeek> daysOfWeek,
            int gapDays
        )
        {
            var result = new List<TaskItem>();
            var weekCursor = startDate;

            while (weekCursor <= repeatUntil)
            {
                foreach (var day in daysOfWeek.OrderBy(d => d))
                {
                    var start =
                        weekCursor.AddDays((int)day - (int)weekCursor.DayOfWeek);

                    if (start >= startDate && start <= repeatUntil)
                    {
                        result.Add(new TaskItem
                        {
                            StartDate = start,
                            TargetDate = start.AddDays(gapDays)
                        });
                    }
                }

                weekCursor = weekCursor.AddDays(7);
            }

            return result
                .GroupBy(t => t.StartDate)
                .Select(g => g.First())
                .OrderBy(t => t.StartDate)
                .ToList();
        }

        // ---------------- MONTHLY ----------------
        // 🔒 FINAL BUSINESS RULE:
        // If selected day does not exist → (last day − 1)
        // Feb → 27, Apr → 29
        public static List<TaskItem> GenerateMonthly(
            DateTime startDate,
            DateTime repeatUntil,
            int selectedDay,
            int gapDays
        )
        {
            var result = new List<TaskItem>();
            var cursor = new DateTime(startDate.Year, startDate.Month, 1);

            while (cursor <= repeatUntil)
            {
                int daysInMonth =
                    DateTime.DaysInMonth(cursor.Year, cursor.Month);

                int adjustedDay =
                    selectedDay <= daysInMonth
                        ? selectedDay
                        : daysInMonth - 1; // 🔒 DO NOT CHANGE

                var start = new DateTime(
                    cursor.Year,
                    cursor.Month,
                    adjustedDay
                );

                if (start >= startDate && start <= repeatUntil)
                {
                    result.Add(new TaskItem
                    {
                        StartDate = start,
                        TargetDate = start.AddDays(gapDays)
                    });
                }

                cursor = cursor.AddMonths(1);
            }

            return result;
        }
    }
}