date-generator.ts

/* eslint-disable max-len */
import { isNullOrUndefined, L10n, getDefaultDateObject, getValue, cldrData } from '@syncfusion/ej2-base';
import { MS_PER_DAY, addDays, resetTime, capitalizeFirstWord } from '../schedule/base/util';
import { CalendarUtil, Islamic, Gregorian, CalendarType } from '../common/calendar-util';
import { Timezone } from '../schedule/timezone/timezone';

/**
 * Date Generator from Recurrence Rule
 */

/**
 * Generate Summary from Recurrence Rule
 *
 * @param {string} rule Accepts the Recurrence rule
 * @param {L10n} localeObject Accepts the locale object
 * @param {string} locale Accepts the locale name
 * @param {CalendarType} calendarType Accepts the calendar type
 * @returns {string} Returns the summary string from given recurrence rule
 */
export function generateSummary(rule: string, localeObject: L10n, locale: string, calendarType: CalendarType = 'Gregorian'): string {
    const ruleObject: RecRule = extractObjectFromRule(rule);
    let summary: string = localeObject.getConstant(EVERY) + ' ';
    let cldrObj: string[];
    let cldrObj1: string[];
    const calendarMode: string = calendarType.toLowerCase();
    if (locale === 'en' || locale === 'en-US') {
        const nameSpace1: string = 'months.stand-alone.abbreviated';
        const nameSpace: string = 'days.stand-alone.abbreviated';
        cldrObj1 = <string[]>(getValue(nameSpace1, getDefaultDateObject(calendarMode)));
        cldrObj = <string[]>(getValue(nameSpace, getDefaultDateObject(calendarMode)));
    } else {
        const nameSpace1: string =
            'main.' + locale + '.dates.calendars.' + calendarMode + '.months.stand-alone.abbreviated';
        const nameSpace: string =
            'main.' + locale + '.dates.calendars.' + calendarMode + '.days.stand-alone.abbreviated';
        cldrObj1 =
            <string[]>(getValue(nameSpace1, cldrData));
        cldrObj =
            <string[]>(getValue(nameSpace, cldrData));
    }
    if (ruleObject.interval > 1) {
        summary += ruleObject.interval + ' ';
    }
    switch (ruleObject.freq) {
    case 'DAILY':
        summary += localeObject.getConstant(DAYS);
        break;
    case 'WEEKLY':
        summary += localeObject.getConstant(WEEKS) + ' ' + localeObject.getConstant(ON) + ' ';
        ruleObject.day.forEach((day: string, index: number) => {
            summary += capitalizeFirstWord(<string>getValue(DAYINDEXOBJECT[`${day}`], cldrObj), 'single');
            summary += (((ruleObject.day.length - 1) === index) ? '' : ', ');
        });
        break;
    case 'MONTHLY':
        summary += localeObject.getConstant(MONTHS) + ' ' + localeObject.getConstant(ON) + ' ';
        summary += getMonthSummary(ruleObject, cldrObj, localeObject);
        break;
    case 'YEARLY':
        summary += localeObject.getConstant(YEARS) + ' ' + localeObject.getConstant(ON) + ' ';
        summary += capitalizeFirstWord(<string>getValue((ruleObject.month[0]).toString(), cldrObj1), 'single') + ' ';
        summary += getMonthSummary(ruleObject, cldrObj, localeObject);
        break;
    }
    if (ruleObject.count) {
        summary += ', ' + (ruleObject.count) + ' ' + localeObject.getConstant(TIMES);
    } else if (ruleObject.until) {
        const tempDate: Date = ruleObject.until;
        summary += ', ' + localeObject.getConstant(UNTIL)
            + ' ' + tempDate.getDate()
            + ' ' + capitalizeFirstWord(<string>getValue((tempDate.getMonth() + 1).toString(), cldrObj1), 'single')
            + ' ' + tempDate.getFullYear();
    }
    return summary;
}

/**
 * Generates Month summary
 *
 * @param {RecRule} ruleObject Accepts the recurrence rule object
 * @param {string[]} cldrObj Accepts the collections of month name from calendar
 * @param {L10n} localeObj Accepts the locale object
 * @returns {string} Returns the month summary string from given recurrence rule object
 * @private
 */
function getMonthSummary(ruleObject: RecRule, cldrObj: string[], localeObj: L10n): string {
    let summary: string = '';
    if (ruleObject.monthDay.length) {
        summary += ruleObject.monthDay[0];
    } else if (ruleObject.day) {
        const pos: number = ruleObject.setPosition - 1;
        summary += localeObj.getConstant(WEEKPOS[pos > -1 ? pos : (WEEKPOS.length - 1)])
            + ' ' + capitalizeFirstWord(<string>getValue(DAYINDEXOBJECT[ruleObject.day[0]], cldrObj), 'single');
    }
    return summary;
}

/**
 * Generates the date collections from the given recurrence rule
 *
 * @param {Date} startDate Accepts the rule start date
 * @param {string} rule Accepts the recurrence rule
 * @param {string} excludeDate Accepts the exception dates in string format
 * @param {number} startDayOfWeek Accepts the start day index of week
 * @param {number} maximumCount Accepts the maximum number count to generate date collections
 * @param {Date} viewDate Accepts the current date instead of start date
 * @param {CalendarType} calendarMode Accepts the calendar type
 * @param {string} oldTimezone Accepts the timezone name
 * @param {string} newTimezone Accepts the timezone name
 * @returns {number[]} Returns the collection of dates
 */
export function generate(startDate: Date, rule: string, excludeDate: string, startDayOfWeek: number, maximumCount: number = MAXOCCURRENCE, viewDate: Date = null, calendarMode: CalendarType = 'Gregorian', oldTimezone: string = null, newTimezone: string = null): number[] {
    const ruleObject: RecRule = extractObjectFromRule(rule);
    let cacheDate: Date; calendarUtil = getCalendarUtil(calendarMode);
    const data: number[] = [];
    const modifiedDate: Date = new Date(startDate.getTime());
    tempExcludeDate = [];
    const tempDate: string[] = isNullOrUndefined(excludeDate) ? [] : excludeDate.split(',');
    const tz: Timezone = new Timezone();
    tempDate.forEach((content: string) => {
        let parsedDate: Date = getDateFromRecurrenceDateString(content);
        if (oldTimezone && newTimezone) {
            parsedDate = tz.convert(new Date(parsedDate.getTime()), oldTimezone, newTimezone);
        }
        tempExcludeDate.push(new Date(parsedDate.getTime()).setHours(0, 0, 0, 0));
    });
    ruleObject.recExceptionCount = !isNullOrUndefined(ruleObject.count) ? tempExcludeDate.length : 0;

    if (viewDate && viewDate > startDate && !ruleObject.count) {
        tempViewDate = new Date(new Date(viewDate.getTime()).setHours(0, 0, 0));
    } else {
        tempViewDate = null;
    }
    if (!ruleObject.until && tempViewDate) {
        cacheDate = new Date(tempViewDate.getTime());
        cacheDate.setDate(tempViewDate.getDate() + maximumCount * (ruleObject.interval));
        ruleObject.until = cacheDate;
    }
    if (ruleObject.until && startDate > ruleObject.until) {
        return data;
    }
    maxOccurrence = maximumCount;
    setFirstDayOfWeek(DAYINDEX[parseInt(startDayOfWeek.toString(), 10)]);
    if (ruleObject.until) {
        const end: Date = resetTime(ruleObject.until);
        ruleObject.until = new Date(end.getFullYear(), end.getMonth(), end.getDate(), 23, 59, 59);
    }
    switch (ruleObject.freq) {
    case 'DAILY':
        dailyType(modifiedDate, ruleObject.until, data, ruleObject);
        break;
    case 'WEEKLY':
        weeklyType(modifiedDate, ruleObject.until, data, ruleObject);
        break;
    case 'MONTHLY':
        monthlyType(modifiedDate, ruleObject.until, data, ruleObject);
        break;
    case 'YEARLY':
        yearlyType(modifiedDate, ruleObject.until, data, ruleObject);
    }
    return data;
}

/**
 * Generate date object from given date string
 *
 * @param {string} recDateString Accepts the exception date as string
 * @returns {Date} Returns the date from exception date string
 */
export function getDateFromRecurrenceDateString(recDateString: string): Date {
    return new Date(recDateString.substr(0, 4) +
        '-' + recDateString.substr(4, 2) +
        '-' + recDateString.substr(6, 5) +
        ':' + recDateString.substr(11, 2) +
        ':' + recDateString.substr(13));
}

/**
 * Internal method to handle exclude date
 *
 * @param {number[]} data Accepts the exception date collections
 * @param {number} date Accepts the new exclude date
 * @returns {void}
 * @private
 */
function excludeDateHandler(data: number[], date: number): void {
    const zeroIndex: number = new Date(date).setHours(0, 0, 0, 0);
    if (tempExcludeDate.indexOf(zeroIndex) === -1 && (!tempViewDate || zeroIndex >= tempViewDate.getTime())) {
        data.push(date);
    }
}

/**
 * Internal method for get date count
 *
 * @param {Date} startDate Accepts the date
 * @param {RecRule} ruleObject Accepts the recurrence rule object
 * @returns {number} Returns the number of date count
 * @private
 */
function getDateCount(startDate: Date, ruleObject: RecRule): number {
    let count: number = maxOccurrence;
    if (ruleObject.count) {
        count = ruleObject.count;
    } else if (ruleObject.until) {
        if (ruleObject.freq === 'DAILY' || ruleObject.freq === 'WEEKLY') {
            count = Math.floor((ruleObject.until.getTime() - startDate.getTime()) / MS_PER_DAY) + 1;
        } else if (ruleObject.freq === 'MONTHLY' || ruleObject.freq === 'YEARLY') {
            count = Math.floor(((ruleObject.until.getMonth() + 12 * ruleObject.until.getFullYear()) -
                (startDate.getMonth() + 12 * startDate.getFullYear())) / ruleObject.interval) +
                (ruleObject.day.length > 1 ? (Math.floor((ruleObject.until.getTime() - startDate.getTime()) / MS_PER_DAY) + 1) : 1);
            if (ruleObject.freq === 'YEARLY') {
                count = ruleObject.month.length > 1 ? ((count as number) * ruleObject.month.length) : count;
            }
        }
    }
    return count;
}

/**
 *  Internal method for daily type recurrence rule
 *
 * @param {Date} startDate Accepts the strat date
 * @param {Date} endDate Accepts the end date
 * @param {number[]} data Accepts the collection of dates
 * @param {RecRule} ruleObject Accepts the recurrence rule object
 * @returns {void}
 * @private
 */
function dailyType(startDate: Date, endDate: Date, data: number[], ruleObject: RecRule): void {
    const tempDate: Date = new Date(startDate.getTime());
    const interval: number = ruleObject.interval;
    const expectedCount: number = getDateCount(startDate, ruleObject);
    let state: boolean;
    const expectedDays: string[] = ruleObject.day;
    while (compareDates(tempDate, endDate)) {
        state = true;
        state = validateRules(tempDate, ruleObject);
        if (state && (expectedDays.indexOf(DAYINDEX[tempDate.getDay()]) > -1 || expectedDays.length === 0)) {
            excludeDateHandler(data, tempDate.getTime());
            if (expectedCount && (data.length + ruleObject.recExceptionCount) >= expectedCount) {
                break;
            }
        }
        tempDate.setDate(tempDate.getDate() + interval);
        if (tempDate.getHours() !== startDate.getHours()) {
            tempDate.setHours(startDate.getHours());
        }
    }
}

/**
 * Internal method for weekly type recurrence rule
 *
 * @param {Date} startDate Accepts the strat date
 * @param {Date} endDate Accepts the end date
 * @param {number[]} data Accepts the collection of dates
 * @param {RecRule} ruleObject Accepts the recurrence rule object
 * @returns {void}
 * @private
 */
function weeklyType(startDate: Date, endDate: Date, data: number[], ruleObject: RecRule): void {
    let tempDate: Date = new Date(startDate.getTime());
    if (!ruleObject.day.length) {
        ruleObject.day.push(DAYINDEX[startDate.getDay()]);
    }
    const interval: number = ruleObject.interval;
    const expectedDays: string[] = ruleObject.day;
    const expectedCount: number = getDateCount(startDate, ruleObject);
    let weekState: boolean = true;
    let wkstIndex: number;
    let weekCollection: number[][] = [];
    if (expectedDays.length > 1) {
        if (isNullOrUndefined(ruleObject.wkst) || ruleObject.wkst === '') {
            ruleObject.wkst = dayIndex[0];
        }
        wkstIndex = DAYINDEX.indexOf(ruleObject.wkst);
        while (compareDates(tempDate, endDate)) {
            let startDateDiff: number = DAYINDEX.indexOf(DAYINDEX[tempDate.getDay()]) - wkstIndex;
            startDateDiff = startDateDiff === -1 ? 6 : startDateDiff;
            const weekstartDate: Date = addDays(tempDate, -startDateDiff);
            let weekendDate: Date = addDays(weekstartDate, 6);
            let compareTempDate: Date = new Date(tempDate.getTime());
            weekendDate = resetTime(weekendDate);
            compareTempDate = resetTime(compareTempDate);
            while (weekendDate >= compareTempDate) {
                if (expectedDays.indexOf(DAYINDEX[tempDate.getDay()]) > -1) {
                    weekCollection.push([tempDate.getTime()]);
                }
                if (expectedCount && (data.length + ruleObject.recExceptionCount) >= expectedCount) {
                    break;
                }
                tempDate.setDate(tempDate.getDate() + 1);
                if (tempDate.getHours() !== startDate.getHours()) {
                    tempDate.setHours(startDate.getHours());
                }
                compareTempDate = new Date(tempDate.getTime());
                compareTempDate = resetTime(compareTempDate);
            }
            tempDate.setDate(tempDate.getDate() - 1);
            if (expectedCount && (data.length + ruleObject.recExceptionCount) >= expectedCount) {
                break;
            }
            tempDate.setDate((tempDate.getDate()) + 1 + ((interval - 1) * 7));
            insertDataCollection(weekCollection, weekState, startDate, endDate, data, ruleObject);
            weekCollection = [];
        }
    } else {
        tempDate = getStartDateForWeek(startDate, ruleObject.day);
        while (compareDates(tempDate, endDate)) {
            weekState = validateRules(tempDate, ruleObject);
            if (weekState && (expectedDays.indexOf(DAYINDEX[tempDate.getDay()]) > -1)) {
                excludeDateHandler(data, tempDate.getTime());
            }
            if (expectedCount && (data.length + ruleObject.recExceptionCount) >= expectedCount) {
                break;
            }
            tempDate.setDate(tempDate.getDate() + (interval * 7));
        }
        insertDataCollection(weekCollection, weekState, startDate, endDate, data, ruleObject);
        weekCollection = [];
    }
}

/**
 *  Internal method for monthly type recurrence rule
 *
 * @param {Date} startDate Accepts the strat date
 * @param {Date} endDate Accepts the end date
 * @param {number[]} data Accepts the collection of dates
 * @param {RecRule} ruleObject Accepts the recurrence rule object
 * @returns {void}
 * @private
 */
function monthlyType(startDate: Date, endDate: Date, data: number[], ruleObject: RecRule): void {
    // Set monthday value if BYDAY, BYMONTH and Month day property is not set based on start date
    if (!ruleObject.month.length && !ruleObject.day.length && !ruleObject.monthDay.length) {
        ruleObject.monthDay.push(startDate.getDate());
        if (ruleObject.freq === 'YEARLY') {
            ruleObject.month.push(startDate.getMonth() + 1);
        }
    } else if (ruleObject.month.length > 0 && !ruleObject.day.length && !ruleObject.monthDay.length) {
        ruleObject.monthDay.push(startDate.getDate());
    }
    const ruleType: MonthlyType = validateMonthlyRuleType(ruleObject);
    switch (ruleType) {
    case 'day':
        switch (ruleObject.freq) {
        case 'MONTHLY':
            monthlyDayTypeProcessforMonthFreq(startDate, endDate, data, ruleObject);
            break;
        case 'YEARLY':
            monthlyDayTypeProcess(startDate, endDate, data, ruleObject);
            break;
        }
        break;
    case 'both':
    case 'date':
        switch (ruleObject.freq) {
        case 'MONTHLY':
            monthlyDateTypeProcessforMonthFreq(startDate, endDate, data, ruleObject);
            break;
        case 'YEARLY':
            monthlyDateTypeProcess(startDate, endDate, data, ruleObject);
            break;
        }
        break;
    }
}

/**
 * Internal method for yearly type recurrence rule
 *
 * @param {Date} startDate Accepts the strat date
 * @param {Date} endDate Accepts the end date
 * @param {number[]} data Accepts the collection of dates
 * @param {RecRule} ruleObject Accepts the recurrence rule object
 * @returns {void}
 * @private
 */
function yearlyType(startDate: Date, endDate: Date, data: number[], ruleObject: RecRule): void {
    const typeValue: YearRuleType = checkYearlyType(ruleObject);
    switch (typeValue) {
    case 'MONTH':
        monthlyType(startDate, endDate, data, ruleObject);
        break;
    case 'WEEKNO':
        processWeekNo(startDate, endDate, data, ruleObject);
        break;
    case 'YEARDAY':
        processYearDay(startDate, endDate, data, ruleObject);
        break;
    }
}

/**
 * Internal method for process week no
 *
 * @param {Date} startDate Accepts the strat date
 * @param {Date} endDate Accepts the end date
 * @param {number[]} data Accepts the collection of dates
 * @param {RecRule} ruleObject Accepts the recurrence rule object
 * @returns {void}
 * @private
 */
function processWeekNo(startDate: Date, endDate: Date, data: number[], ruleObject: RecRule): void {
    let stDate: Date = calendarUtil.getYearLastDate(startDate, 0);
    let tempDate: Date;
    const expectedCount: number = getDateCount(startDate, ruleObject);
    let state: boolean;
    let startDay: number;
    let firstWeekSpan: number;
    const weekNos: number[] = ruleObject.weekNo;
    let weekNo: number;
    let maxDate: number;
    let minDate: number;
    let weekCollection: number[][] = [];
    const expectedDays: string[] = ruleObject.day;
    while (compareDates(stDate, endDate)) {
        startDay = dayIndex.indexOf(DAYINDEX[stDate.getDay()]);
        firstWeekSpan = (6 - startDay) + 1;
        for (let index: number = 0; index < weekNos.length; index++) {
            weekNo = weekNos[parseInt(index.toString(), 10)];
            weekNo = (weekNo > 0) ? weekNo : 53 + weekNo + 1;
            maxDate = (weekNo === 1) ? firstWeekSpan : firstWeekSpan + ((weekNo - 1) * 7);
            minDate = (weekNo === 1) ? firstWeekSpan - 7 : firstWeekSpan + ((weekNo - 2) * 7);
            while (minDate < maxDate) {
                tempDate = new Date(stDate.getTime() + (MS_PER_DAY * minDate));
                if (expectedDays.length === 0 || expectedDays.indexOf(DAYINDEX[tempDate.getDay()]) > -1) {
                    if (isNullOrUndefined(ruleObject.setPosition)) {
                        insertDateCollection(state, startDate, endDate, data, ruleObject, tempDate.getTime());
                    } else {
                        weekCollection.push([tempDate.getTime()]);
                    }
                }
                minDate++;
            }
        }
        if (!isNullOrUndefined(ruleObject.setPosition)) {
            insertDatasIntoExistingCollection(weekCollection, state, startDate, endDate, data, ruleObject);
        }
        if (expectedCount && (data.length + ruleObject.recExceptionCount) >= expectedCount) {
            return;
        }
        stDate = calendarUtil.getYearLastDate(tempDate, ruleObject.interval);
        weekCollection = [];
    }
}

/**
 * Internal method for process year day
 *
 * @param {Date} startDate Accepts the strat date
 * @param {Date} endDate Accepts the end date
 * @param {number[]} data Accepts the collection of dates
 * @param {RecRule} ruleObject Accepts the recurrence rule object
 * @returns {void}
 * @private
 */
function processYearDay(startDate: Date, endDate: Date, data: number[], ruleObject: RecRule): void {
    let stDate: Date = calendarUtil.getYearLastDate(startDate, 0);
    let tempDate: Date;
    const expectedCount: number = getDateCount(startDate, ruleObject);
    let state: boolean;
    let dateCollection: number[][] = [];
    let date: number;
    const expectedDays: string[] = ruleObject.day;
    while (compareDates(stDate, endDate)) {
        for (let index: number = 0; index < ruleObject.yearDay.length; index++) {
            date = ruleObject.yearDay[parseInt(index.toString(), 10)];
            tempDate = new Date(stDate.getTime());
            if ((date === calendarUtil.getLeapYearDaysCount() || date === -calendarUtil.getLeapYearDaysCount()) &&
                (!calendarUtil.isLeapYear(calendarUtil.getFullYear(tempDate), 1))) {
                tempDate.setDate(tempDate.getDate() + 1);
                continue;
            }
            tempDate.setDate(tempDate.getDate() + ((date < 0) ?
                calendarUtil.getYearDaysCount(tempDate, 1) + 1 + date : date));
            if (expectedDays.length === 0 || expectedDays.indexOf(DAYINDEX[tempDate.getDay()]) > -1) {
                if (ruleObject.setPosition == null) {
                    insertDateCollection(state, startDate, endDate, data, ruleObject, tempDate.getTime());
                } else {
                    dateCollection.push([tempDate.getTime()]);
                }
            }
        }
        if (!isNullOrUndefined(ruleObject.setPosition)) {
            insertDatasIntoExistingCollection(dateCollection, state, startDate, endDate, data, ruleObject);
        }
        if (expectedCount && (data.length + ruleObject.recExceptionCount) >= expectedCount) {
            return;
        }
        stDate = calendarUtil.getYearLastDate(tempDate, ruleObject.interval);
        dateCollection = [];
    }
}

/**
 * Internal method to check yearly type
 *
 * @param {RecRule} ruleObject Accepts the recurrence rule object
 * @returns {YearRuleType} Returns the Yearly rule type object
 * @private
 */
function checkYearlyType(ruleObject: RecRule): YearRuleType {
    if (ruleObject.yearDay.length) {
        return 'YEARDAY';
    } else if (ruleObject.weekNo.length) {
        return 'WEEKNO';
    }
    return 'MONTH';
}

/**
 * Internal method to initialize recurrence rule variables
 *
 * @param {Date} startDate Accepts the start date
 * @param {RecRule} ruleObject Accepts the recurrence rule object
 * @returns {RuleData} Return the rule data object
 * @private
 */
function initializeRecRuleVariables(startDate: Date, ruleObject: RecRule): RuleData {
    const ruleData: RuleData = {
        monthCollection: [],
        index: 0,
        tempDate: new Date(startDate.getTime()),
        mainDate: new Date(startDate.getTime()),
        expectedCount: getDateCount(startDate, ruleObject),
        monthInit: 0,
        dateCollection: []
    };
    if (ruleObject.month.length) {
        calendarUtil.setMonth(ruleData.tempDate, ruleObject.month[0], ruleData.tempDate.getDate());
    }
    return ruleData;
}

/**
 * Internal method for process monthly date type recurrence rule
 *
 * @param {Date} startDate Accepts the strat date
 * @param {Date} endDate Accepts the end date
 * @param {number[]} data Accepts the collection of dates
 * @param {RecRule} ruleObject Accepts the recurrence rule object
 * @returns {void}
 * @private
 */
function monthlyDateTypeProcess(startDate: Date, endDate: Date, data: number[], ruleObject: RecRule): void {
    if (ruleObject.month.length) {
        monthlyDateTypeProcessforMonthFreq(startDate, endDate, data, ruleObject);
        return;
    }
    const ruleData: RuleData = initializeRecRuleVariables(startDate, ruleObject);
    let currentMonthDate: Date;
    ruleData.tempDate = ruleData.mainDate = calendarUtil.getMonthStartDate(ruleData.tempDate);
    while (compareDates(ruleData.tempDate, endDate)) {
        currentMonthDate = new Date(ruleData.tempDate.getTime());
        while (calendarUtil.isSameYear(currentMonthDate, ruleData.tempDate) &&
            (ruleData.expectedCount && (data.length + ruleObject.recExceptionCount) <= ruleData.expectedCount)) {
            if (ruleObject.month.length === 0 || (ruleObject.month.length > 0
                && !calendarUtil.checkMonth(ruleData.tempDate, ruleObject.month))) {
                processDateCollectionForByMonthDay(ruleObject, ruleData, endDate, false);
                ruleData.beginDate = new Date(ruleData.tempDate.getTime());
                ruleData.monthInit = setNextValidDate(
                    ruleData.tempDate, ruleObject, ruleData.monthInit, ruleData.beginDate);
            } else {
                calendarUtil.setValidDate(ruleData.tempDate, 1, 1);
                ruleData.tempDate = getStartDateForWeek(ruleData.tempDate, ruleObject.day);
                break;
            }
        }
        ruleData.tempDate.setFullYear(currentMonthDate.getFullYear(), currentMonthDate.getMonth(), currentMonthDate.getDate());
        insertDataCollection(ruleData.dateCollection, ruleData.state, startDate, endDate, data, ruleObject);
        if (calendarUtil.isLastMonth(ruleData.tempDate)) {
            calendarUtil.setValidDate(ruleData.tempDate, 1, 1);
            ruleData.tempDate = getStartDateForWeek(ruleData.tempDate, ruleObject.day);
        }
        if (ruleData.expectedCount && (data.length + ruleObject.recExceptionCount) >= ruleData.expectedCount) {
            return;
        }
        ruleData.tempDate.setFullYear(ruleData.tempDate.getFullYear() + ruleObject.interval - 1);
        ruleData.tempDate = getStartDateForWeek(ruleData.tempDate, ruleObject.day);
        ruleData.monthInit = setNextValidDate(
            ruleData.tempDate, ruleObject, ruleData.monthInit, ruleData.beginDate);
        ruleData.dateCollection = [];
    }
}

/**
 * Internal method for process monthly date type with month frequency from recurrence rule
 *
 * @param {Date} startDate Accepts the strat date
 * @param {Date} endDate Accepts the end date
 * @param {number[]} data Accepts the collection of dates
 * @param {RecRule} ruleObject Accepts the recurrence rule object
 * @returns {void}
 * @private
 */
function monthlyDateTypeProcessforMonthFreq(startDate: Date, endDate: Date, data: number[], ruleObject: RecRule): void {
    const ruleData: RuleData = initializeRecRuleVariables(startDate, ruleObject);
    ruleData.tempDate = ruleData.mainDate = calendarUtil.getMonthStartDate(ruleData.tempDate);
    if (((ruleObject.freq === 'MONTHLY' && ruleObject.interval === 12) || (ruleObject.freq === 'YEARLY')) &&
        calendarUtil.getMonthDaysCount(startDate) < ruleObject.monthDay[0]) {
        return;
    }
    while (compareDates(ruleData.tempDate, endDate)) {
        ruleData.beginDate = new Date(ruleData.tempDate.getTime());
        processDateCollectionForByMonthDay(ruleObject, ruleData, endDate, true, startDate, data);
        if (!isNullOrUndefined(ruleObject.setPosition)) {
            insertDatasIntoExistingCollection(ruleData.dateCollection, ruleData.state, startDate, endDate, data, ruleObject);
        }
        if (ruleData.expectedCount && (data.length + ruleObject.recExceptionCount) >= ruleData.expectedCount) {
            return;
        }
        ruleData.monthInit = setNextValidDate(ruleData.tempDate, ruleObject, ruleData.monthInit, ruleData.beginDate);
        ruleData.dateCollection = [];
    }
}

/**
 * To process date collection for Monthly & Yearly based on BYMONTH Day property
 *
 * @param {RecRule} ruleObject Accepts the recurrence rule object
 * @param {RuleData} recRuleVariables Accepts the rule data
 * @param {Date} endDate Accepts the end date
 * @param {boolean} isByMonth Accepts the boolean to validate either month or not
 * @param {Date} startDate Accepts the start date
 * @param {number[]} data Accepts the collection of dates
 * @returns {void}
 * @private
 */
function processDateCollectionForByMonthDay(ruleObject: RecRule, recRuleVariables: RuleData, endDate: Date, isByMonth?: boolean, startDate?: Date, data?: number[]): void {
    for (let index: number = 0; index < ruleObject.monthDay.length; index++) {
        recRuleVariables.date = ruleObject.monthDay[parseInt(index.toString(), 10)];
        recRuleVariables.tempDate = calendarUtil.getMonthStartDate(recRuleVariables.tempDate);
        const maxDate: number = calendarUtil.getMonthDaysCount(recRuleVariables.tempDate);
        recRuleVariables.date = recRuleVariables.date > 0 ? recRuleVariables.date : (maxDate + recRuleVariables.date + 1);
        if (validateProperDate(recRuleVariables.tempDate, recRuleVariables.date, recRuleVariables.mainDate)
            && (recRuleVariables.date > 0)) {
            calendarUtil.setDate(recRuleVariables.tempDate, recRuleVariables.date);
            if (endDate && recRuleVariables.tempDate > endDate) {
                return;
            }
            if (ruleObject.day.length === 0 || ruleObject.day.indexOf(DAYINDEX[recRuleVariables.tempDate.getDay()]) > -1) {
                if (isByMonth && isNullOrUndefined(ruleObject.setPosition) && (recRuleVariables.expectedCount
                    && (data.length + ruleObject.recExceptionCount) < recRuleVariables.expectedCount)) {
                    insertDateCollection(recRuleVariables.state, startDate, endDate, data, ruleObject, recRuleVariables.tempDate.getTime());
                } else {
                    recRuleVariables.dateCollection.push([recRuleVariables.tempDate.getTime()]);
                }
            }
        }
    }
}

/**
 * Internal method to set next valid date
 *
 * @param {Date} tempDate Accepts the date
 * @param {RecRule} ruleObject Accepts the recurrence rule object
 * @param {number} monthInit Accepts the initial month
 * @param {Date} beginDate Accepts the initial date
 * @param {number} interval Accepts the interval duration
 * @returns {number} Returnx the next valid date
 * @private
 */
function setNextValidDate(tempDate: Date, ruleObject: RecRule, monthInit: number, beginDate: Date = null, interval?: number): number {
    let monthData: number = beginDate ? beginDate.getMonth() : 0;
    const startDate: Date = calendarUtil.getMonthStartDate(tempDate);
    interval = isNullOrUndefined(interval) ? ruleObject.interval : interval;
    tempDate.setFullYear(startDate.getFullYear());
    tempDate.setMonth(startDate.getMonth());
    tempDate.setDate(startDate.getDate());
    if (ruleObject.month.length) {
        monthInit++;
        monthInit = monthInit % ruleObject.month.length;
        calendarUtil.setMonth(tempDate, ruleObject.month[parseInt(monthInit.toString(), 10)], 1);
        if (monthInit === 0) {
            calendarUtil.addYears(tempDate, interval, ruleObject.month[0]);
        }
    } else {
        if (beginDate && (beginDate.getFullYear() < tempDate.getFullYear())) {
            monthData = tempDate.getMonth() - 1;
        }
        calendarUtil.setValidDate(tempDate, interval, 1, monthData, beginDate);
    }
    return monthInit;
}

/**
 * To get month collection when BYDAY property having more than one value in list.
 *
 * @param {Date} startDate Accepts the strat date
 * @param {Date} endDate Accepts the end date
 * @param {number[]} data Accepts the collection of dates
 * @param {RecRule} ruleObject Accepts the recurrence rule object
 * @returns {void}
 * @private
 */
function getMonthCollection(startDate: Date, endDate: Date, data: number[], ruleObject: RecRule): void {
    const expectedDays: string[] = ruleObject.day;
    let tempDate: Date = new Date(startDate.getTime());
    tempDate = calendarUtil.getMonthStartDate(tempDate);
    let monthCollection: number[][] = [];
    let dateCollection: number[][] = [];
    let dates: number[] = [];
    let index: number;
    let state: boolean;
    const expectedCount: number = getDateCount(startDate, ruleObject);
    let monthInit: number = 0;
    let beginDate: Date;
    if (ruleObject.month.length) {
        calendarUtil.setMonth(tempDate, ruleObject.month[0], 1);
    }
    tempDate = getStartDateForWeek(tempDate, ruleObject.day);
    while (compareDates(tempDate, endDate)
        && (expectedCount && (data.length + ruleObject.recExceptionCount) < expectedCount)) {
        const currentMonthDate: Date = new Date(tempDate.getTime());
        const isHavingNumber: boolean[] = expectedDays.map((item: string) => HASNUMBER.test(item));
        if (isHavingNumber.indexOf(true) > -1) {
            for (let j: number = 0; j <= expectedDays.length - 1; j++) {
                const expectedDaysArray: string[] = expectedDays[parseInt(j.toString(), 10)].match(SPLITNUMBERANDSTRING);
                const position: number = parseInt(expectedDaysArray[0], 10);
                tempDate = new Date(tempDate.getTime());
                tempDate = calendarUtil.getMonthStartDate(tempDate);
                tempDate = getStartDateForWeek(tempDate, expectedDays);
                currentMonthDate.setFullYear(tempDate.getFullYear(), tempDate.getMonth(), tempDate.getDate());
                while (calendarUtil.isSameYear(currentMonthDate, tempDate) && calendarUtil.isSameMonth(currentMonthDate, tempDate)) {
                    if (expectedDaysArray[expectedDaysArray.length - 1] === DAYINDEX[currentMonthDate.getDay()]) {
                        monthCollection.push([currentMonthDate.getTime()]);
                    }
                    currentMonthDate.setDate(currentMonthDate.getDate() + (1));
                }
                currentMonthDate.setDate(currentMonthDate.getDate() - (1));
                if (expectedDaysArray[0].indexOf('-') > -1) {
                    index = monthCollection.length - (-1 * position);
                } else {
                    index = position - 1;
                }
                index = isNaN(index) ? 0 : index;
                if (monthCollection.length > 0) {
                    if (isNullOrUndefined(ruleObject.setPosition)) {
                        insertDatasIntoExistingCollection(monthCollection, state, startDate, endDate, data, ruleObject, index);
                    } else {
                        dateCollection = [(filterDateCollectionByIndex(monthCollection, index, dates))];
                    }
                }
                if (expectedCount && (data.length + ruleObject.recExceptionCount) >= expectedCount) {
                    return;
                }
                monthCollection = [];
            }
            if (!isNullOrUndefined(ruleObject.setPosition)) {
                insertDateCollectionBasedonBySetPos(dateCollection, state, startDate, endDate, data, ruleObject);
                dates = [];
            }
            monthInit = setNextValidDate(tempDate, ruleObject, monthInit, beginDate);
            tempDate = getStartDateForWeek(tempDate, ruleObject.day);
            monthCollection = [];
        } else {
            let weekCollection: number[] = [];
            const dayCycleData: { [key: string]: number } = processWeekDays(expectedDays);
            currentMonthDate.setFullYear(tempDate.getFullYear(), tempDate.getMonth(), tempDate.getDate());
            const initialDate: Date = new Date(tempDate.getTime());
            beginDate = new Date(tempDate.getTime());
            while (calendarUtil.isSameMonth(initialDate, tempDate)) {
                weekCollection.push(tempDate.getTime());
                if (expectedDays.indexOf(DAYINDEX[tempDate.getDay()]) > -1) {
                    monthCollection.push(weekCollection);
                    weekCollection = [];
                }
                tempDate.setDate(tempDate.getDate()
                    + dayCycleData[DAYINDEX[tempDate.getDay()]]);
            }
            index = ((ruleObject.setPosition < 1) ? (monthCollection.length + ruleObject.setPosition) : ruleObject.setPosition - 1);
            if (isNullOrUndefined(ruleObject.setPosition)) {
                index = 0;
                const datas: number[] = [];
                for (let week: number = 0; week < monthCollection.length; week++) {
                    for (let row: number = 0; row < monthCollection[parseInt(week.toString(), 10)].length; row++) {
                        datas.push(monthCollection[parseInt(week.toString(), 10)][parseInt(row.toString(), 10)]);
                    }
                }
                monthCollection = [datas];
            }
            if (monthCollection.length > 0) {
                insertDatasIntoExistingCollection(monthCollection, state, startDate, endDate, data, ruleObject, index);
            }
            if (expectedCount && (data.length + ruleObject.recExceptionCount) >= expectedCount) {
                return;
            }
            monthInit = setNextValidDate(tempDate, ruleObject, monthInit, beginDate);
            tempDate = getStartDateForWeek(tempDate, ruleObject.day);
            monthCollection = [];
        }
    }
}

/**
 * To process monday day type for FREQ=MONTHLY
 *
 * @param {Date} startDate Accepts the strat date
 * @param {Date} endDate Accepts the end date
 * @param {number[]} data Accepts the collection of dates
 * @param {RecRule} ruleObject Accepts the recurrence rule object
 * @returns {void}
 * @private
 */
function monthlyDayTypeProcessforMonthFreq(startDate: Date, endDate: Date, data: number[], ruleObject: RecRule): void {
    const expectedDays: string[] = ruleObject.day;
    // When BYDAY property having more than 1 value.
    if (expectedDays.length > 1) {
        getMonthCollection(startDate, endDate, data, ruleObject);
        return;
    }
    let tempDate: Date = new Date(startDate.getTime());
    const expectedCount: number = getDateCount(startDate, ruleObject);
    let monthCollection: number[][] = [];
    let beginDate: Date;
    let monthInit: number = 0;
    tempDate = calendarUtil.getMonthStartDate(tempDate);
    if (ruleObject.month.length) {
        calendarUtil.setMonth(tempDate, ruleObject.month[0], 1);
    }
    tempDate = getStartDateForWeek(tempDate, ruleObject.day);
    while (compareDates(tempDate, endDate) && (expectedCount && (data.length + ruleObject.recExceptionCount) < expectedCount)) {
        beginDate = new Date(tempDate.getTime());
        const currentMonthDate: Date = new Date(tempDate.getTime());
        while (calendarUtil.isSameMonth(tempDate, currentMonthDate)) {
            monthCollection.push([currentMonthDate.getTime()]);
            currentMonthDate.setDate(currentMonthDate.getDate() + (7));
        }
        // To filter date collection based on BYDAY Index, then BYSETPOS and to insert datas into existing collection
        insertDateCollectionBasedonIndex(monthCollection, startDate, endDate, data, ruleObject);
        monthInit = setNextValidDate(tempDate, ruleObject, monthInit, beginDate);
        tempDate = getStartDateForWeek(tempDate, ruleObject.day);
        monthCollection = [];
    }
}

/**
 * To process monday day type for FREQ=YEARLY
 *
 * @param {Date} startDate Accepts the strat date
 * @param {Date} endDate Accepts the end date
 * @param {number[]} data Accepts the collection of dates
 * @param {RecRule} ruleObject Accepts the recurrence rule object
 * @returns {void}
 * @private
 */
function monthlyDayTypeProcess(startDate: Date, endDate: Date, data: number[], ruleObject: RecRule): void {
    const expectedDays: string[] = ruleObject.day;
    const isHavingNumber: boolean[] = expectedDays.map((item: string) => HASNUMBER.test(item));
    // If BYDAY property having more than 1 value in list
    if (expectedDays.length > 1 && isHavingNumber.indexOf(true) > -1) {
        processDateCollectionforByDayWithInteger(startDate, endDate, data, ruleObject);
        return;
    } else if (ruleObject.month.length && expectedDays.length === 1 && isHavingNumber.indexOf(true) > -1) {
        monthlyDayTypeProcessforMonthFreq(startDate, endDate, data, ruleObject);
        return;
    }
    let tempDate: Date = new Date(startDate.getTime());
    let currentMonthDate: Date;
    const expectedCount: number = getDateCount(startDate, ruleObject);
    const interval: number = ruleObject.interval;
    let monthCollection: number[][] = [];
    if (ruleObject.month.length) {
        calendarUtil.setMonth(tempDate, ruleObject.month[0], tempDate.getDate());
    }
    // Set the date as start date of the yeear if yearly freq having ByDay property alone
    if (isNullOrUndefined(ruleObject.setPosition) && ruleObject.month.length === 0 && ruleObject.weekNo.length === 0) {
        tempDate.setFullYear(startDate.getFullYear(), 0, 1);
    }
    tempDate = calendarUtil.getMonthStartDate(tempDate);
    tempDate = getStartDateForWeek(tempDate, ruleObject.day);
    while (compareDates(tempDate, endDate)) {
        currentMonthDate = new Date(tempDate.getTime());
        while (calendarUtil.isSameYear(currentMonthDate, tempDate) &&
            (expectedCount && (data.length + ruleObject.recExceptionCount) <= expectedCount)) {
            currentMonthDate = new Date(tempDate.getTime());
            while (calendarUtil.isSameYear(currentMonthDate, tempDate)) {
                if (ruleObject.month.length === 0 || (ruleObject.month.length > 0
                    && !calendarUtil.checkMonth(tempDate, ruleObject.month))) {
                    if (expectedDays.length > 1) {
                        if (calendarUtil.compareMonth(currentMonthDate, tempDate)) {
                            calendarUtil.setValidDate(tempDate, 1, 1);
                            tempDate = getStartDateForWeek(tempDate, ruleObject.day);
                            break;
                        }
                        if (expectedDays.indexOf(DAYINDEX[currentMonthDate.getDay()]) > -1) {
                            monthCollection.push([currentMonthDate.getTime()]);
                        }
                        currentMonthDate.setDate(currentMonthDate.getDate() + (1));
                    } else {
                        // If BYDAY property having 1 value in list
                        if (currentMonthDate.getFullYear() > tempDate.getFullYear()) {
                            calendarUtil.setValidDate(tempDate, 1, 1);
                            tempDate = getStartDateForWeek(tempDate, ruleObject.day);
                            break;
                        }
                        const newstr: string = getDayString(expectedDays[0]);
                        if (DAYINDEX[currentMonthDate.getDay()] === newstr
                            && new Date(currentMonthDate.getFullYear(), currentMonthDate.getMonth(), 0)
                            > new Date(startDate.getFullYear())) {
                            monthCollection.push([currentMonthDate.getTime()]);
                        }
                        currentMonthDate.setDate(currentMonthDate.getDate() + (7));
                    }
                } else {
                    calendarUtil.setValidDate(tempDate, 1, 1);
                    tempDate = getStartDateForWeek(tempDate, ruleObject.day);
                    break;
                }
            }
        }
        tempDate.setFullYear(currentMonthDate.getFullYear(), currentMonthDate.getMonth(), currentMonthDate.getDate());
        // To filter date collection based on BYDAY Index, then BYSETPOS and to insert datas into existing collection
        insertDateCollectionBasedonIndex(monthCollection, startDate, endDate, data, ruleObject);
        if (calendarUtil.isLastMonth(tempDate)) {
            calendarUtil.setValidDate(tempDate, 1, 1);
            tempDate = getStartDateForWeek(tempDate, ruleObject.day);
        }
        tempDate.setFullYear(tempDate.getFullYear() + interval - 1);
        if (expectedCount && (data.length + ruleObject.recExceptionCount) >= expectedCount) {
            return;
        }
        tempDate = getStartDateForWeek(tempDate, ruleObject.day);
        monthCollection = [];
    }
}

/**
 * To process the recurrence rule when BYDAY property having values with integer
 *
 * @param {Date} startDate Accepts the strat date
 * @param {Date} endDate Accepts the end date
 * @param {number[]} data Accepts the collection of dates
 * @param {RecRule} ruleObject Accepts the recurrence rule object
 * @returns {void}
 * @private
 */
function processDateCollectionforByDayWithInteger(startDate: Date, endDate: Date, data: number[], ruleObject: RecRule): void {
    const expectedDays: string[] = ruleObject.day;
    const expectedCount: number = getDateCount(startDate, ruleObject);
    let tempDate: Date = new Date(startDate.getTime());
    const interval: number = ruleObject.interval;
    let monthCollection: number[][] = [];
    let dateCollection: number[][] = [];
    let index: number;
    let state: boolean;
    let monthInit: number = 0;
    let currentMonthDate: Date;
    let currentDate: Date;
    let beginDate: Date;
    tempDate = calendarUtil.getMonthStartDate(tempDate);
    let datas: number[] = [];
    if (ruleObject.month.length) {
        calendarUtil.setMonth(tempDate, ruleObject.month[0], 1);
    }
    tempDate = getStartDateForWeek(tempDate, ruleObject.day);
    while (compareDates(tempDate, endDate)) {
        currentMonthDate = new Date(tempDate.getTime());
        for (let i: number = 0; i <= ruleObject.month.length; i++) {
            for (let j: number = 0; j <= expectedDays.length - 1; j++) {
                tempDate = calendarUtil.getMonthStartDate(tempDate);
                tempDate = getStartDateForWeek(tempDate, ruleObject.day);
                monthCollection = [];
                while (calendarUtil.isSameYear(currentMonthDate, tempDate) &&
                    (expectedCount && (data.length + ruleObject.recExceptionCount) <= expectedCount)) {
                    while (calendarUtil.isSameYear(currentMonthDate, tempDate)) {
                        currentMonthDate = new Date(tempDate.getTime());
                        if (ruleObject.month.length === 0 ||
                            (ruleObject.month.length > 0 && ruleObject.month[parseInt(i.toString(), 10)] === calendarUtil.getMonth(currentMonthDate))) {
                            const expectedDaysArray: string[] = expectedDays[parseInt(j.toString(), 10)].match(SPLITNUMBERANDSTRING);
                            const position: number = parseInt(expectedDaysArray[0], 10);
                            currentDate = new Date(tempDate.getTime());
                            while (calendarUtil.isSameYear(currentDate, tempDate)
                                && calendarUtil.isSameMonth(currentDate, tempDate)) {
                                if (expectedDaysArray[expectedDaysArray.length - 1] === DAYINDEX[currentDate.getDay()]) {
                                    monthCollection.push([currentDate.getTime()]);
                                }
                                currentDate.setDate(currentDate.getDate() + (1));
                            }
                            currentDate.setDate(currentDate.getDate() - (1));
                            if (expectedDaysArray[0].indexOf('-') > -1) {
                                index = monthCollection.length - (-1 * position);
                            } else {
                                index = position - 1;
                            }
                            index = isNaN(index) ? 0 : index;
                        }
                        monthInit = setNextValidDate(tempDate, ruleObject, monthInit, beginDate, 1);
                        tempDate = getStartDateForWeek(tempDate, ruleObject.day);
                    }
                }
                tempDate = j === 0 && currentDate ? new Date(currentDate.getTime()) : new Date(currentMonthDate.getTime());
                if (monthCollection.length > 0) {
                    if (isNullOrUndefined(ruleObject.setPosition)) {
                        insertDatasIntoExistingCollection(monthCollection, state, startDate, endDate, data, ruleObject, index);
                    } else {
                        dateCollection = [(filterDateCollectionByIndex(monthCollection, index, datas))];
                    }
                }
                if (expectedCount && (data.length + ruleObject.recExceptionCount) >= expectedCount) {
                    return;
                }
            }
        }
        if (!isNullOrUndefined(ruleObject.setPosition)) {
            insertDateCollectionBasedonBySetPos(dateCollection, state, startDate, endDate, data, ruleObject);
            datas = [];
        }
        if (calendarUtil.isLastMonth(tempDate)) {
            calendarUtil.setValidDate(tempDate, 1, 1);
            tempDate.setFullYear(tempDate.getFullYear() + interval - 1);
        } else {
            tempDate.setFullYear(tempDate.getFullYear() + interval);
        }
        tempDate = getStartDateForWeek(tempDate, ruleObject.day);
        if (ruleObject.month.length) {
            calendarUtil.setMonth(tempDate, ruleObject.month[0], tempDate.getDate());
        }
    }
}

/**
 * To get recurrence collection if BYSETPOS is null
 *
 * @param {number[]} monthCollection Accepts the month collection dates
 * @param {string[]} expectedDays Accepts the exception dates
 * @returns {RuleData} Returns the rule data object
 * @private
 */
function getRecurrenceCollection(monthCollection: number[][], expectedDays: string[]): RuleData {
    let index: number;
    const recurrenceCollectionObject: RuleData = { monthCollection: [], index: 0 };
    if (expectedDays.length === 1) {
        // To split numeric value from BYDAY property value
        const expectedDaysArrays: string[] = expectedDays[0].match(SPLITNUMBERANDSTRING);
        let arrPosition: number;
        if (expectedDaysArrays.length > 1) {
            arrPosition = parseInt(expectedDaysArrays[0], 10);
            index = ((arrPosition < 1) ? (monthCollection.length + arrPosition) : arrPosition - 1);
        } else {
            index = 0;
            monthCollection = getDateCollectionforBySetPosNull(monthCollection);
        }
    } else {
        index = 0;
        monthCollection = getDateCollectionforBySetPosNull(monthCollection);
    }
    recurrenceCollectionObject.monthCollection = monthCollection;
    recurrenceCollectionObject.index = index;
    return recurrenceCollectionObject;
}

/**
 * Internal method to process the data collections
 *
 * @param {number[]} dateCollection Accepts the date collections
 * @param {boolean} state Accepts the state
 * @param {Date} startDate Accepts the start date
 * @param {Date} endDate Accepts the end date
 * @param {number[]} data Accepts the collection of numbers
 * @param {RecRule} ruleObject Accepts the recurrence rule object
 * @returns {void}
 * @private
 */
function insertDataCollection(dateCollection: number[][], state: boolean, startDate: Date, endDate: Date, data: number[], ruleObject: RecRule): void {
    let index: number = ((ruleObject.setPosition < 1) ?
        (dateCollection.length + ruleObject.setPosition) : ruleObject.setPosition - 1);
    if (isNullOrUndefined(ruleObject.setPosition)) {
        index = 0;
        dateCollection = getDateCollectionforBySetPosNull(dateCollection);
    }
    if (dateCollection.length > 0) {
        insertDatasIntoExistingCollection(dateCollection, state, startDate, endDate, data, ruleObject, index);
    }
}

/**
 * To process month collection if BYSETPOS is null
 *
 * @param {number[]} monthCollection Accepts the month date collections
 * @returns {number[]} Returns the month date collections
 * @private
 */
function getDateCollectionforBySetPosNull(monthCollection: number[][]): number[][] {
    const datas: number[] = [];
    for (let week: number = 0; week < monthCollection.length; week++) {
        for (let row: number = 0; row < monthCollection[parseInt(week.toString(), 10)].length; row++) {
            datas.push(new Date(monthCollection[parseInt(week.toString(), 10)][parseInt(row.toString(), 10)]).getTime());
        }
    }
    monthCollection = datas.length > 0 ? [datas] : [];
    return monthCollection;
}

/**
 * To filter date collection based on BYDAY Index, then BYSETPOS and to insert datas into existing collection
 *
 * @param {number[]} monthCollection Accepts the month date collections
 * @param {Date} startDate Accepts the start date
 * @param {Date} endDate Accepts the end date
 * @param {number[]} data Accepts the date collections
 * @param {RecRule} ruleObject Accepts the recurrence rule object
 * @returns {void}
 * @private
 */
function insertDateCollectionBasedonIndex(monthCollection: number[][], startDate: Date, endDate: Date, data: number[], ruleObject: RecRule): void {
    const expectedDays: string[] = ruleObject.day;
    let state: boolean;
    let datas: number[] = [];
    let dateCollection: number[][] = [];
    const recurrenceCollections: RuleData = getRecurrenceCollection(monthCollection, expectedDays);
    monthCollection = recurrenceCollections.monthCollection;
    const index: number = recurrenceCollections.index;
    if (ruleObject.setPosition != null) {
        dateCollection = [(filterDateCollectionByIndex(monthCollection, index, datas))];
        insertDateCollectionBasedonBySetPos(dateCollection, state, startDate, endDate, data, ruleObject);

    } else {
        if (monthCollection.length > 0) {
            insertDatasIntoExistingCollection(monthCollection, state, startDate, endDate, data, ruleObject, index);
        }
    }
    datas = [];
}

/**
 * To filter date collection when BYDAY property having values with number
 *
 * @param {number[]} monthCollection Accepts the date collections
 * @param {number} index Accepts the index of date collections
 * @param {number[]} datas Accepts the collection of dates
 * @returns {number[]} Returns the collection of dates
 * @private
 */
function filterDateCollectionByIndex(monthCollection: number[][], index: number, datas: number[]): number[] {
    for (let week: number = 0; week < monthCollection[parseInt(index.toString(), 10)].length; week++) {
        datas.push(monthCollection[parseInt(index.toString(), 10)][parseInt(week.toString(), 10)]);
    }
    return datas;
}

/**
 * To insert processed date collection in final array element
 *
 * @param {boolean} state Accepts the state of the recurrence rule
 * @param {Date} startDate Accepts the start date
 * @param {Date} endDate Accepts the end date
 * @param {number[]} data Accepts the collection of date
 * @param {RecRule} ruleObject Accepts the recurrence rule object
 * @param {number} dayData Accepts the date index
 * @returns {void}
 * @private
 */
function insertDateCollection(state: boolean, startDate: Date, endDate: Date, data: number[], ruleObject: RecRule, dayData: number): void {
    const expectedCount: number = getDateCount(startDate, ruleObject);
    const chDate: Date = new Date(dayData);
    state = validateRules(chDate, ruleObject);
    if ((chDate >= startDate) && compareDates(chDate, endDate) && state
        && expectedCount && (data.length + ruleObject.recExceptionCount) < expectedCount) {
        excludeDateHandler(data, dayData);
    }
}

/**
 * Return the last week number of given month and year.
 *
 * @param {number} year Accepts the Year in number format
 * @param {number} startDayOfWeek Accepts the start date
 * @param {number[]} monthCollection Accepts the collection of dates
 * @param {number} week Accepts the week in number format
 * @param {RecRule} ruleObject Accepts the recurrence rule object
 * @returns {number} returns week number
 * @private
 */
function weekCount(year: number, startDayOfWeek: number, monthCollection: number[][], week: number, ruleObject: RecRule): number {
    const firstDayOfWeek: number = startDayOfWeek || 0;
    const firstOfMonth: Date = new Date(year, ruleObject.month[0] - 1, 1);
    const lastOfMonth: Date = new Date(year, ruleObject.month[0], 0);
    const numberOfDaysInMonth: number = lastOfMonth.getDate();
    const firstWeekDay: number = (firstOfMonth.getDay() - firstDayOfWeek + 7) % 7;
    const used: number = firstWeekDay + numberOfDaysInMonth;
    const count: number = Math.ceil(used / 7) - 1;
    const dayData: number = monthCollection[parseInt(week.toString(), 10)][parseInt(count.toString(), 10)];
    const chDate: Date = new Date(dayData);
    const state: boolean = validateRules(chDate, ruleObject);
    return (state) ? count : count - 1;
}

/**
 * To process date collection based on Byset position after process the collection based on BYDAY property value index: EX:BYDAY=1SUm-1SU
 *
 * @param {number[]} monthCollection Accepts the collection of dates
 * @param {boolean} state Accepts the state of the recurrence rule
 * @param {Date} startDate Accepts the start date
 * @param {Date} endDate Accepts the end date
 * @param {number[]} data Accepts the collection of date
 * @param {RecRule} ruleObject Accepts the recurrence rule object
 * @returns {void}
 * @private
 */
function insertDateCollectionBasedonBySetPos
(monthCollection: number[][], state: boolean, startDate: Date, endDate: Date, data: number[], ruleObject: RecRule)
    : void {
    if (monthCollection.length > 0) {
        for (let week: number = 0; week < monthCollection.length; week++) {
            monthCollection[parseInt(week.toString(), 10)].sort();
            const expectedDays: string[] = ruleObject.day;
            const isHavingNumber: boolean[] = expectedDays.map((item: string) => HASNUMBER.test(item));
            const weekIndex: number = (ruleObject.freq === 'YEARLY' && (ruleObject.validRules.indexOf('BYMONTH') > -1) &&
                !(isHavingNumber.indexOf(true) > -1)) ?
                weekCount(new Date(monthCollection[0][0]).getFullYear(), 0, monthCollection, week, ruleObject)
                : (monthCollection[parseInt(week.toString(), 10)].length + ruleObject.setPosition);
            const index: number = ((ruleObject.setPosition < 1) ? weekIndex : ruleObject.setPosition - 1);
            const dayData: number = monthCollection[parseInt(week.toString(), 10)][parseInt(index.toString(), 10)];
            insertDateCollection(state, startDate, endDate, data, ruleObject, dayData);
        }
    }
}

/**
 * To insert datas into existing collection which is processed from previous loop.
 *
 * @param {number[]} monthCollection Accepts the collection of dates
 * @param {boolean} state Accepts the state of the recurrence rule
 * @param {Date} startDate Accepts the start date
 * @param {Date} endDate Accepts the end date
 * @param {number[]} data Accepts the collection of date
 * @param {RecRule} ruleObject Accepts the recurrence rule object
 * @param {number} index Accepts the index value
 * @returns {void}
 * @private
 */
function insertDatasIntoExistingCollection(monthCollection: number[][], state: boolean, startDate: Date, endDate: Date, data: number[], ruleObject: RecRule, index?: number): void {
    if (monthCollection.length > 0) {
        index = !isNullOrUndefined(index) ? index :
            ((ruleObject.setPosition < 1)
                ? (monthCollection.length + ruleObject.setPosition) : ruleObject.setPosition - 1);
        monthCollection[parseInt(index.toString(), 10)].sort();
        for (let week: number = 0; week < monthCollection[parseInt(index.toString(), 10)].length; week++) {
            const dayData: number = monthCollection[parseInt(index.toString(), 10)][parseInt(week.toString(), 10)];
            insertDateCollection(state, startDate, endDate, data, ruleObject, dayData);
        }
    }
}

/**
 * Internal method to compare dates
 *
 * @param {Date} startDate Accepts the start date
 * @param {Date} endDate Accepts the end date
 * @returns {boolean} Returns the result of checking start and end dates
 * @private
 */
function compareDates(startDate: Date, endDate: Date): boolean {
    return endDate ? (startDate <= endDate) : true;
}

/**
 * Internal method to get day string
 *
 * @param {string} expectedDays Accepts the exception date string
 * @returns {string} Returns the valid string
 * @private
 */
function getDayString(expectedDays: string): string {
    // To get BYDAY value without numeric value
    const newstr: string = expectedDays.replace(REMOVENUMBERINSTRING, '');
    return newstr;
}

/**
 * Internal method to check day index
 *
 * @param {number} day Accepts the day index
 * @param {string[]} expectedDays Accepts the exception dates
 * @returns {boolean} Returns the index date
 * @private
 */
function checkDayIndex(day: number, expectedDays: string[]): boolean {
    const sortedExpectedDays: string[] = [];
    expectedDays.forEach((element: string) => {
        const expectedDaysNumberSplit: string[] = element.match(SPLITNUMBERANDSTRING);
        if (expectedDaysNumberSplit.length === 2) {
            sortedExpectedDays.push(expectedDaysNumberSplit[1]);
        } else {
            sortedExpectedDays.push(expectedDaysNumberSplit[0]);
        }
    });
    return (sortedExpectedDays.indexOf(DAYINDEX[parseInt(day.toString(), 10)]) === -1);
}

/**
 * Internal method to get start date of week
 *
 * @param {Date} startDate Accepts the start date
 * @param {string[]} expectedDays Accepts the exception dates
 * @returns {Date} Return the week start date
 * @private
 */
function getStartDateForWeek(startDate: Date, expectedDays: string[]): Date {
    const tempDate: Date = new Date(startDate.getTime());
    let newstr: string;
    if (expectedDays.length > 0) {
        const expectedDaysArr: string[] = [];
        for (let i: number = 0; i <= expectedDays.length - 1; i++) {
            newstr = getDayString(expectedDays[parseInt(i.toString(), 10)]);
            expectedDaysArr.push(newstr);
        }
        if (expectedDaysArr.indexOf(DAYINDEX[tempDate.getDay()]) === -1) {
            do {
                tempDate.setDate(tempDate.getDate() + 1);
            } while (expectedDaysArr.indexOf(DAYINDEX[tempDate.getDay()]) === -1);
        }
    }
    return tempDate;
}

/**
 * Method to generate recurrence rule object from given rule
 *
 * @param {string} rules Accepts the recurrence rule
 * @returns {RecRule} Returns the recurrence rule object
 */
export function extractObjectFromRule(rules: string): RecRule {
    const ruleObject: RecRule = {
        freq: null,
        interval: 1,
        count: null,
        until: null,
        day: [],
        wkst: null,
        month: [],
        weekNo: [],
        monthDay: [],
        yearDay: [],
        setPosition: null,
        validRules: []
    };
    const rulesList: string[] = rules.split(';');
    let splitData: string[] = [];
    let temp: string;
    rulesList.forEach((data: string) => {
        splitData = data.split('=');
        switch (splitData[0]) {
        case 'UNTIL':
            temp = splitData[1];
            ruleObject.until = getDateFromRecurrenceDateString(temp);
            break;
        case 'BYDAY':
            ruleObject.day = splitData[1].split(',');
            ruleObject.validRules.push(splitData[0]);
            break;
        case 'BYMONTHDAY':
            ruleObject.monthDay = splitData[1].split(',').map(Number);
            ruleObject.validRules.push(splitData[0]);
            break;
        case 'BYMONTH':
            ruleObject.month = splitData[1].split(',').map(Number);
            ruleObject.validRules.push(splitData[0]);
            break;
        case 'BYYEARDAY':
            ruleObject.yearDay = splitData[1].split(',').map(Number);
            ruleObject.validRules.push(splitData[0]);
            break;
        case 'BYWEEKNO':
            ruleObject.weekNo = splitData[1].split(',').map(Number);
            ruleObject.validRules.push(splitData[0]);
            break;
        case 'INTERVAL':
            ruleObject.interval = parseInt(splitData[1], 10);
            break;
        case 'COUNT':
            ruleObject.count = parseInt(splitData[1], 10);
            break;
        case 'BYSETPOS':
            ruleObject.setPosition = parseInt(splitData[1], 10) > 4 ? -1 : parseInt(splitData[1], 10);
            break;
        case 'FREQ':
            ruleObject.freq = <FreqType>splitData[1];
            break;
        case 'WKST':
            ruleObject.wkst = splitData[1];
            break;
        }
    });
    if ((ruleObject.freq === 'MONTHLY') && (ruleObject.monthDay.length === 0)) {
        const index: number = ruleObject.validRules.indexOf('BYDAY');
        ruleObject.validRules.splice(index, 1);
    }
    return ruleObject;
}

/**
 * Internal method to validate proper date
 *
 * @param {Date} tempDate Accepts the date value
 * @param {number} data Accepts the data value
 * @param {Date} startDate Accepts the start date
 * @returns {boolean} Returns the result of date validate
 * @private
 */
function validateProperDate(tempDate: Date, data: number, startDate: Date): boolean {
    const maxDate: number = calendarUtil.getMonthDaysCount(tempDate);
    return (data <= maxDate) && (tempDate >= startDate);
}

/**
 * Internal method to process week days
 *
 * @param {string[]} expectedDays Accepts the expection dates
 * @returns {Object} Returns the weekdays object
 * @private
 */
function processWeekDays(expectedDays: string[]): { [key: string]: number } {
    const dayCycle: { [key: string]: number } = {};
    expectedDays.forEach((element: string, index: number) => {
        if (index === expectedDays.length - 1) {
            const startIndex: number = dayIndex.indexOf(element);
            let temp: number = startIndex;
            while (temp % 7 !== dayIndex.indexOf(expectedDays[0])) {
                temp++;
            }
            dayCycle[`${element}`] = temp - startIndex;
        } else {
            dayCycle[`${element}`] = dayIndex.indexOf(expectedDays[(<number>index + 1)]) - dayIndex.indexOf(element);
        }
    });
    return dayCycle;
}

/**
 * Internal method to check date
 *
 * @param {Date} tempDate Accepts the date value
 * @param {number[]} expectedDate Accepts the exception dates
 * @returns {boolean} Returns the boolean value
 * @private
 */
function checkDate(tempDate: Date, expectedDate: number[]): boolean {
    const temp: number[] = expectedDate.slice(0);
    let data: number;
    const maxDate: number = calendarUtil.getMonthDaysCount(tempDate);
    data = temp.shift();
    while (data) {
        if (data < 0) {
            data = <number>data + maxDate + 1;
        }
        if (data === tempDate.getDate()) {
            return false;
        }
        data = temp.shift();
    }
    return true;
}

/**
 * Internal method to check the year value
 *
 * @param {Date} tempDate Accepts the date value
 * @param {number[]} expectedyearDay Accepts the exception dates in year
 * @returns {boolean} Returns the boolean value
 * @private
 */
function checkYear(tempDate: Date, expectedyearDay: number[]): boolean {
    const temp: number[] = expectedyearDay.slice(0);
    let data: number;
    const yearDay: number = getYearDay(tempDate);
    data = temp.shift();
    while (data) {
        if (data < 0) {
            data = <number>data + calendarUtil.getYearDaysCount(tempDate, 0) + 1;
        }
        if (data === yearDay) {
            return false;
        }
        data = temp.shift();
    }
    return true;
}

/**
 * Internal method to get the year day
 *
 * @param {Date} currentDate Accepts the date value
 * @returns {number} Returns the boolean value
 * @private
 */
function getYearDay(currentDate: Date): number {
    if (!startDateCollection[calendarUtil.getFullYear(currentDate)]) {
        startDateCollection[calendarUtil.getFullYear(currentDate)] = calendarUtil.getYearLastDate(currentDate, 0);
    }
    const tempDate: Date = startDateCollection[calendarUtil.getFullYear(currentDate)];
    const diff: number = currentDate.getTime() - tempDate.getTime();
    return Math.ceil(diff / MS_PER_DAY);
}

/**
 * Internal method to validate monthly rule type
 *
 * @param {RecRule} ruleObject Accepts the recurrence rule object
 * @returns {MonthlyType} Returns the monthly type object
 * @private
 */
function validateMonthlyRuleType(ruleObject: RecRule): MonthlyType {
    if (ruleObject.monthDay.length && !ruleObject.day.length) {
        return 'date';
    } else if (!ruleObject.monthDay.length && ruleObject.day.length) {
        return 'day';
    }
    return 'both';
}

/**
 * Internal method to re-order the week days based on first day of week
 *
 * @param {string[]} days Accepts the week days value
 * @returns {void}
 * @private
 */
function rotate(days: string[]): void {
    const data: string = days.shift();
    days.push(data);
}

/**
 * Internal method to set first day of week
 *
 * @param {string} day Accepts the first day string
 * @returns {void}
 * @private
 */
function setFirstDayOfWeek(day: string): void {
    while (dayIndex[0] !== day) {
        rotate(dayIndex);
    }
}

/**
 * Internal method to validate recurrence rule
 *
 * @param {Date} tempDate Accepts the date value
 * @param {RecRule} ruleObject Accepts the recurrence rule object
 * @returns {boolean} Returns the boolean value
 * @private
 */
function validateRules(tempDate: Date, ruleObject: RecRule): boolean {
    let state: boolean = true;
    const expectedDays: string[] = ruleObject.day;
    const expectedMonth: number[] = ruleObject.month;
    const expectedDate: number[] = calendarUtil.getExpectedDays(tempDate, ruleObject.monthDay);
    const expectedyearDay: number[] = ruleObject.yearDay;
    ruleObject.validRules.forEach((rule: string) => {
        switch (rule) {
        case 'BYDAY':
            if (checkDayIndex(tempDate.getDay(), expectedDays)) {
                state = false;
            }
            break;
        case 'BYMONTH':
            if (calendarUtil.checkMonth(tempDate, expectedMonth)) {
                state = false;
            }
            break;
        case 'BYMONTHDAY':
            if (checkDate(tempDate, expectedDate)) {
                state = false;
            }
            break;
        case 'BYYEARDAY':
            if (checkYear(tempDate, expectedyearDay)) {
                state = false;
            }
            break;
        }
    });
    return state;
}

/**
 * Internal method to get calendar util
 *
 * @param {CalendarType} calendarMode Accepts the calendar type object
 * @returns {CalendarUtil} Returns the calendar util object
 * @private
 */
export function getCalendarUtil(calendarMode: CalendarType): CalendarUtil {
    if (calendarMode === 'Islamic') {
        return new Islamic();
    }
    return new Gregorian();
}

const startDateCollection: { [key: string]: Date } = {};

/** @private */
export interface RecRule {
    freq: FreqType;
    interval: number;
    count: number;
    until: Date;
    day: string[];
    wkst: string;
    month: number[];
    weekNo: number[];
    monthDay: number[];
    yearDay: number[];
    setPosition: number;
    validRules: string[];
    recExceptionCount?: number;
}

// Variables which are used for recurrence date generation
interface RuleData {
    monthCollection?: number[][];
    index?: number;
    tempDate?: Date;
    mainDate?: Date;
    expectedCount?: number;
    monthInit?: number;
    date?: number;
    dateCollection?: number[][];
    beginDate?: Date;
    state?: boolean;
}

/** @private */
export type FreqType = 'DAILY' | 'WEEKLY' | 'MONTHLY' | 'YEARLY';
type MonthlyType = 'date' | 'day' | 'both';
type YearRuleType = 'MONTH' | 'WEEKNO' | 'YEARDAY';
let tempExcludeDate: number[];
const dayIndex: string[] = ['SU', 'MO', 'TU', 'WE', 'TH', 'FR', 'SA'];
let maxOccurrence: number;
let tempViewDate: Date;
let calendarUtil: CalendarUtil;
const DAYINDEX: string[] = ['SU', 'MO', 'TU', 'WE', 'TH', 'FR', 'SA'];
const MAXOCCURRENCE: number = 43;
const WEEKPOS: string[] = ['first', 'second', 'third', 'fourth', 'last'];
const TIMES: string = 'summaryTimes';
const ON: string = 'summaryOn';
const EVERY: string = 'every';
const UNTIL: string = 'summaryUntil';
const DAYS: string = 'summaryDay';
const WEEKS: string = 'summaryWeek';
const MONTHS: string = 'summaryMonth';
const YEARS: string = 'summaryYear';
const DAYINDEXOBJECT: { [key: string]: string } = {
    SU: 'sun',
    MO: 'mon',
    TU: 'tue',
    WE: 'wed',
    TH: 'thu',
    FR: 'fri',
    SA: 'sat'
};

// To check string has number
const HASNUMBER: RegExp = /\d/;

// To find the numbers in string
const REMOVENUMBERINSTRING: RegExp = /[^A-Z]+/;

// To split number and string
const SPLITNUMBERANDSTRING: RegExp = /[a-z]+|[^a-z]+/gi;

/**
 * Method to generate string from date
 *
 * @param {Date} date Accepts the date value
 * @returns {string} Returns the string value
 */
export function getRecurrenceStringFromDate(date: Date): string {
    return [date.getUTCFullYear(),
        roundDateValues(date.getUTCMonth() + 1),
        roundDateValues(date.getUTCDate()),
        'T',
        roundDateValues(date.getUTCHours()),
        roundDateValues(date.getUTCMinutes()),
        roundDateValues(date.getUTCSeconds()),
        'Z'].join('');
}

/**
 * Internal method to round the date values
 *
 * @param {string | number} date Accepts the date value in either string or number format
 * @returns {string} Returns the date value in string format
 * @private
 */
function roundDateValues(date: string | number): string {
    return ('0' + date).slice(-2);
}