import moment from 'moment-timezone';
import type { CronExpression, INode } from 'n8n-workflow';
import type { Mock } from 'vitest';

import {
	intervalToRecurrence,
	recurrenceCheck,
	resetStaleRecurrence,
	toCronExpression,
	validateInterval,
	withIntervalDefaults,
} from '../GenericFunctions';
import type { RawScheduleInterval, ScheduleInterval } from '../SchedulerInterface';

vi.mock('moment-timezone');
const mockedMoment = vi.mocked(moment);

function mockMomentTz(values: {
	epochMinute?: number;
	hour?: number;
	dayOfYear?: number;
	week?: number;
	month?: number;
	year?: number;
}) {
	const tzObj = {
		valueOf: () => (values.epochMinute ?? 0) * 60_000,
		hour: () => values.hour ?? 0,
		dayOfYear: () => values.dayOfYear ?? 1,
		week: () => values.week ?? 1,
		month: () => values.month ?? 0,
		year: () => values.year ?? 0,
	};
	(mockedMoment.tz as unknown as Mock).mockReturnValue(tzObj);
}

// Cron expressions are 6 fields: `<sec> <min> <hr> <dom> <mon> <dow>`.
// Fields the user does not explicitly pin (e.g. `triggerAtMinute`) are
// filled in by `stableInt(seed, label, ...)`; every other field comes
// from the input interval.
//
// For `seed = 'test-key'`, `stableInt` produces:
//   second=56, minute=19, hour=14, dayOfMonth=22
const TEST_SEED = 'test-key';

describe('toCronExpression', () => {
	it('should return cron expression for cronExpression field', () => {
		// All fields are user-provided literally — no filler.
		const result = toCronExpression(
			{
				field: 'cronExpression',
				expression: '1 2 3 * * *',
			},
			TEST_SEED,
		);
		expect(result).toEqual('1 2 3 * * *');
	});

	it('should return cron expression for seconds interval', () => {
		// Sub-minute schedules use `*/N`; no filler needed.
		const result = toCronExpression(
			{
				field: 'seconds',
				secondsInterval: 10,
			},
			TEST_SEED,
		);
		expect(result).toEqual('*/10 * * * * *');
	});

	it('should return cron expression for minutes interval', () => {
		// sec=56 is filler; */30 comes from `minutesInterval`.
		const result = toCronExpression(
			{
				field: 'minutes',
				minutesInterval: 30,
			},
			TEST_SEED,
		);
		expect(result).toEqual('56 */30 * * * *');

		// 50 does not divide 60 — fire every minute, gated by recurrenceCheck.
		const result1 = toCronExpression(
			{
				field: 'minutes',
				minutesInterval: 50,
			},
			TEST_SEED,
		);
		expect(result1).toEqual('56 * * * * *');
	});

	it('should return cron expression for hours interval', () => {
		// sec=56 is filler; min=22 from `triggerAtMinute`; */3 from `hoursInterval`.
		const result = toCronExpression(
			{
				field: 'hours',
				hoursInterval: 3,
				triggerAtMinute: 22,
			},
			TEST_SEED,
		);
		expect(result).toEqual('56 22 */3 * * *');

		// No `triggerAtMinute`, so min=19 is also filler.
		const result1 = toCronExpression(
			{
				field: 'hours',
				hoursInterval: 3,
			},
			TEST_SEED,
		);
		expect(result1).toEqual('56 19 */3 * * *');

		const result2 = toCronExpression(
			{
				field: 'hours',
				hoursInterval: 18,
			},
			TEST_SEED,
		);
		expect(result2).toEqual('56 19 * * * *');
	});

	it('should return cron expression for days interval', () => {
		// sec=56 is filler; min=30 and hr=10 from `triggerAtMinute`/`triggerAtHour`.
		const result = toCronExpression(
			{
				field: 'days',
				daysInterval: 4,
				triggerAtMinute: 30,
				triggerAtHour: 10,
			},
			TEST_SEED,
		);
		expect(result).toEqual('56 30 10 * * *');

		// Nothing pinned, so sec=56 / min=19 / hr=14 are all filler.
		const result1 = toCronExpression(
			{
				field: 'days',
				daysInterval: 4,
			},
			TEST_SEED,
		);
		expect(result1).toEqual('56 19 14 * * *');
	});

	it('should return cron expression for weeks interval', () => {
		// sec=56 is filler; the rest come from `triggerAtMinute`/`triggerAtHour`/`triggerAtDay`.
		const result = toCronExpression(
			{
				field: 'weeks',
				weeksInterval: 2,
				triggerAtMinute: 0,
				triggerAtHour: 9,
				triggerAtDay: [1, 3, 5],
			},
			TEST_SEED,
		);
		expect(result).toEqual('56 0 9 * * 1,3,5');
		// Only `triggerAtDay` pinned, so sec=56 / min=19 / hr=14 are all filler.
		const result1 = toCronExpression(
			{
				field: 'weeks',
				weeksInterval: 2,
				triggerAtDay: [1, 3, 5],
			},
			TEST_SEED,
		);
		expect(result1).toEqual('56 19 14 * * 1,3,5');
	});

	it('should return cron expression for months interval', () => {
		// sec=56 is filler; min/hr/dom come from triggerAt*.
		const result = toCronExpression(
			{
				field: 'months',
				monthsInterval: 3,
				triggerAtMinute: 0,
				triggerAtHour: 0,
				triggerAtDayOfMonth: 1,
			},
			TEST_SEED,
		);
		expect(result).toEqual('56 0 0 1 */3 *');
		// Nothing pinned, so sec=56 / min=19 / hr=14 / dom=22 are all filler.
		const result1 = toCronExpression(
			{
				field: 'months',
				monthsInterval: 3,
			},
			TEST_SEED,
		);
		expect(result1).toEqual('56 19 14 22 */3 *');
	});

	it('should keep `*/N` for month intervals that divide 12, and fire monthly otherwise', () => {
		// Divisors of 12 keep their calendar-anchored cron unchanged.
		for (const months of [1, 2, 3, 4, 6, 12]) {
			expect(toCronExpression({ field: 'months', monthsInterval: months }, TEST_SEED)).toEqual(
				`56 19 14 22 */${months} *`,
			);
		}
		// Non-divisors fire every month; recurrenceCheck enforces the elapsed-months gap.
		for (const months of [5, 7, 8, 13, 24]) {
			expect(toCronExpression({ field: 'months', monthsInterval: months }, TEST_SEED)).toEqual(
				'56 19 14 22 * *',
			);
		}
	});
});

describe('withIntervalDefaults', () => {
	it.each<[string, RawScheduleInterval, ScheduleInterval]>([
		['an empty entry', {}, { field: 'days', daysInterval: 1 }],
		[
			'an entry with no field',
			{ triggerAtHour: 7 },
			{ field: 'days', daysInterval: 1, triggerAtHour: 7 },
		],
		[
			'an unrecognized field',
			{ field: 'daily' } as unknown as RawScheduleInterval,
			{ field: 'days', daysInterval: 1 },
		],
		[
			'a seconds entry with no size',
			{ field: 'seconds' },
			{ field: 'seconds', secondsInterval: 30 },
		],
		[
			'a minutes entry with no size',
			{ field: 'minutes' },
			{ field: 'minutes', minutesInterval: 5 },
		],
		['an hours entry with no size', { field: 'hours' }, { field: 'hours', hoursInterval: 1 }],
		['a days entry with no size', { field: 'days' }, { field: 'days', daysInterval: 1 }],
		[
			'a weeks entry with no size and no weekdays',
			{ field: 'weeks' },
			{ field: 'weeks', weeksInterval: 1, triggerAtDay: [0] },
		],
		['a months entry with no size', { field: 'months' }, { field: 'months', monthsInterval: 1 }],
		[
			'a cron entry with no expression',
			{ field: 'cronExpression' },
			{ field: 'cronExpression', expression: '' as CronExpression },
		],
	])('should complete %s', (_, stored, expected) => {
		expect(withIntervalDefaults(stored)).toEqual(expected);
	});

	it('should keep an out-of-range size so validateInterval can report it', () => {
		expect(withIntervalDefaults({ field: 'days', daysInterval: 0 })).toEqual({
			field: 'days',
			daysInterval: 0,
		});
	});
});

describe('validateInterval', () => {
	const mockNode: INode = {
		id: 'test-node',
		name: 'Test Node',
		type: 'n8n-nodes-base.scheduleTrigger',
		typeVersion: 1,
		position: [0, 0],
		parameters: {},
	};

	describe('valid intervals', () => {
		it.each<[string, ScheduleInterval]>([
			['seconds', { field: 'seconds', secondsInterval: 1 }],
			['seconds', { field: 'seconds', secondsInterval: 30 }],
			['seconds', { field: 'seconds', secondsInterval: 59 }],
			['minutes', { field: 'minutes', minutesInterval: 1 }],
			['minutes', { field: 'minutes', minutesInterval: 30 }],
			['minutes', { field: 'minutes', minutesInterval: 59 }],
			['hours', { field: 'hours', hoursInterval: 1 }],
			['hours', { field: 'hours', hoursInterval: 12 }],
			['hours', { field: 'hours', hoursInterval: 23 }],
			['days', { field: 'days', daysInterval: 1 }],
			['days', { field: 'days', daysInterval: 15 }],
			['days', { field: 'days', daysInterval: 31 }],
		])('should not throw error for valid %s interval: %j', (_field, interval) => {
			expect(() => {
				validateInterval(mockNode, 0, interval);
			}).not.toThrow();
		});
	});

	describe('invalid intervals', () => {
		it.each<[string, ScheduleInterval, string]>([
			['seconds', { field: 'seconds', secondsInterval: 0 }, 'Seconds must be in range 1-59'],
			['seconds', { field: 'seconds', secondsInterval: 60 }, 'Seconds must be in range 1-59'],
			['seconds', { field: 'seconds', secondsInterval: -1 }, 'Seconds must be in range 1-59'],
			['seconds', { field: 'seconds', secondsInterval: 100 }, 'Seconds must be in range 1-59'],
			['minutes', { field: 'minutes', minutesInterval: 60 }, 'Minutes must be in range 1-59'],
			['minutes', { field: 'minutes', minutesInterval: 0 }, 'Minutes must be in range 1-59'],
			['minutes', { field: 'minutes', minutesInterval: -1 }, 'Minutes must be in range 1-59'],
			['minutes', { field: 'minutes', minutesInterval: 100 }, 'Minutes must be in range 1-59'],
			['hours', { field: 'hours', hoursInterval: 0 }, 'Hours must be in range 1-23'],
			['hours', { field: 'hours', hoursInterval: 24 }, 'Hours must be in range 1-23'],
			['hours', { field: 'hours', hoursInterval: -1 }, 'Hours must be in range 1-23'],
			['hours', { field: 'hours', hoursInterval: 100 }, 'Hours must be in range 1-23'],
			['days', { field: 'days', daysInterval: 0 }, 'Days must be in range 1-31'],
			['days', { field: 'days', daysInterval: 32 }, 'Days must be in range 1-31'],
			['days', { field: 'days', daysInterval: -1 }, 'Days must be in range 1-31'],
			['days', { field: 'days', daysInterval: 100 }, 'Days must be in range 1-31'],
			['months', { field: 'months', monthsInterval: 0 }, 'Months must be larger than 0'],
		])(
			'should throw error for invalid %s interval: %j',
			(_field, interval, expectedDescription) => {
				try {
					validateInterval(mockNode, 0, interval);
					expect.fail('Expected validateInterval to throw an error');
				} catch (error) {
					expect(error.message).toBe('Invalid interval');
					expect(error.description).toBe(expectedDescription);
				}
			},
		);
	});
});

describe('recurrenceCheck', () => {
	it('should return true if activated=false', () => {
		const result = recurrenceCheck({ activated: false }, [], 'UTC');
		expect(result).toBe(true);
	});

	it('should return false if intervalSize is falsey', () => {
		mockMomentTz({ dayOfYear: 10 });
		const result = recurrenceCheck(
			{
				activated: true,
				index: 0,
				intervalSize: 0,
				typeInterval: 'days',
			},
			[],
			'UTC',
		);
		expect(result).toBe(false);
	});

	it('should return true on first execution when lastExecution is undefined', () => {
		mockMomentTz({ dayOfYear: 100 });
		const recurrenceRules: number[] = [];
		const result = recurrenceCheck(
			{ activated: true, index: 0, intervalSize: 3, typeInterval: 'days' },
			recurrenceRules,
			'UTC',
		);
		expect(result).toBe(true);
		expect(recurrenceRules[0]).toBe(100);
	});

	it('should treat a persisted null (reset slot) as a first execution', () => {
		mockMomentTz({ dayOfYear: 100 });
		const recurrenceRules: Array<number | null> = [null];
		const result = recurrenceCheck(
			{ activated: true, index: 0, intervalSize: 3, typeInterval: 'days' },
			recurrenceRules,
			'UTC',
		);
		expect(result).toBe(true);
		expect(recurrenceRules[0]).toBe(100);
	});

	it('should not trigger again on the same day', () => {
		mockMomentTz({ dayOfYear: 100 });
		const recurrenceRules: number[] = [];
		recurrenceCheck(
			{ activated: true, index: 0, intervalSize: 2, typeInterval: 'days' },
			recurrenceRules,
			'UTC',
		);
		const result = recurrenceCheck(
			{ activated: true, index: 0, intervalSize: 2, typeInterval: 'days' },
			recurrenceRules,
			'UTC',
		);
		expect(result).toBe(false);
	});

	describe('minutes', () => {
		it('should trigger when exactly on time', () => {
			mockMomentTz({ epochMinute: 1000 });
			const recurrenceRules = [950]; // 50 minutes elapsed, interval = 50
			const result = recurrenceCheck(
				{ activated: true, index: 0, intervalSize: 50, typeInterval: 'minutes' },
				recurrenceRules,
				'UTC',
			);
			expect(result).toBe(true);
			expect(recurrenceRules[0]).toBe(1000);
		});

		it('should not trigger before interval has elapsed', () => {
			mockMomentTz({ epochMinute: 1000 });
			const recurrenceRules = [960]; // only 40 minutes elapsed, need 50
			const result = recurrenceCheck(
				{ activated: true, index: 0, intervalSize: 50, typeInterval: 'minutes' },
				recurrenceRules,
				'UTC',
			);
			expect(result).toBe(false);
		});

		it('should fire on the first tick after a gap longer than the hour wrap', () => {
			mockMomentTz({ epochMinute: 1000 });
			// 110 minutes elapsed: a wall-clock minute-of-hour gate would read this
			// as 50 % 60 elapsed and wait again; the absolute count fires immediately.
			const recurrenceRules = [890];
			const result = recurrenceCheck(
				{ activated: true, index: 0, intervalSize: 50, typeInterval: 'minutes' },
				recurrenceRules,
				'UTC',
			);
			expect(result).toBe(true);
			expect(recurrenceRules[0]).toBe(1000);
		});
	});

	describe('hours', () => {
		it('should trigger when exactly on time', () => {
			mockMomentTz({ hour: 5 });
			const recurrenceRules = [2]; // lastExecution = hour 2, interval = 3
			const result = recurrenceCheck(
				{ activated: true, index: 0, intervalSize: 3, typeInterval: 'hours' },
				recurrenceRules,
				'UTC',
			);
			expect(result).toBe(true);
			expect(recurrenceRules[0]).toBe(5);
		});

		it('should not trigger before interval has elapsed', () => {
			mockMomentTz({ hour: 4 });
			const recurrenceRules = [2];
			const result = recurrenceCheck(
				{ activated: true, index: 0, intervalSize: 3, typeInterval: 'hours' },
				recurrenceRules,
				'UTC',
			);
			expect(result).toBe(false);
		});

		it('should recover after a missed execution', () => {
			mockMomentTz({ hour: 8 });
			const recurrenceRules = [2]; // missed hour 5, now at hour 8
			const result = recurrenceCheck(
				{ activated: true, index: 0, intervalSize: 3, typeInterval: 'hours' },
				recurrenceRules,
				'UTC',
			);
			expect(result).toBe(true);
			expect(recurrenceRules[0]).toBe(8);
		});

		it('should handle wrap-around (e.g., 23 → 2)', () => {
			mockMomentTz({ hour: 2 });
			const recurrenceRules = [23]; // lastExecution = 23, interval = 3, expected = 2
			const result = recurrenceCheck(
				{ activated: true, index: 0, intervalSize: 3, typeInterval: 'hours' },
				recurrenceRules,
				'UTC',
			);
			expect(result).toBe(true);
		});

		it('should not trigger before interval on wrap-around', () => {
			mockMomentTz({ hour: 0 });
			const recurrenceRules = [23]; // only 1 hour elapsed, need 3
			const result = recurrenceCheck(
				{ activated: true, index: 0, intervalSize: 3, typeInterval: 'hours' },
				recurrenceRules,
				'UTC',
			);
			expect(result).toBe(false);
		});
	});

	describe('days', () => {
		it('should trigger when exactly on time', () => {
			mockMomentTz({ dayOfYear: 24 });
			const recurrenceRules = [21]; // lastExecution = day 21, interval = 3
			const result = recurrenceCheck(
				{ activated: true, index: 0, intervalSize: 3, typeInterval: 'days' },
				recurrenceRules,
				'UTC',
			);
			expect(result).toBe(true);
			expect(recurrenceRules[0]).toBe(24);
		});

		it('should not trigger before interval has elapsed', () => {
			mockMomentTz({ dayOfYear: 23 });
			const recurrenceRules = [21];
			const result = recurrenceCheck(
				{ activated: true, index: 0, intervalSize: 3, typeInterval: 'days' },
				recurrenceRules,
				'UTC',
			);
			expect(result).toBe(false);
		});

		it('should recover after a missed execution', () => {
			mockMomentTz({ dayOfYear: 30 });
			const recurrenceRules = [21]; // missed day 24, now at day 30
			const result = recurrenceCheck(
				{ activated: true, index: 0, intervalSize: 3, typeInterval: 'days' },
				recurrenceRules,
				'UTC',
			);
			expect(result).toBe(true);
			expect(recurrenceRules[0]).toBe(30);
		});

		it('should handle wrap-around at year boundary', () => {
			mockMomentTz({ dayOfYear: 3 });
			const recurrenceRules = [363]; // interval = 5, elapsed = (3-363+365)%365 = 5
			const result = recurrenceCheck(
				{ activated: true, index: 0, intervalSize: 5, typeInterval: 'days' },
				recurrenceRules,
				'UTC',
			);
			expect(result).toBe(true);
		});

		it('should not trigger before interval on wrap-around', () => {
			mockMomentTz({ dayOfYear: 2 });
			const recurrenceRules = [363]; // elapsed = (2-363+365)%365 = 4, need 5
			const result = recurrenceCheck(
				{ activated: true, index: 0, intervalSize: 5, typeInterval: 'days' },
				recurrenceRules,
				'UTC',
			);
			expect(result).toBe(false);
		});

		it('should reproduce the exact bug from NODE-4831 (Indeed scenario)', () => {
			// Workflow set to "every 3 days", last fired on day 21, missed day 24
			// Now on day 25 — should fire but currently doesn't
			mockMomentTz({ dayOfYear: 25 });
			const recurrenceRules = [21];
			const result = recurrenceCheck(
				{ activated: true, index: 0, intervalSize: 3, typeInterval: 'days' },
				recurrenceRules,
				'UTC',
			);
			expect(result).toBe(true);
		});
	});

	describe('weeks', () => {
		it('should trigger when exactly on time', () => {
			mockMomentTz({ week: 8 });
			const recurrenceRules = [6]; // lastExecution = week 6, interval = 2
			const result = recurrenceCheck(
				{ activated: true, index: 0, intervalSize: 2, typeInterval: 'weeks' },
				recurrenceRules,
				'UTC',
			);
			expect(result).toBe(true);
			expect(recurrenceRules[0]).toBe(8);
		});

		it('should not trigger before interval has elapsed', () => {
			mockMomentTz({ week: 7 });
			const recurrenceRules = [6];
			const result = recurrenceCheck(
				{ activated: true, index: 0, intervalSize: 2, typeInterval: 'weeks' },
				recurrenceRules,
				'UTC',
			);
			expect(result).toBe(false);
		});

		it('should recover after a missed execution', () => {
			mockMomentTz({ week: 10 });
			const recurrenceRules = [6]; // missed week 8, now at week 10
			const result = recurrenceCheck(
				{ activated: true, index: 0, intervalSize: 2, typeInterval: 'weeks' },
				recurrenceRules,
				'UTC',
			);
			expect(result).toBe(true);
			expect(recurrenceRules[0]).toBe(10);
		});

		it('should allow re-trigger on multiple days in the same week', () => {
			mockMomentTz({ week: 10 });
			const recurrenceRules = [10]; // same week as lastExecution
			const result = recurrenceCheck(
				{ activated: true, index: 0, intervalSize: 2, typeInterval: 'weeks' },
				recurrenceRules,
				'UTC',
			);
			expect(result).toBe(true);
		});

		it('should handle wrap-around at year boundary', () => {
			mockMomentTz({ week: 2 });
			const recurrenceRules = [50]; // elapsed = (2-50+52)%52 = 4, interval = 3
			const result = recurrenceCheck(
				{ activated: true, index: 0, intervalSize: 3, typeInterval: 'weeks' },
				recurrenceRules,
				'UTC',
			);
			expect(result).toBe(true);
		});
	});

	describe('months', () => {
		it('should trigger when exactly on time', () => {
			mockMomentTz({ month: 5 });
			const recurrenceRules = [2]; // lastExecution = month 2, interval = 3
			const result = recurrenceCheck(
				{ activated: true, index: 0, intervalSize: 3, typeInterval: 'months' },
				recurrenceRules,
				'UTC',
			);
			expect(result).toBe(true);
			expect(recurrenceRules[0]).toBe(5);
		});

		it('should not trigger before interval has elapsed', () => {
			mockMomentTz({ month: 3 });
			const recurrenceRules = [2];
			const result = recurrenceCheck(
				{ activated: true, index: 0, intervalSize: 3, typeInterval: 'months' },
				recurrenceRules,
				'UTC',
			);
			expect(result).toBe(false);
		});

		it('should recover after a missed execution', () => {
			mockMomentTz({ month: 8 });
			const recurrenceRules = [2]; // missed month 5, now at month 8
			const result = recurrenceCheck(
				{ activated: true, index: 0, intervalSize: 3, typeInterval: 'months' },
				recurrenceRules,
				'UTC',
			);
			expect(result).toBe(true);
			expect(recurrenceRules[0]).toBe(8);
		});

		it('should handle wrap-around across the year boundary (month 10 → month 1)', () => {
			mockMomentTz({ month: 1, year: 1 }); // absolute month = 13
			const recurrenceRules = [10]; // last fired month 10 of year 0; elapsed = 13-10 = 3
			const result = recurrenceCheck(
				{ activated: true, index: 0, intervalSize: 3, typeInterval: 'months' },
				recurrenceRules,
				'UTC',
			);
			expect(result).toBe(true);
		});

		it('should not trigger before interval across the year boundary', () => {
			mockMomentTz({ month: 0, year: 1 }); // absolute month = 12
			const recurrenceRules = [10]; // last fired month 10 of year 0; elapsed = 12-10 = 2, need 3
			const result = recurrenceCheck(
				{ activated: true, index: 0, intervalSize: 3, typeInterval: 'months' },
				recurrenceRules,
				'UTC',
			);
			expect(result).toBe(false);
		});

		it('should keep firing "every 12 months" after the first execution', () => {
			const recurrenceRules: number[] = [];
			const rule = {
				activated: true,
				index: 0,
				intervalSize: 12,
				typeInterval: 'months',
			} as const;

			mockMomentTz({ month: 0, year: 1 }); // first January
			expect(recurrenceCheck(rule, recurrenceRules, 'UTC')).toBe(true);

			mockMomentTz({ month: 11, year: 1 }); // 11 months later, not yet due
			expect(recurrenceCheck(rule, recurrenceRules, 'UTC')).toBe(false);

			mockMomentTz({ month: 0, year: 2 }); // 12 months later, next January
			expect(recurrenceCheck(rule, recurrenceRules, 'UTC')).toBe(true);
		});
	});

	describe('schedule change recovery (NODE-4625)', () => {
		it('should recover when interval is changed and lastExecution is stale', () => {
			// Was "every 5 days", changed to "every 3 days". lastExecution=day 21 from old schedule.
			// Now on day 25 — enough time has passed for the new 3-day interval.
			mockMomentTz({ dayOfYear: 25 });
			const recurrenceRules = [21];
			const result = recurrenceCheck(
				{ activated: true, index: 0, intervalSize: 3, typeInterval: 'days' },
				recurrenceRules,
				'UTC',
			);
			expect(result).toBe(true);
			expect(recurrenceRules[0]).toBe(25);
		});
	});

	describe('stale value left by a type change from days to hours', () => {
		const hoursRule = {
			activated: true,
			index: 0,
			intervalSize: 3,
			typeInterval: 'hours',
		} as const;

		it('never fires when a day-of-year value lingers under an hours rule', () => {
			// staticData holds a day-of-year (200) at index 0 from a previous "every 3 days"
			// schedule. Read as an hour, it blocks the trigger across every hour of the day.
			const recurrenceRules = [200];
			let everFires = false;
			for (let h = 0; h < 24; h++) {
				mockMomentTz({ hour: h });
				if (recurrenceCheck(hoursRule, [...recurrenceRules], 'UTC')) everFires = true;
			}
			expect(everFires).toBe(false);
		});

		it('fires again once resetStaleRecurrence clears the stale value', () => {
			const recurrenceRules: number[] = [200];
			resetStaleRecurrence({ recurrenceRules, recurrenceRuleSignatures: [] }, [
				{ recurrence: hoursRule },
			]);
			mockMomentTz({ hour: 0 });
			expect(recurrenceCheck(hoursRule, recurrenceRules, 'UTC')).toBe(true);
		});
	});
});

describe('intervalToRecurrence', () => {
	it('should return recurrence rule for seconds interval', () => {
		const result = intervalToRecurrence(
			{
				field: 'seconds',
				secondsInterval: 10,
			},
			0,
		);
		expect(result.activated).toBe(false);
	});

	it('should return recurrence rule for minutes interval', () => {
		const result = intervalToRecurrence(
			{
				field: 'minutes',
				minutesInterval: 30,
			},
			1,
		);
		expect(result.activated).toBe(false);

		// Non-dividing interval needs the recurrence gate.
		const result1 = intervalToRecurrence(
			{
				field: 'minutes',
				minutesInterval: 50,
			},
			1,
		);
		expect(result1).toEqual({
			activated: true,
			index: 1,
			intervalSize: 50,
			typeInterval: 'minutes',
		});
	});

	it('should not activate recurrence for a non-positive minutes interval (pre-1.3 nodes skip validation)', () => {
		const result = intervalToRecurrence(
			{
				field: 'minutes',
				minutesInterval: 0,
			},
			1,
		);
		expect(result.activated).toBe(false);
	});

	it('should return recurrence rule for hours interval', () => {
		const result = intervalToRecurrence(
			{
				field: 'hours',
				hoursInterval: 3,
				triggerAtMinute: 22,
			},
			2,
		);
		expect(result).toEqual({
			activated: true,
			index: 2,
			intervalSize: 3,
			typeInterval: 'hours',
		});

		const result1 = intervalToRecurrence(
			{
				field: 'hours',
				hoursInterval: 3,
			},
			3,
		);
		expect(result1).toEqual({
			activated: true,
			index: 3,
			intervalSize: 3,
			typeInterval: 'hours',
		});
	});

	it('should return recurrence rule for days interval', () => {
		const result = intervalToRecurrence(
			{
				field: 'days',
				daysInterval: 4,
				triggerAtMinute: 30,
				triggerAtHour: 10,
			},
			4,
		);
		expect(result).toEqual({
			activated: true,
			index: 4,
			intervalSize: 4,
			typeInterval: 'days',
		});

		const result1 = intervalToRecurrence(
			{
				field: 'days',
				daysInterval: 4,
			},
			5,
		);
		expect(result1).toEqual({
			activated: true,
			index: 5,
			intervalSize: 4,
			typeInterval: 'days',
		});
	});

	it('should return recurrence rule for weeks interval', () => {
		const result = intervalToRecurrence(
			{
				field: 'weeks',
				weeksInterval: 2,
				triggerAtMinute: 0,
				triggerAtHour: 9,
				triggerAtDay: [1, 3, 5],
			},
			6,
		);
		expect(result).toEqual({
			activated: true,
			index: 6,
			intervalSize: 2,
			typeInterval: 'weeks',
		});
	});

	it('should return recurrence rule for months interval', () => {
		const result = intervalToRecurrence(
			{
				field: 'months',
				monthsInterval: 3,
				triggerAtMinute: 0,
				triggerAtHour: 0,
				triggerAtDayOfMonth: 1,
			},
			8,
		);
		expect(result).toEqual({
			activated: true,
			index: 8,
			intervalSize: 3,
			typeInterval: 'months',
		});
	});
});

describe('resetStaleRecurrence', () => {
	const daysRule = {
		activated: true,
		index: 0,
		intervalSize: 3,
		typeInterval: 'days',
	} as const;

	it('keeps an in-range value and backfills the signature on upgrade', () => {
		// No signature yet (pre-upgrade) + a value still valid for its type: the
		// schedule is healthy, so keep its cadence and only record the signature.
		const staticData = { recurrenceRules: [200], recurrenceRuleSignatures: [] as string[] };
		resetStaleRecurrence(staticData, [{ recurrence: daysRule }]);
		expect(staticData.recurrenceRules[0]).toBe(200);
		expect(staticData.recurrenceRuleSignatures[0]).toBe('days:3');
	});

	it('clears an out-of-range value and records the signature on upgrade', () => {
		// No signature yet + a value impossible for the type (200 as an hour): this
		// is the stale wrong-unit state that blocks the trigger, so clear it.
		const staticData = { recurrenceRules: [200], recurrenceRuleSignatures: [] as string[] };
		resetStaleRecurrence(staticData, [
			{ recurrence: { activated: true, index: 0, intervalSize: 3, typeInterval: 'hours' } },
		]);
		expect(staticData.recurrenceRules[0]).toBeUndefined();
		expect(staticData.recurrenceRuleSignatures[0]).toBe('hours:3');
	});

	it('clears a months value on upgrade (absolute-month encoding is new)', () => {
		// Old 0-11 month index is meaningless under the new absolute count.
		const staticData = { recurrenceRules: [5], recurrenceRuleSignatures: [] as string[] };
		resetStaleRecurrence(staticData, [
			{ recurrence: { activated: true, index: 0, intervalSize: 2, typeInterval: 'months' } },
		]);
		expect(staticData.recurrenceRules[0]).toBeUndefined();
		expect(staticData.recurrenceRuleSignatures[0]).toBe('months:2');
	});

	it('leaves the stored value intact when the signature is unchanged', () => {
		const staticData = { recurrenceRules: [21], recurrenceRuleSignatures: ['days:3'] };
		resetStaleRecurrence(staticData, [{ recurrence: daysRule }]);
		expect(staticData.recurrenceRules[0]).toBe(21);
		expect(staticData.recurrenceRuleSignatures[0]).toBe('days:3');
	});

	it('clears the stored value when the interval type changes', () => {
		const staticData = { recurrenceRules: [200], recurrenceRuleSignatures: ['days:3'] };
		resetStaleRecurrence(staticData, [
			{ recurrence: { activated: true, index: 0, intervalSize: 3, typeInterval: 'hours' } },
		]);
		expect(staticData.recurrenceRules[0]).toBeUndefined();
		expect(staticData.recurrenceRuleSignatures[0]).toBe('hours:3');
	});

	it('clears the stored value when the interval size changes', () => {
		const staticData = { recurrenceRules: [21], recurrenceRuleSignatures: ['days:3'] };
		resetStaleRecurrence(staticData, [
			{ recurrence: { activated: true, index: 0, intervalSize: 5, typeInterval: 'days' } },
		]);
		expect(staticData.recurrenceRules[0]).toBeUndefined();
		expect(staticData.recurrenceRuleSignatures[0]).toBe('days:5');
	});

	it('clears value and signature when a rule becomes non-recurring', () => {
		const staticData = { recurrenceRules: [21], recurrenceRuleSignatures: ['days:3'] };
		resetStaleRecurrence(staticData, [{ recurrence: { activated: false } }]);
		expect(staticData.recurrenceRules[0]).toBeUndefined();
		expect(staticData.recurrenceRuleSignatures[0]).toBeUndefined();
	});

	it('trims entries left by a previous config with more intervals', () => {
		const staticData = {
			recurrenceRules: [21, 5, 9],
			recurrenceRuleSignatures: ['days:3', 'hours:2', 'weeks:4'],
		};
		resetStaleRecurrence(staticData, [{ recurrence: daysRule }]);
		expect(staticData.recurrenceRules).toEqual([21]);
		expect(staticData.recurrenceRuleSignatures).toEqual(['days:3']);
	});
});