﻿var editMatchesView = new kendo.View("editmatches-template");
var globalisbulkEventCancel = false;

var matchSchedulerCalendar = function (isDayView) {
    /*-------- Variable Declaration ----------*/
    var common = new Sschedule_commonFunctions();
    var calendar_askForConfimation = 1;
    var calendar_failedMove = 2;
    var calendar_successMove = 3;
    var dataSources = new sSchedule_dataSources_eventDataSource();
    var multiSelectSearchBox = null;
    var treeViewBox = new sSchedule_multiSelectTreeViewSearchBoxUtility();

    var fieldAvailability = new sSchedule_viewModels_checkFieldAvailabilityViewModel();
    var exportMatchesToICalendarl = new sSchedule_viewModels_exportMatchesToICalendarViewModel();

    var dataModels = sSchedule_common_dataModels();
    var matchModel = dataModels.getModel("EditMatches");
    var showConflict = null;
    var addressField = {
        locality: 'long_name',
        administrative_area_level_1: 'short_name',
        postal_code: 'short_name'
    };
    var fieldsList = null;
    /*-------- Variable Declaration ----------*/

    /*----- START : Scheduler Calendar Conflict Grid Configuration ---------------*/
    var matchesGridColumnConfiguration = [
        {
            field: "MatchOrderNo",
            title: "Order(Round)",
            width: "10%",
            template: "#:MatchOrderNo#(#:RoundNumber#)"
        },
        {
            field: "EventName",
            title: "Event Name"
        },
        {
            field: "Date",
            title: "Match Date",
            format: "{0: MM/dd/yyyy [ddd]}",
            width: "12%"
        },
        {
            field: "StartTime",
            title: "Start-End Time",
            format: "{0: HH:mm}",
            width: "14%",
            template: "#:kendo.format('{0:hh:mm tt}', StartTime)#&nbsp;-&nbsp;#:kendo.format('{0:hh:mm tt}', EndTime)#"
        },
        {
            field: "Team1Name",
            title: "Team VS Team",
            template: "#:Team1#&nbsp;<b>VS</b>&nbsp;#:Team2#",
            width: "20%"
        },
        {
            field: "LocationName",
            title: "Locations & Fields",
            width: "20%",
            template: "#:LocationName#&nbsp;/&nbsp;#:FieldName#"
        }
    ];
    /*----- END : Scheduler Calendar Conflict Grid Configuration ---------------*/

    /*----- START : Data Sources ---*/

    var eventNamesDataSource = dataSources.getDsByName(
        "EventNamesTreeViewDs",
        null,
        null,
        function (options, operation) {
            if (operation != 'read') {
                return kendo.stringify(options);
            } else {
                var isCustomEventMatchInclude = calendarViewModel.get("isCustomEventMatchInclude");
                var isPosted = calendarViewModel.get("isPosted");
                var params = {
                    portalId: sSchedule_portalId,
                    programId: -1,
                    divisionId: -1,
                    locationId: -1,
                    eventTypeId: -1,
                    isAscending: true,
                    isCustomEventMatchInclude: isCustomEventMatchInclude,
                    isPosted: isPosted
                };

                return params;
            }
        }, null, function () {
            var selectedEventId = calendarViewModel.get("selectedEventId");
            if (selectedEventId) {
                var eventSelectionBox = $("#multiEventSelectBox").data("kendoMultiSelectTreeViewSearchBox");
                eventSelectionBox.setTheNodeSelected(parseFloat(selectedEventId), "EventID");
                eventSelectionBox._displaySelectedItems();
                calendarViewModel.setSelectedEventListByCheckedNodes();
            }
        });

    var locationDs = new sSchedule_dataSources_locationDataSource();
    var locationsDataSource = locationDs.getDsByName(
        "PortalGroupsLocationTreeListDs",
        function (options, operation) {
            if (operation == "read") {
                var params = {
                    portalId: sSchedule_portalId,
                    isActiveLocationOnly: false,
                    needToIncludeTBDLocation: true
                };

                return params;
            }
        }, function (options) {
            calendarViewModel.hideProgress();
            var lst = calendarViewModel.get("locations");
            lst.splice(0, lst.length);

            var locations = locationsDataSource.data();
            locations.shift();

            for (var i = 0; i < locations.length; i++) {
                lst.push({ LocationID: locations[i].Id, Name: locations[i].Name });
            }

            if (lst.length > 0) {
                calendarViewModel.set("location", lst[0]);
                calendarViewModel.set("locationsWithTBD", lst);
            }

            if (options == null) {
                return;
            }

            if (options.Key == "MSError") {
                dataSource.errorDs();
            }
        }, function (options, operation) {
            var treeView = jQuery('#MultiSelectTreeViewSearchBoxForLocations').data("kendoTreeView");
            if (treeView) {
                treeView.expand(".k-item");
            }
            treeView = jQuery('#multiSelectLocationFieldTreeViewForMassShift').data("kendoTreeView");
            if (treeView) {
                treeView.expand(".k-item");
            }
        });
    var actionDataSource = new kendo.data.DataSource({
        data: [
            { ActionStatus: 0, Name: "None" },
            { ActionStatus: 1, Name: "Canceled" },
            { ActionStatus: 2, Name: "Postponed" },
            { ActionStatus: 3, Name: "Rescheduled" }
        ]
    });
    var fieldsDataSources = new sSchedule_dataSources_fieldsDataSource();
    var fieldsListDs = fieldsDataSources.getDsByName(
        "PortalGroupsFieldsDs",
        function (options, operation) {
            var models = options;
            if (operation == "create" || operation == "update" || operation == "destroy") {
                if (models) {
                    var modelsData = options.models;
                    if (modelsData) {
                        return kendo.stringify(modelsData);
                    }
                }
            } else {
                var params = {
                    masterPortalId: sSchedule_portalId,
                    needToIncludeTBDField: true
                };

                return params;
            }
        }, function () {
            //calendarViewModel.set("field", fieldsListDs.data()[0]);
            var location = calendarViewModel.get("location");
            if (!location) {
                return;
            }

            /*-- Read Call back --*/
            if (!fieldsListDs.data() || fieldsListDs.data().length <= 0) {
                return;
            }

            //filter the field data source  by location
            calendarViewModel.filterFieldsBasedOnAllocatedFields(location.LocationID);

            var lst = calendarViewModel.get("fields");

            //lst.splice(0, 1, { ProgramID: -1, ProgramName: 'Select Program' });
            lst.splice(0, lst.length);

            var fields = fieldsListDs.data();
            for (var i = 0; i < fields.length; i++) {
                lst.push({ FieldID: fields[i].FieldID, Name: fields[i].Name });
            }

            if (lst.length > 0) {
                calendarViewModel.set("field", lst[0]);
            }
            /*-- Read Call back --*/
        });

    var allFieldsDs = fieldsDataSources.getDsByName("AllFieldsDs", function (options, operation) {
        var models = options;
        if (operation == "create" || operation == "update" || operation == "destroy") {
            if (models) {
                var modelsData = options.models;
                if (modelsData) {
                    return kendo.stringify(modelsData);
                }
            }
        } else {
            var params = {
                portalId: masterPortalId,
                needToIncludeTBDLocation: true
            };

            return params;
        }
    }, function (data) {
        var fieldData = allFieldsDs.data();
        var locationData = allLocationsDS.data();
        var filterResourceLocationData = [];
        var filterResourceFieldData = [];
        var scheduleDetails = scheduleData.scheduleDataModel.get("scheduleDetails");
        if (!fieldData) return;
        for (var i = 0; i < fieldData.length; i++) {
            var field = fieldData[i];
            var allocatedFields = scheduleDetails.get("Fields");
            if (allocatedFields != null && allocatedFields.length > 0) {
                $.each(allocatedFields, function (index, item) {
                    if (item.FieldID == field.FieldID) {
                        item.GlobalBlackOutList = jQuery.parseJSON(field.GlobalBlackOut);
                        var fieldBlackout = item.GlobalBlackOutList
                        if (fieldBlackout != null) {
                            $.each(fieldBlackout, function (index1, item1) {
                                item1.DateFrom = kendo.format("{0:d}", kendo.parseDate(item1.DateFrom));
                                item1.DateTo = kendo.format("{0:d}", kendo.parseDate(item1.DateTo));
                                filterResourceFieldData.push(item1);
                            });
                        }
                    }
                    var dt = Enumerable.From(locationData)
                        .Where(function (x) {
                            return x.LocationID == item.LocationID;
                        })
                        .Select(function (x) {
                            return x;
                        }).ToArray();

                    for (var j = 0; j < dt.length; j++) {
                        if (dt[j].GlobalBlackOutList != null) {
                            item.LocationGlobalBlackOutList = dt[j].GlobalBlackOutList;
                            if (item.LocationGlobalBlackOutList != null) {
                                $.each(item.LocationGlobalBlackOutList, function (index1, item1) {
                                    item1.DateFrom = kendo.format("{0:d}", kendo.parseDate(item1.DateFrom));
                                    item1.DateTo = kendo.format("{0:d}", kendo.parseDate(item1.DateTo));
                                    filterResourceLocationData.push(item1);
                                });
                            }
                        }
                    }
                })
            }
        }
    });

    var locationsListDs = locationDs.getDsByName("PortalGroupsLocationsDs", function (options, operation) {
        if (operation == "read") {
            var params = {
                masterPortalId: sSchedule_portalId,
                needToIncludeTBDLocation: true
            };

            return params;
        }
    }, null, function () {
        var location = locationsListDs.data()[0];
        calendarViewModel.set("location", location);
    });

    var allLocationsDS = locationDs.getDsByName(
        "LocationsListDs",
        function (options, operation) {
            if (operation == "read") {
                var params = {
                    portalId: masterPortalId,
                    isActiveLocationOnly: false,
                    needToIncludeTBDLocation: true
                };

                return params;
            }
        });

    var programDivisionTeamDataSource = new sSchedule_dataSources_programDivisionDataSource();
    var programDivisionTeamDs = programDivisionTeamDataSource.getDsByName(
        "ProgramDivisionTreeListDs",
        function (options, operation) {
            if (operation == "read") {
                var params = {
                    portalId: sSchedule_portalId
                };

                return params;
            }
        }, null, function (options, operation) {
            var treeView = jQuery('#multiSelectTreeViewSearchBoxForProgramDivisionTeam').data("kendoTreeView");
            if (treeView) {
                treeView.expand(".k-item");
                treeView.expand(".k-in");
            }
        });

    /*----- END : Data Sources ---*/

    var calendarViewModel = kendo.observable({
        isSavedFromClubLocation: false,
        portal: null,
        associatedPortals: new kendo.data.ObservableArray([]),
        loadAssociatedPortals: function () {
            var childPortalDataSource = new sSchedule_dataSources_childPortalDataSource();
            var associatedPortalsDs = childPortalDataSource.getDsByName(function () {
                return { portalId: $('.masterPortalIdHidden').val() }
            }, function () {
                calendarViewModel.setAssociatedPortal();
            });
            var list = calendarViewModel.associatedPortals;
            if (list.length > 0) {
                calendarViewModel.setAssociatedPortal();
            } else {
                associatedPortalsDs.fetch(function () {
                    var data = associatedPortalsDs.data();
                    var dataLength = data.length;

                    for (var i = 0; i < dataLength; i++) {
                        list.push(data[i]);
                    }
                });
            }
        },
        portalSelectionChanged: function () {
            var portal = calendarViewModel.get("portal");
            if (portal == null) {
                return;
            }

            $('.portalIdHidden').val(portal.PortalID);
            sSchedule_portalId = $('.portalIdHidden').val();
            locationsDataSource.read();
            eventNamesDataSource.read();
            programDivisionTeamDs.read();

            calendarViewModel.set("selectedEventId", -1);
            calendarViewModel.set("selectedEventsList", []);
            calendarViewModel.set("selectedFieldsList", []);
            calendarViewModel.set("selectedTeamsList", []);
            calendarViewModel.loadSchedulerData();
        },
        setAssociatedPortal: function () {
            var associatedPortals = calendarViewModel.associatedPortals;
            var dataLength = associatedPortals.length;

            for (var i = 0; i < dataLength; i++) {
                if (associatedPortals[i].PortalID == sSchedule_portalId) {
                    calendarViewModel.set("portal", associatedPortals[i]);
                    break;
                }
            }
        },
        createChildPortalCombo: function () {
            $("#childPortalDiv").html('');
            var childPortalView = new kendo.View("childPortal-template", { model: calendarViewModel });
            childPortalView.render(("#childPortalDiv"));
        },
        /*----- Other Properties --*/
        isNgbEvent: false,
        isSaveClicked: false,
        location: null,
        field: null,
        isBulkEventCancel: false,
        bulkCancelCalendarMatches: new kendo.data.ObservableArray([]),
        matchActionStatus: null,
        matchActionNote: null,
        locations: new kendo.data.ObservableArray([]),
        locationsWithTBD: new kendo.data.ObservableArray([]),
        fields: new kendo.data.ObservableArray([]),
        currentCalendarView: 'month',
        currentCalendarDate: new Date(),
        isSpecificDateSelected: true,
        isToCheckForDateRange: false,
        savedSiteWideclubsLocation: "",
        savedSiteWideclubsField: "",
        tempSiteWideClubsLocation: "",
        tempSiteWideClubsField: "",
        siteWideEventId: 0,
        selectedEventChanged: function (e) {

        },
        //isCurrentMonthView: false,
        /*----- Other Properties --*/

        /*---- Parameter Properties to send over server -------------*/
        calendarStartDate: new Date(),
        selectedEventsList: [],
        selectedFieldsList: [],
        selectedTeamsList: [],
        AllocatedFieldsByEvent: [],
        DeletedMatches: [],
        /*---- Parameter Properties to send over server -------------*/

        /*----------- Calendar Properties -----------------*/
        conflictsList: [],
        selectedMatch: null,
        selectedMatchStartTime: null,
        selectedMatchEndTime: null,
        weekDayStartTime: null,
        weekDayEndTime: null,
        selectedEventId: -1,
        maxEventsCount: 0,
        isAcceptWithConflict: false,
        saveLinkText: "Save",
        isSelectAllEventsChecked: false,
        isNotesVisible: false,
        /*----------- Calendar Properties -----------------*/

        /*----------- Calendar Resources Data Sources -----------------*/
        roundNumberResources: new kendo.data.ObservableArray([]),
        areasDataSource: new kendo.data.ObservableArray([]),
        /*----------- Calendar Resources Data Sources -----------------*/

        /*----------- Calendar Methos to update view -----------------*/
        setEndHoursAndMinutes: function (day, end, endTime) {
            var endHours = 0;
            var endMins = 0;

            endHours = common.getHoursFromString(endTime);
            endMins = common.getMinutesFromString(endTime);

            end.setHours(endHours, endMins);
        },
        setStartHoursAndMinutes: function (day, start, startTime) {
            //WorkDayStart
            var startHours = 0;
            var startMins = 0;

            startHours = common.getHoursFromString(startTime);
            startMins = common.getMinutesFromString(startTime);

            start.setHours(startHours, startMins);
        },
        loadView: function () {
            calendarViewModel.loadSchedulerData();
            calendarViewModel.loadLocationsAndFields();
            calendarViewModel.loadMultiSelectEventBox();
            calendarViewModel.loadProgramsDivisionsAndTeams();
        },
        setCalanderPosition: function () {
            var divPosition = $('#schedulerDiv').offset();
            var el = $.browser.opera ? $("html") : $("html, body");
            el.animate({ scrollTop: divPosition.top }, 'slow');
        },
        updatePropertiesForCurrentCalendarView: function (viewName, calendarDate) {
            calendarViewModel.set("selectedEventId", -1);
            var scheduler = $("#scheduler").data("kendoScheduler");

            if (!viewName) {
                var schedulerView = scheduler.view();
                viewName = schedulerView.name;
            }

            if (!calendarDate) {
                calendarDate = scheduler.date();
            }

            calendarViewModel.set("calendarStartDate", calendarDate);
        },

        /*----------- Calendar Methos to update view -----------------*/

        /*----------- Calendar Methos to load data sources -----------------*/

        /*-----START: Load Scheduler Data Source with API ---*/

        getParametersForSelectedEventsAndFields: function () {
            var scheduler = jQuery('#scheduler').data("kendoScheduler");
            var selectedEventId = calendarViewModel.get("selectedEventId");
            var calendarDate = kendo.format("{0:d}", calendarViewModel.get("calendarStartDate"));
            var isSpecificDateSelected = calendarViewModel.get("isSpecificDateSelected");
            var currentView = calendarViewModel.get("currentCalendarView");

            if (isSpecificDateSelected == false && (scheduler._model.selectedDate.getMonth() == new Date().getMonth())) {
                calendarDate = kendo.format("{0:d}", new Date());
                scheduler.date(new Date());
            } else {
                calendarDate = kendo.format("{0:d}", calendarViewModel.get("currentCalendarDate"));
            }

            var scheduleEventIds = [];
            //create the calendar request object.
            var selectedEventIdParams = "";
            var isSelectAllEventsChecked = calendarViewModel.get("isSelectAllEventsChecked");
            if (isSelectAllEventsChecked == false) {
                var selectedEvents = calendarViewModel.get("selectedEventsList");
                if (selectedEvents && selectedEvents.length > 0) {
                    for (var i = 0; i < selectedEvents.length; i++) {
                        scheduleEventIds.push(selectedEvents[i]);
                    }
                }

                var eventIdLen = scheduleEventIds.length;
                if (selectedEventId > 0) {
                    selectedEventIdParams = selectedEventId;
                }

                if (eventIdLen > 0) {
                    if (selectedEventIdParams.length > 0) {
                        selectedEventIdParams += ":";
                    }

                    for (var j = 0; j < eventIdLen; j++) {
                        selectedEventIdParams = selectedEventIdParams + scheduleEventIds[j];
                        if (j < eventIdLen - 1) {
                            selectedEventIdParams = selectedEventIdParams + ":";
                        }
                    }
                }
            }

            var selectedFieldParams = "";
            var selectedFieldIdInUrl = calendarViewModel.get("selectedFieldIdInUrl");
            if (selectedFieldIdInUrl > 0) {
                selectedFieldParams = selectedFieldIdInUrl;
            }

            var selectedFieldIds = calendarViewModel.get("selectedFieldsList");
            var fieldIdLen = selectedFieldIds.length;

            if (fieldIdLen > 0) {
                if (selectedFieldParams != "") {
                    selectedFieldParams = selectedFieldParams + ":";
                }

                for (var k = 0; k < fieldIdLen; k++) {
                    selectedFieldParams = selectedFieldParams + selectedFieldIds[k];
                    if (k < fieldIdLen - 1) {
                        selectedFieldParams = selectedFieldParams + ":";
                    }
                }
            }

            var selectedTeamParams = "";
            var selectedTeamIdsInUrl = calendarViewModel.get("selectedTeamIdsInUrl");
            if (selectedTeamIdsInUrl != "" && selectedEventIdParams == "" && selectedFieldParams == "") {

                if (selectedTeamIdsInUrl.indexOf(",") > 0) {
                    var selectedTeamIdList = selectedTeamIdsInUrl.split(",");
                    for (var i = 0; i < selectedTeamIdList.length; i++) {
                        selectedTeamParams = selectedTeamParams + selectedTeamIdList[i];

                        if (i < selectedTeamIdList.length - 1) {
                            selectedTeamParams = selectedTeamParams + ":";
                        }
                    }
                } else {
                    selectedTeamParams = selectedTeamIdsInUrl;
                }
            }

            var selectedTeamIds = calendarViewModel.get("selectedTeamsList");
            var isCheckForAction;
            var checkCelledOrPostponed = $('#chkcancelledorpostponed');
            if (checkCelledOrPostponed != undefined && checkCelledOrPostponed[0].checked == true) {
                isCheckForAction = true;
            }
            else {
                isCheckForAction = false;
            }

            var teamIdLen = selectedTeamIds.length;
            if (teamIdLen > 0) {
                if (selectedTeamParams != "") {
                    selectedTeamParams = selectedTeamParams + ":";
                }

                for (var k = 0; k < teamIdLen; k++) {
                    if (selectedTeamIdsInUrl.indexOf(selectedTeamIds[k]) < 0) {
                        selectedTeamParams = selectedTeamParams + selectedTeamIds[k];
                    }

                    if (k < teamIdLen - 1) {
                        selectedTeamParams = selectedTeamParams + ":";
                    }
                }
            }

            var currentCalendarView = 0;
            if (currentView == 'month') {
                currentCalendarView = 1;
            } else if (currentView == 'day') {
                currentCalendarView = 2;
            } else if (currentView == 'agenda') {
                currentCalendarView = 3;
            }

            var isToCheckForDateRange = calendarViewModel.get("isToCheckForDateRange");
            var isPosted = calendarViewModel.get("isPosted");
            var isCustomEventMatchInclude = calendarViewModel.get("isCustomEventMatchInclude");
            var isBulkEventCancel = calendarViewModel.get("isBulkEventCancel");

            var paramList = {
                portalId: sSchedule_portalId,
                selectedEvents: selectedEventIdParams,
                selectedFields: selectedFieldParams,
                currentDate: calendarDate,
                timeZone: common.getTimezoneName(),
                currentCalendarView: currentCalendarView,
                isToCheckForDateRange: isToCheckForDateRange,
                isPosted: isPosted,
                selectedTeams: selectedTeamParams,
                isCustomEventMatchInclude: isCustomEventMatchInclude,
                isCheckForAction: isCheckForAction,
                isBulkEventCancel: calendarViewModel.get("isBulkEventCancel")
            };

            return paramList;
        },
        loadSchedulerResources: function () {
            calendarViewModel.set("isFilterSelected", false);
            calendarViewModel.set("isNgbEvent", false);
            var scheduler = $("#scheduler").data("kendoScheduler");
            var ds = scheduler.dataSource;

            var calendarData = ds.data();
            var calendarLen = calendarData.length;
            if (calendarLen <= 0) {
                return;
            }

            var smallMatchDate = null;

            for (var i = 0; i < calendarLen; i++) {
                var matchDate = calendarData[i].Date;

                if (!smallMatchDate) {
                    smallMatchDate = matchDate;
                }

                if (calendarData[i].IsNgbEvent) {
                    calendarViewModel.set("isNgbEvent", calendarData[i].IsNgbEvent);
                }

                if (matchDate < smallMatchDate) {
                    smallMatchDate = matchDate;
                }

                var minDate = kendo.toString(smallMatchDate, 'MM/dd/yyyy');
                if (minDate == '01/01/0001') {
                    smallMatchDate = matchDate;
                }
            }

            //set the Round Number Resources here.
            var firstMatch = calendarData[0];
            if (!firstMatch) {
                return;
            }

            var resourcesDataSource = firstMatch.RoundNumberResources;
            scheduler.resources[0].dataSource.data(resourcesDataSource);
            scheduler.options.majorTick = 30;
            //refresh current view to reflect the above change
            scheduler.view(scheduler.view().name);

            //set the allocated fields values from first match here.
            var allocatedFields = firstMatch.AllocatedFieldsByEvent;
            calendarViewModel.set("AllocatedFieldsByEvent", allocatedFields);

            //After load events in calendar, scroll page to first event object
            var currentView = jQuery('.k-scheduler-views').find('.k-state-selected').attr('data-name');
            if (currentView == "day") {
                var container = jQuery('.k-scheduler-content');
                var Timer = jQuery('.k-scheduler-times');
                $(container).scroll(function () {
                    Timer.scrollTop($(container).scrollTop());
                });

                var firstEvent = jQuery('.k-event').first();
                var scrollToppx = jQuery(firstEvent).offset().top - jQuery(container).offset().top;
                container.animate({ scrollTop: scrollToppx }, 'slow');

                var sch = jQuery('#schedulerDiv');
                window.scrollTo(0, jQuery(sch).offset().top);
            }

            var dayViewLink = jQuery('.k-scheduler-views').find('li[data-name=day]');
            var agendaViewLink = jQuery('.k-scheduler-views').find('li[data-name=agenda]');

            dayViewLink.unbind('click');
            agendaViewLink.unbind('click');

            jQuery(dayViewLink).add(agendaViewLink).click(function () {
                var currentCalendarView = calendarViewModel.get("currentCalendarView");
                if (currentCalendarView == 'month') {
                    calendarViewModel.set("isSpecificDateSelected", false);
                }
            });
        },
        loadSchedulerForUsers: function () {
            var roundNumberResources = calendarViewModel.get("roundNumberResources");
            var areas = calendarViewModel.get("areasDataSource");
            var serviceRootUrl = common.getServiceRootUrl();

            var scheduler = $("#scheduler").kendoScheduler({

                width: 1080,
                height: 960,
                dataSource: {
                    batch: true,
                    autoSync: false,
                    transport: {
                        read: {
                            url: serviceRootUrl + "Calendar/GetMatches",
                            type: "GET",
                            contentType: "application/json",
                            dataType: "json",
                            complete: function (jqXHR, textStatus) {
                                calendarViewModel.hideProgress();
                                calendarViewModel.loadSchedulerResources();
                            },
                        },
                        create: false,
                        update: false,
                        destroy: false,
                        parameterMap: function (options, operation) {
                            if (operation == "read") {
                                var paramList = calendarViewModel.getParametersForSelectedEventsAndFields();

                                return paramList;
                            }
                        },
                    },
                    schema: {
                        model: {
                            id: "TaskId",
                            fields: {
                                TaskId: { type: "number", field: "MatchID" },
                                EventName: { type: "string", field: "EventName" },
                                title: { field: "Title", defaultValue: "No title", validation: { required: true } },
                                Date: { type: "date", field: "Date" },
                                start: { type: "date", field: "Start" },
                                end: { type: "date", field: "End" },
                                MatchDate: { type: "date", field: "MatchDate" },
                                StartTime: { type: "string", field: "StartTime" },
                                EndTime: { type: "string", field: "EndTime" },
                                description: { field: "Description" },
                                AreaId: { nullable: true },
                                AttendeeTypes: { defaultValue: 1 },
                                RoundNumber: { type: "number", field: "RoundNumber" },
                                GameIntervalHours: { type: "number", field: "GameIntervalHours" },
                                GameIntervalMins: { type: "number", field: "GameIntervalMins" },
                                HomeTeamID: { type: "number", field: "HomeTeamID" },
                                AwayTeamID: { type: "number", field: "AwayTeamID" },
                                Team1Name: { type: "string", field: "Team1Name" },
                                Team2Name: { type: "string", field: "Team2Name" },
                                Team1Type: { type: "number", field: "Team1Type" },
                                Team2Type: { type: "number", field: "Team2Type" },
                                MatchOrderNo: { type: "number" },
                                IsEventEdited: { type: "bool", field: "IsEventEdited" },
                                EventDate: { type: "date", field: "EventDate" },
                                IsEditDisabled: { type: "bool" },
                                IsSwapOn: { type: "bool", field: "IsSwapOn" },
                                IsSwapStarted: { type: "bool" },
                                IsMassShiftOn: { type: "bool", field: "IsMassShiftOn" },
                                IsMatchSelectedForMassShift: { type: "bool" },
                                LocationName: { type: "string" },
                                FieldName: { type: "string" },
                                isAllDay: { type: "boolean", field: "IsAllDay" },
                                IsAwayTeamDisplayFirst: { type: "boolean", field: "IsAwayTeamDisplayFirst" },
                                IsNgbEvent: { type: "boolean", defaultValue: false }
                            }
                        }
                    },
                },
                eventTemplate: $("#event-noneditable-template").html(),
                allDayEventTemplate: $("#event-noneditable-template").html(),
                editable: {
                    create: false,
                    destroy: false,
                    resize: false,
                    update: false,
                    move: false
                },
                views: [
                    "month",
                    {

                        type: "day",
                        dateHeaderTemplate: "<span class='k-link k-nav-day'>#=kendo.toString(date, 'dddd M/dd')#</span>"
                    },
                    "agenda"
                ],

                resources: [
                    {
                        field: "EventRoundNumber",
                        name: "Round",
                        dataTextField: "Text",
                        dataValueField: "TextValue",
                        dataColorField: "Color",
                        dataSource: roundNumberResources,
                        title: "Round"
                    },
                    {
                        field: "AttendeeTypes",
                        dataSource: [
                            { text: "Match", value: 1, color: "#07d9f9" },
                            { text: "Blackout", value: 2, color: "#a39c9c" },
                            { text: "Availibility", value: 4, color: "#f49c18" }
                        ],
                        title: "attendeeTypes"
                    },
                    {
                        field: "AreaId",
                        name: "area",
                        dataTextField: "Text",
                        dataValueField: "Value",
                        dataColorField: "Color",
                        dataSource: areas,
                        title: "location"
                    }
                ],

                dataBound: function () {
                    if (isTouchDevice()) {
                        var $info = jQuery(".tipInfo, .tooltip", document.body).not(".converted");
                        $info.addClass("converted").tipTip({ activation: "click", defaultPosition: "top", maxWidth: "420px" });
                    } else {
                        var $info = jQuery(".tipInfo, .tooltip", document.body).not(".converted");
                        $info.addClass("converted").tipTip({ defaultPosition: "top", maxWidth: "420px" });
                    }
                },
                navigate: function (e) {
                    var view = e.view;
                    calendarViewModel.set("isToCheckForDateRange", true);
                    var currentCalendarView = calendarViewModel.get("currentCalendarView");

                    if (currentCalendarView == view) {
                        if (view == 'day' || view == 'agenda') {
                            calendarViewModel.set("isSpecificDateSelected", true);
                        }
                    }

                    if (view == 'agenda') {
                        calendarViewModel.set("isAgendaViewOn", true);
                    } else {
                        calendarViewModel.set("isAgendaViewOn", false);
                    }

                    //Here check if there are some changes the display confirmation if to navigate or not
                    calendarViewModel.set("currentCalendarView", view);
                    calendarViewModel.set("currentCalendarDate", e.date);
                    if (view == 'month') {
                        calendarViewModel.set("isSpecificDateSelected", true);
                    }
                    calendarViewModel.reloadTheCalendarData(e);
                }
            });
        },

        loadSchedulerForBulkEventCancel: function (schedulerSelectedDate) {
            var roundNumberResources = calendarViewModel.get("roundNumberResources");
            var areas = calendarViewModel.get("areasDataSource");
            var serviceRootUrl = common.getServiceRootUrl();

            var scheduler = $("#scheduler").kendoScheduler({
                date: new Date(schedulerSelectedDate),
                width: 1080,
                height: 960,
                dataSource: {
                    batch: true,
                    autoSync: false,
                    transport: {
                        read: {
                            url: serviceRootUrl + "Calendar/GetMatches",
                            type: "GET",
                            contentType: "application/json",
                            dataType: "json",
                            complete: function (jqXHR, textStatus) {
                                calendarViewModel.hideProgress();
                                calendarViewModel.loadSchedulerResources();
                            },
                        },
                        create: false,
                        update: false,
                        destroy: false,
                        parameterMap: function (options, operation) {
                            if (operation == "read") {
                                var paramList = calendarViewModel.getParametersForSelectedEventsAndFields();

                                return paramList;
                            }
                        },
                    },
                    schema: {
                        model: {
                            id: "TaskId",
                            fields: {
                                TaskId: { type: "number", field: "MatchID" },
                                EventName: { type: "string", field: "EventName" },
                                title: { field: "Title", defaultValue: "No title", validation: { required: true } },
                                Date: { type: "date", field: "Date" },
                                start: { type: "date", field: "Start" },
                                end: { type: "date", field: "End" },
                                MatchDate: { type: "date", field: "MatchDate" },
                                StartTime: { type: "string", field: "StartTime" },
                                EndTime: { type: "string", field: "EndTime" },
                                description: { field: "Description" },
                                AreaId: { nullable: true },
                                AttendeeTypes: { defaultValue: 1 },
                                RoundNumber: { type: "number", field: "RoundNumber" },
                                GameIntervalHours: { type: "number", field: "GameIntervalHours" },
                                GameIntervalMins: { type: "number", field: "GameIntervalMins" },
                                HomeTeamID: { type: "number", field: "HomeTeamID" },
                                AwayTeamID: { type: "number", field: "AwayTeamID" },
                                Team1Name: { type: "string", field: "Team1Name" },
                                Team2Name: { type: "string", field: "Team2Name" },
                                Team1Type: { type: "number", field: "Team1Type" },
                                Team2Type: { type: "number", field: "Team2Type" },
                                MatchOrderNo: { type: "number" },
                                IsEventEdited: { type: "bool", field: "IsEventEdited" },
                                EventDate: { type: "date", field: "EventDate" },
                                IsEditDisabled: { type: "bool" },
                                IsSwapOn: { type: "bool", field: "IsSwapOn" },
                                IsSwapStarted: { type: "bool" },
                                IsMassShiftOn: { type: "bool", field: "IsMassShiftOn" },
                                IsMatchSelectedForMassShift: { type: "bool" },
                                LocationName: { type: "string" },
                                FieldName: { type: "string" },
                                isAllDay: { type: "boolean", field: "IsAllDay" },
                                IsAwayTeamDisplayFirst: { type: "boolean", field: "IsAwayTeamDisplayFirst" },
                                IsNgbEvent: { type: "boolean", defaultValue: false }
                            }
                        }
                    },
                },
                eventTemplate: $("#event-noneditable-template").html(),
                allDayEventTemplate: $("#event-noneditable-template").html(),
                editable: {
                    create: false,
                    destroy: false,
                    resize: false,
                    update: false,
                    move: false
                },
                views: [
                    "month",
                    {
                        type: "day",
                        dateHeaderTemplate: "<span class='k-link k-nav-day'>#=kendo.toString(date, 'dddd M/dd')#</span>"
                    },
                    "agenda"
                ],
                resources: [
                    {
                        field: "EventRoundNumber",
                        name: "Round",
                        dataTextField: "Text",
                        dataValueField: "TextValue",
                        dataColorField: "Color",
                        dataSource: roundNumberResources,
                        title: "Round"
                    },
                    {
                        field: "AttendeeTypes",
                        dataSource: [
                            { text: "Match", value: 1, color: "#07d9f9" },
                            { text: "Blackout", value: 2, color: "#a39c9c" },
                            { text: "Availibility", value: 4, color: "#f49c18" },
                        ],
                        title: "attendeeTypes"
                    },
                    {
                        field: "AreaId",
                        name: "area",
                        dataTextField: "Text",
                        dataValueField: "Value",
                        dataColorField: "Color",
                        dataSource: areas,
                        title: "location"
                    }
                ],
                dataBound: function () {
                    tooltip("#app");
                    var scheduler = $("#scheduler").data("kendoScheduler");
                    var events = scheduler.dataSource.view();
                    for (var i = 0; i < events.length; i++) {
                        if (events[i].RunningMatchCount > 0 || events[i].IsCustomEventMatch == true || events[i].ActionStatus == 1) {
                            var element = scheduler.element.find("[data-uid='" + events[i].uid + "']");
                            if (element) {
                                element.addClass("greyed-out-event");
                            }
                        }
                    }
                },
                navigate: function (e) {
                    var view = e.view;
                    calendarViewModel.set("isToCheckForDateRange", true);
                    var currentCalendarView = calendarViewModel.get("currentCalendarView");

                    if (currentCalendarView == view) {
                        if (view == 'day' || view == 'agenda') {
                            calendarViewModel.set("isSpecificDateSelected", true);
                        }
                    }

                    if (view == 'agenda') {
                        calendarViewModel.set("isAgendaViewOn", true);
                    } else {
                        calendarViewModel.set("isAgendaViewOn", false);
                    }

                    // Here check if there are some changes the display confirmation if to navigate or not
                    calendarViewModel.set("currentCalendarView", view);
                    calendarViewModel.set("currentCalendarDate", e.date);
                    if (view == 'month') {
                        calendarViewModel.set("isSpecificDateSelected", true);
                    }

                    calendarViewModel.bulkCancelCalendarMatches = new kendo.data.ObservableArray([]);
                    $('.bulkcancelnotes').val("");

                    if (calendarViewModel.bulkCancelCalendarMatches.length == 0) {
                        btnNextForCancelEvents.setAttribute("disabled", "true");
                        btnNextForCancelEvents.style.pointerEvents = "none";
                    }
                    calendarViewModel.reloadTheCalendarData(e);
                }
            });
        },
        loadSchedulerDataSourceUsingApiCall: function () {
            var roundNumberResources = calendarViewModel.get("roundNumberResources");
            var areas = calendarViewModel.get("areasDataSource");
            var serviceRootUrl = common.getServiceRootUrl();

            var scheduler = $("#scheduler").kendoScheduler({
                width: 1080,
                height: 960,
                dataSource: {
                    batch: true,
                    autoSync: false,
                    transport: {
                        read: {
                            url: serviceRootUrl + "Calendar/GetMatches",
                            type: "GET",
                            contentType: "application/json",
                            dataType: "json",
                            complete: function (jqXHR, textStatus) {
                                calendarViewModel.hideProgress();
                                calendarViewModel.loadSchedulerResources();
                                calendarViewModel.updateTheDataSourceFromSwappingArray();
                                var isSwapOn = calendarViewModel.get("swapModeEnabled");
                                if (isSwapOn == true) {
                                    calendarViewModel.resetEditModeForEventMatches(true);
                                }
                            },
                        },
                        create: false,
                        update: {
                            url: serviceRootUrl + "Calendar/SaveMatch",
                            type: "POST",
                            contentType: "application/json",
                            dataType: "json",
                        },
                        destroy: false,
                        parameterMap: function (options, operation) {
                            if (operation == "read") {
                                var paramList = calendarViewModel.getParametersForSelectedEventsAndFields();

                                return paramList;
                            }
                        },
                    },
                    schema: {
                        model: {
                            id: "TaskId",
                            fields: {
                                TaskId: { type: "number", field: "MatchID" },
                                EventID: { type: "number", field: "EventID" },
                                EventName: { type: "string", field: "EventName" },
                                title: { field: "Title", defaultValue: "No title", validation: { required: true } },
                                Date: { type: "date", field: "Date" },
                                start: { type: "date", field: "Start" },
                                end: { type: "date", field: "End" },
                                MatchDate: { type: "date", field: "MatchDate" },
                                StartTime: { type: "string", field: "StartTime" },
                                EndTime: { type: "string", field: "EndTime" },
                                description: { field: "Description" },
                                AreaId: { nullable: true },
                                AttendeeTypes: { defaultValue: 1 },
                                RoundNumber: { type: "number", field: "RoundNumber" },
                                GameIntervalHours: { type: "number", field: "GameIntervalHours" },
                                GameIntervalMins: { type: "number", field: "GameIntervalMins" },
                                HomeTeamID: { type: "number", field: "HomeTeamID" },
                                AwayTeamID: { type: "number", field: "AwayTeamID" },
                                Team1Name: { type: "string", field: "Team1Name" },
                                Team2Name: { type: "string", field: "Team2Name" },
                                MatchOrderNo: { type: "number" },
                                IsEventEdited: { type: "bool", field: "IsEventEdited" },
                                EventDate: { type: "date", field: "EventDate" },
                                IsMassShiftOn: { type: "bool", field: "IsMassShiftOn" },
                                IsMatchSelectedForMassShift: { type: "bool", field: "IsMatchSelectedForMassShift", defaultValue: true },
                                isAllDay: { type: "boolean", field: "IsAllDay" }, //For AllDay  Slot in week view
                                IsAwayTeamDisplayFirst: { type: "boolean", field: "IsAwayTeamDisplayFirst" },
                                ActionStatus: { type: "number", field: "ActionStatus" },
                                IsMatchStatusCanceled: { type: "boolean", defaultValue: false },
                                IsNgbEvent: { type: "boolean", defaultValue: false }
                            }
                        }
                    },
                },
                eventTemplate: $("#event-template").html(),
                allDayEventTemplate: $("#event-template").html(),
                editable: {
                    create: false,
                    destroy: true,
                    resize: false,
                    update: true,
                    template: $("#match-edit-popup-template").html()
                },
                views: [
                    "month",
                    {
                        type: "day",
                        dateHeaderTemplate: "<span class='k-link k-nav-day'>#=kendo.toString(date, 'dddd M/dd')#</span>"
                    },
                    "agenda"
                ],
                resources: [
                    {
                        field: "EventRoundNumber",
                        name: "Round",
                        dataTextField: "Text",
                        dataValueField: "TextValue",
                        dataColorField: "Color",
                        dataSource: roundNumberResources,
                        title: "Round"
                    },
                    {
                        field: "AttendeeTypes",
                        dataSource: [
                            { text: "Match", value: 1, color: "#07d9f9" },
                            { text: "Blackout", value: 2, color: "#a39c9c" },
                            { text: "Availibility", value: 4, color: "#f49c18" }
                        ],
                        title: "attendeeTypes"
                    },
                    {
                        field: "AreaId",
                        name: "area",
                        dataTextField: "Text",
                        dataValueField: "Value",
                        dataColorField: "Color",
                        dataSource: areas,
                        title: "location"
                    }
                ],
                navigate: function (e) {
                    calendarViewModel.set("isMassShiftStarted", false);

                    var view = e.view;
                    calendarViewModel.set("isToCheckForDateRange", true);
                    var currentCalendarView = calendarViewModel.get("currentCalendarView");

                    if (currentCalendarView == view) {
                        if (view == 'day' || view == 'agenda') {
                            calendarViewModel.set("isSpecificDateSelected", true);
                        }
                    }

                    calendarViewModel.set("currentCalendarView", view);
                    calendarViewModel.set("currentCalendarDate", e.date);
                    if (view == 'month') {
                        calendarViewModel.set("isSpecificDateSelected", true);
                    }

                    $(".hdnSelectedDate").val(kendo.format("{0:d}", new Date()));

                    if (view == 'day') {
                        calendarViewModel.set("isMassShiftOn", true);

                        calendarViewModel.set("massShiftLinkText", "Start Mass Shift");
                        $(".hdnSelectedDate").val(e.date);
                    } else {
                        calendarViewModel.set("isMassShiftOn", false);
                    }

                    if (view == 'agenda') {
                        calendarViewModel.set("isAgendaViewOn", true);
                        setTimeout(function () {
                            $(".k-scheduler-agendaview .k-task").each(function () {
                                $(this).attr("style", "height: " + ($(this).parent().height() + 12) + ";");
                            });
                        }, 1000);
                    } else {
                        calendarViewModel.set("isAgendaViewOn", false);
                    }

                    var conflictData = calendarViewModel.get("conflictedMatches");
                    var isSwapOn = calendarViewModel.get("swapModeEnabled");

                    if (isSwapOn == false) {
                        var calendarMatches = calendarViewModel.getChangedMatches();
                        if (calendarMatches && calendarMatches.length > 0) {
                            if (confirm("You have made some changes in match details. Do you want to ignore them?")) {
                                calendarViewModel.reloadTheCalendarData(e);
                                $("#btnsaveScheduleData").removeClass("active");
                            } else {
                                e.preventDefault();
                                calendarViewModel.set("conflictedMatches", conflictData);
                            }
                        } else {
                            calendarViewModel.reloadTheCalendarData(e);
                        }
                    } else {
                        calendarViewModel.reloadTheCalendarData(e);
                    }
                },
                edit: function (e) {
                    if (e.event.IsNgbEvent) {
                        e.preventDefault();

                        return;
                    }

                    if (e.event.Team1Type == TeamType.PortalTeam && e.event.Team2Type == TeamType.PortalTeam) {
                        calendarViewModel.showSiteWideEventPopup(e);
                        e.preventDefault();

                        return;
                    }

                    if (e.event.IsCustomEventMatch && e.event.EventTypeID == ScheduleType.Other) {
                        e.preventDefault();

                        return;
                    }

                    if (e.event.IsHideEditOptions == true) {
                        common.showMessage("You are not allowed to edit another portal’s game.", null, true);
                        e.preventDefault();

                        return;
                    }

                    calendarViewModel.disableEditModeForSwap(e);

                    //find the edit popup and bind the locations list
                    calendarViewModel.set("selectedMatch", {});
                    calendarViewModel.set("selectedMatch", e.event);
                    calendarViewModel.selectedMatch.set("IsNoteVisible", e.event.ActionStatus > 0);
                    calendarViewModel.selectedMatch.set("IsMatchStatusCanceled", e.event.ActionStatus == 1);

                    //set the minimum date of the match date.
                    var matchDateDiv = e.container.find("#matchDate");
                    var eventDate = e.event.EventDate;

                    var matchDateDatePicker = $(matchDateDiv).data("kendoDatePicker");
                    if (matchDateDatePicker) {
                        matchDateDatePicker.min(eventDate);
                    }

                    var editForm = e.container.find("#editMatchTable");

                    $(".k-widget.k-window.bsbSkin").addClass("scom tournament-popup gray-popup");
                    $(".k-popup-edit-form.k-scheduler-edit-form").css("padding-top", "0");
                    $(".k-popup-edit-form.k-scheduler-edit-form").addClass("bsb-tournament");

                    $(editForm).kendoValidator({
                        validateOnBlur: true,
                        rules: {
                            ruleMinimumDate: function (input) {
                                if (e.event.IsCustomEventMatch) {
                                    return true;
                                }

                                if (input.is("[name=MatchDate]")) {
                                    var matchDate = kendo.parseDate(kendo.format('{0:d}', input.val()));
                                    eventDate = kendo.parseDate(kendo.format('{0:d}', eventDate));
                                    if (matchDate < eventDate) {
                                        return false;
                                    } else {
                                        return true;
                                    }
                                }

                                return true;
                            },
                            ruleValidStartTime: function (input) {
                                if (input.is("[name=start]")) {
                                    var startTime = parseInt(kendo.toString(kendo.parseDate(input.val()), 'mm'));
                                    if (common.isValidMinute(startTime)) {
                                        return true;
                                    } else {
                                        return false;
                                    }
                                }

                                return true;
                            },
                            ruleValidEndTime: function (input) {
                                if (input.is("[name=end]")) {
                                    var endTime = parseInt(kendo.toString(kendo.parseDate(input.val()), 'mm'));
                                    if (common.isValidMinute(endTime)) {
                                        return true;
                                    } else {
                                        return false;
                                    }
                                }

                                return true;
                            }
                        },
                        messages: {
                            ruleMinimumDate: "Match date should be less than Event start date.",
                            ruleValidStartTime: "Only 00,15,30,45 minutes are allowed time.",
                            ruleValidEndTime: "Only 00,15,30,45 minutes are allowed time."
                        }
                    }).data("kendoValidator");

                    //Set the title of window to event name.
                    e.container.kendoWindow("title", e.event.EventName);
                    if (e.event.EventTypeID == ScheduleType.Tournament) {
                        $(".k-edit-form-container .k-scheduler-delete").hide();
                    } else {
                        $(".k-edit-form-container .k-scheduler-delete").show();
                    }

                    $(".k-edit-form-container .k-scheduler-delete").addClass("bsb-btn btn-blue btn-default  btn-tournament ");
                    $(".k-edit-form-container .k-scheduler-update").addClass("bsb-btn btn-default btn-tournament");
                    $(".k-edit-form-container .k-scheduler-cancel").addClass("bsb-btn btn-default btn-tournament");

                    $(".k-edit-form-container .k-scheduler-cancel").hide();
                    $(".k-edit-form-container .k-scheduler-delete").text("");
                    $(".k-edit-form-container .k-scheduler-delete").append('<span class="icn icn-tournament-close"></span> Delete');
                    $(".k-edit-form-container .k-scheduler-update").text("");
                    $(".k-edit-form-container .k-scheduler-update").append('Continue');
                    $(".k-edit-form-container .k-scheduler-delete").click(function (e) {
                        setTimeout(function () {
                            if ($(".k-window div.k-popup-edit-form")[1] != undefined) {
                                $(".k-window div.k-popup-edit-form")[1].id = "DeleteWindow";
                                $("#DeleteWindow")[0].offsetParent.className += " scom tournament-popup";
                                $("#DeleteWindow")[0].lastChild.lastChild.firstChild.className += " bsb-btn btn-default btn-tournament btn-tournament-orange pull-left";
                                $("#DeleteWindow")[0].lastChild.lastChild.lastChild.className += " bsb-btn btn-default btn-tournament btn-tournament-orange";

                            }
                        }, 1);
                    });
                    var locationDropDown = e.container.find("#LocationList");
                    $("#LocationList").parent().addClass("k-dropdown-light");
                    calendarViewModel.loadLocationDropDown(locationDropDown, e.event.LocationID, e.event.IsCustomEventMatch);

                    var fieldsDropDownList = e.container.find("#FieldsList");
                    $("#FieldsList").parent().addClass("k-dropdown-light");
                    calendarViewModel.loadFieldsDropDown(fieldsDropDownList, e.event.FieldID, e.event.LocationID);

                    var actionDropDownList = e.container.find("#ActionList");
                    $("#ActionList").parent().addClass("k-dropdown-light");
                    calendarViewModel.loadActionDropDown(actionDropDownList, e.event.ActionStatus);

                    if (e.event.Notes != null)
                        calendarViewModel.set("matchActionNote", e.event.Notes);
                    var actionNoteText = e.container.find("#textForNotes");
                    actionNoteText.val(e.event.Notes);
                    actionNoteText.bind("change", function () {
                        var actionNoteValue = actionNoteText.val();
                        calendarViewModel.set("matchActionNote", actionNoteValue);
                    });
                    if (e.event.ActionStatus > 0) {
                        calendarViewModel.set("isNotesVisible", true);
                    }

                    e.event.set("MatchDate", kendo.toString(e.event.start, 'MM/dd/yyyy'));

                    if (e && e.event) {
                        var type = e.event.AttendeeTypes;
                        //IF Blackout then don't move
                        if (type == 2) {
                            e.preventDefault();
                            return;
                        }
                    }

                    var widget = jQuery('#startTime_timeview');
                    if (widget) {
                        common.stopScroll(widget);
                    }

                    widget = jQuery('#endTime_timeview');
                    if (widget) {
                        common.stopScroll(widget);
                    }
                },
                dataBound: function () {
                    schedulerTooltip("#app");
                    var currentCalendarView = calendarViewModel.currentCalendarView;
                    if (currentCalendarView != 'day') {
                        jQuery('.k-scheduler-content .swapMatchLink').hide();
                    } else {
                        jQuery('.k-scheduler-content .swapMatchLink').show();
                    }
                    $(".k-link.k-event-delete").click(function (e) {
                        setTimeout(function () {
                            if ($(".k-window div.k-popup-edit-form") != undefined) {
                                $(".k-window div.k-popup-edit-form").parent().addClass(" scom tournament-popup");
                                $(".k-window div.k-popup-edit-form a.k-button").addClass(" bsb-btn btn-default btn-tournament btn-tournament-orange");
                                $(".k-window div.k-popup-edit-form a.k-button.k-scheduler-delete").addClass(" pull-left");
                            }
                        }, 1);
                    });
                },
                moveStart: function (e) {
                    if (e.event.IsNgbEvent) {
                        e.preventDefault();
                        return;
                    }

                    if (e.event.IsCustomEventMatch && e.event.EventTypeID == ScheduleType.Other) {
                        e.preventDefault();
                        return;
                    }

                    if (e.event.ActionStatus == 1) {
                        e.preventDefault();
                        return;
                    }
                    if (e.event.IsHideEditOptions == true) {
                        common.showMessage("You are not allowed to edit another portal’s game.", null, true);
                        e.preventDefault();
                        return;
                    }

                    calendarViewModel.disableEditModeForSwap(e);

                    if (e && e.event) {
                        var type = e.event.AttendeeTypes;
                        //IF Blackout / field occupied then don't move
                        if (type == 2 || type == 4) {
                            e.preventDefault();
                            return;
                        }
                        calendarViewModel.resetTheSelectedItemsWhenMove();
                        calendarViewModel.set("selectedMatch", e.event);
                    }
                },
                moveEnd: function (e) {
                    calendarViewModel.disableEditModeForSwap(e);

                    calendarViewModel.set("selectedMatchEndTime", e.end);
                    calendarViewModel.set("selectedMatchStartTime", e.start);

                    var moveCheckVal = calendar_successMove;

                    // For custom event EventDetail is not null & start date and event date comparison is not required.
                    if (e.event.EventDetail == null) {
                        moveCheckVal = checkForMinimumEventDate(e.start, e.end, e.event);
                    }

                    switch (moveCheckVal) {
                        case calendar_askForConfimation:
                            e.preventDefault();
                            return;
                            break;
                        case calendar_failedMove:
                            var matchDateValidationError = "Start date for this event is : " + kendo.toString(e.event.EventDate, 'MM/dd/yyyy') + ". You can move match on or after this date.";
                            common.showMessage(matchDateValidationError, null, true);

                            e.preventDefault();
                            return;
                            break;
                        case calendar_successMove:
                            e.preventDefault();
                            //ask for location and field here.
                            e.event.set("IsEventEdited", true);
                            calendarViewModel.set("selectedMatch", e.event);
                            calendarViewModel.openLocationFieldSelectionWindow();
                            break;
                        default:
                            break;
                    }
                },
                save: function (e) {
                    calendarViewModel.disableEditModeForSwap(e);
                    calendarViewModel.resetStatus();

                    var editForm = e.container.find("#editMatchTable");
                    var validator = editForm.data("kendoValidator");
                    var isValid = validator.validate();
                    if (isValid == false) {
                        e.preventDefault();

                        return;
                    }

                    //If hours diff is bigger than 24 hours then show a different
                    var startDate = kendo.toString(e.event.start, 'MM/dd/yyyy');
                    var endDate = kendo.toString(e.event.end, 'MM/dd/yyyy');

                    if (startDate != endDate) {
                        common.showMessage("Start Date and End Date must be same.");
                        e.preventDefault();

                        return;
                    }

                    //If type changed to Blackout then show message
                    var type = e.event.AttendeeTypes;
                    //IF Blackout then don't move
                    if (type == 2) {
                        common.showMessage("You can't change type to blackout.");
                        e.preventDefault();

                        return;
                    }

                    //var conflictListElement = e.container.find("#conflictsList");
                    var location = calendarViewModel.get("location");
                    var field = calendarViewModel.get("field");
                    var matchActionStatus = calendarViewModel.get("matchActionStatus");
                    var matchActionNote = calendarViewModel.get("matchActionNote");

                    if (e.event.FieldID != field.FieldID || e.event.LocationID != location.LocationID || e.event.ActionStatus != matchActionStatus.ActionStatus || e.event.Notes != matchActionNote) {
                        e.event.dirty = true;
                    }

                    if (e.event.dirty == false) {

                        return;
                    }

                    calendarViewModel.set("selectedMatchStartTime", e.event.start);
                    calendarViewModel.set("selectedMatchEndTime", e.event.end);

                    var sTime = common.getTime(e.event.start);
                    var eTime = common.getTime(e.event.end);

                    e.event.FieldID = field.FieldID;
                    e.event.FieldName = field.Name;
                    e.event.LocationID = location.LocationID;
                    e.event.LocationName = location.Name;
                    e.event.StartTime = sTime;
                    e.event.EndTime = eTime;
                    e.event.ActionStatus = matchActionStatus.ActionStatus;
                    e.event.StatusName = matchActionStatus.Name;
                    e.event.Notes = matchActionNote;

                    var start = new Date(e.event.MatchDate);

                    start.setHours(e.event.start.getHours());
                    start.setMinutes(e.event.start.getMinutes());

                    var end = new Date(e.event.MatchDate);
                    end.setHours(e.event.end.getHours());
                    end.setMinutes(e.event.end.getMinutes());

                    e.event.start = start;
                    e.event.end = end;
                    e.event.set("Start", start);
                    e.event.set("End", end);
                    startDate = kendo.format("{0:d}", e.event.MatchDate);
                    e.event.set("Date", startDate);
                    e.event.set("MatchDate", startDate);
                    e.event.set("IsEventEdited", true);

                    var scheduler = $("#scheduler").data("kendoScheduler");
                    var scheduleDs = scheduler.dataSource;
                    scheduleDs.sync();
                    $(".k-edit-form-container").parent().data("kendoWindow").close();
                    $("#btnsaveScheduleData").addClass("active");
                    $(".gray-popup").removeClass("gray-popup");
                },
                cancel: function (e) {
                    $(".gray-popup").removeClass("gray-popup");
                },
                remove: function (e) {
                    calendarViewModel.disableEditModeForSwap(e);
                    var startDate = kendo.toString(e.event.start, 'MM/dd/yyyy');
                    e.event.set("IsDeleted", true);
                    calendarViewModel.showProgress();
                    var deletedMatches = [];
                    startDate = kendo.format("{0:d}", e.event.MatchDate);
                    e.event.Date = startDate;
                    e.event.MatchDate = startDate;
                    deletedMatches.push(e.event);
                    calendarViewModel.saveMatchesDetails(deletedMatches);
                    $(".gray-popup").removeClass("gray-popup");
                }
            });
            calendarViewModel.showProgress();
        },

        reloadTheCalendarData: function (e) {
            var scheduler = e.sender.element.data("kendoScheduler");
            calendarViewModel.setSelectedEventListByCheckedNodes();
            calendarViewModel.setSelectedLocationsFields();
            calendarViewModel.setSelectedTeams();
            calendarViewModel.hideProgress();
            if (scheduler) {
                scheduler.dataSource.read();
            }
            calendarViewModel.set("isConflict", false);
        },
        refreshSchedulerDataSourceForSelectedEvents: function () {
            var scheduler = $("#scheduler").data("kendoScheduler");
            var scheduleDs = scheduler.dataSource;
            scheduleDs.read();

        },
        loadSchedulerData: function () {
            var scheduler = $("#scheduler").data("kendoScheduler");
            if (scheduler) {
                calendarViewModel.refreshSchedulerDataSourceForSelectedEvents();
            } else {
                var isPosted = calendarViewModel.get("isPosted");
                if (isPosted == true) {
                    calendarViewModel.loadSchedulerForUsers();
                } else {
                    calendarViewModel.loadSchedulerDataSourceUsingApiCall();
                }
            }

        },
        /*--- START : Events of Calendar View ---------*/

        editEventClicked: function (e) {

        },

        loadScheduleDataClicked: function (e) {
            jQuery('.treeViewSearchBox').hide();
            e.preventDefault();

            calendarViewModel.set("selectedEventId", -1);

            calendarViewModel.setSelectedEventListByCheckedNodes();
            calendarViewModel.setSelectedLocationsFields();
            calendarViewModel.setSelectedTeams();
            calendarViewModel.loadSchedulerData();

            $("#btnsaveScheduleData").removeClass("active");

            calendarViewModel.set("isConflict", false);

            calendarViewModel.bulkCancelCalendarMatches = new kendo.data.ObservableArray([]);
            $('.bulkcancelnotes').val("");

            var btnNextForCancelEvents = document.getElementById('btnNextForCancelEvents');
            btnNextForCancelEvents.setAttribute("disabled", "true");
            btnNextForCancelEvents.style.pointerEvents = "none";
        },
        bulkEventCancelActiveClick: function (e) {
            jQuery('.treeViewSearchBox').hide();
            e.preventDefault();
            calendarViewModel.set("isBulkEventCancel", true);
            calendarViewModel.set("selectedEventId", -1);
            globalisbulkEventCancel = true;
            calendarViewModel.setSelectedEventListByCheckedNodes();
            calendarViewModel.setSelectedLocationsFields();
            calendarViewModel.setSelectedTeams();
            $("#btnsaveScheduleData").removeClass("active");
            calendarViewModel.set("isConflict", false);

            var schedulerSelectedDate = $("#scheduler").data("kendoScheduler")._model.selectedDate;
            var schedulerSelectedView = $("#scheduler").data("kendoScheduler")._selectedViewName;

            $("#scheduler").html("");
            calendarViewModel.bulkCancelCalendarMatches = new kendo.data.ObservableArray([]);
            $('.bulkcancelnotes').val("");

            calendarViewModel.loadSchedulerForBulkEventCancel(schedulerSelectedDate);
            $("#scheduler").data("kendoScheduler").view(schedulerSelectedView);
            kendo.ui.progress($("#scheduler"), true);

            var dataList = calendarViewModel.bulkCancelCalendarMatches.length;
            if (globalisbulkEventCancel && dataList == 0) {
                var btnNextForCancelEvents = document.getElementById('btnNextForCancelEvents');
                btnNextForCancelEvents.setAttribute("disabled", "true");
                btnNextForCancelEvents.style.pointerEvents = "none";
            }
        },
        bulkEventCancelDeactiveClick: function (e) {
            location.reload();
        },
        bulkEventsCancelNextStepDataClicked: function (e) {
            const dataList = calendarViewModel.bulkCancelCalendarMatches;
            const dataListElement = $("#dataList");

            dataListElement.empty();

            dataList.sort((a, b) => {
                // Compare dates
                var dateComparison = a.MatchDate - b.MatchDate;
                if (dateComparison !== 0) return dateComparison;

                // Compare times
                var timeComparison = a.StartTime.localeCompare(b.StartTime);
                if (timeComparison !== 0) return timeComparison;

                // Compare event names alphabetically
                var eventNameComparison = a.EventName.localeCompare(b.EventName);
                if (eventNameComparison !== 0) return eventNameComparison;

                // Compare titles alphabetically
                return a.title.localeCompare(b.title);
            });

            var currentDate = null;
            var currentTime = null;

            dataList.forEach(item => {
                var matchDate = item.MatchDate;
                var eventName = item.EventName;
                var Team1Name = item.Team1Name;
                var Team2Name = item.Team2Name;

                if (Team2Name != 'Practice') {
                    Team1Name = Team1Name + ' Vs';
                }

                var locationName = item.LocationName;
                var fieldName = item.FieldName;

                var year = matchDate.getFullYear();
                var month = matchDate.getMonth() + 1;
                var day = matchDate.getDate();
                var dateString = `${month}/${day}/${year}`;

                // Convert time to 12-hour format
                var startTime = item.StartTime;
                var timeParts = startTime.split(':');
                var hours = parseInt(timeParts[0]);
                var minutes = parseInt(timeParts[1]);
                var period = hours >= 12 ? 'PM' : 'AM';
                hours = hours % 12 || 12; // Handle midnight (0) as 12
                var timeString = `${hours}:${minutes.toString().padStart(2, '0')} ${period}`;

                if (currentDate !== dateString) {
                    currentDate = dateString;
                    const dateHeader = $("<div class='skdateEvent'>").text(dateString);
                    dataListElement.append(dateHeader);
                    currentTime = null;
                }

                if (currentTime !== timeString) {
                    currentTime = timeString;
                    if (calendarViewModel.bulkCancelCalendarMatches.filter(dtList => dtList.MatchDate.getTime() == item.MatchDate.getTime() && dtList.StartTime.includes(item.StartTime)).length > 1) {
                        const timeHeader = $("<div class='schedule-item-time'>").text(`${timeString}:`);
                        dataListElement.append(timeHeader);
                    }
                    else {
                        const timeHeader = $("<div class='schedule-item-time' style='display: inline;'>").html(`${timeString}: ` + "<div style='margin: -32px 0px 0px 110px;text-align: justify;'><span>" + ` ${eventName} - <b class="boldText"> ${Team1Name + ' ' + Team2Name} </b> - ${locationName}, ${fieldName}` + "</span></div>");
                        dataListElement.append(timeHeader);
                    }
                }

                if (calendarViewModel.bulkCancelCalendarMatches.filter(dtList => dtList.MatchDate.getTime() == item.MatchDate.getTime() && dtList.StartTime.includes(item.StartTime)).length > 1) {
                    const scheduleItem = $("<div class='schedule-item-title' style='margin-left:100px;text-align: justify;'>").html(`${eventName} - <b class="boldText"> ${Team1Name + ' ' + Team2Name} </b> - ${locationName}, ${fieldName}`);
                    dataListElement.append(scheduleItem);
                }
            });

            // Create the Kendo Popup Window
            const popup = $("#popupContainer").kendoWindow({
                title: "Bulk Cancel Events ",
                width: "800px",
                height: "1000px",
                modal: true,
                visible: false,
            }).data("kendoWindow");

            var popupClass = $("#popupContainer");
            popupClass.parent().addClass('scom tournament-popup gray-popup bulkCancel');
            popup.center().open();

            // Event handler for the Confirm button
            $("#confirmButton").click(function () {
                e.preventDefault();
                editMatchesRouter.routes[0];
                var windowId = "#bulkEventCancelConfirmWindow";
                var ContinueButtonId = "#ContinueWindowButton";
                var CancelButtonId = "#CancelWindowButton";

                var cancelEventCounts = calendarViewModel.bulkCancelCalendarMatches.length;
                $(ContinueButtonId).unbind("click");
                $(CancelButtonId).unbind("click");
                var window = $(windowId);
                $("#bulkEventCancelMessgeText").html("Are you sure? You are about to cancel " + cancelEventCounts + " events & an email will be sent to all team personnel & participants.");
                window.kendoWindow({
                    width: "600px",
                    resizable: false,
                    draggable: false,
                    pinned: true,
                    title: "Bulk Event Cancellation Confirmation",
                    modal: true,
                    actions: [
                        "Close"
                    ],
                    close: function () {
                        popup.center().open();
                    }
                });

                window.parent().addClass('scom tournament-popup');
                $(ContinueButtonId).addClass('bsb-btn btn-default btn-tournament');
                $(CancelButtonId).addClass('bsb-btn btn-default btn-tournament');
                $(ContinueButtonId).find("i").removeClass();
                $(ContinueButtonId).find("i").addClass("fa fa-check");
                $(CancelButtonId).find("i").removeClass();
                $(CancelButtonId).find("i").addClass("fa fa-times");
                window.data("kendoWindow").center().open();

                $(ContinueButtonId).on("click", function () {

                    var cancelNotes = document.getElementsByClassName('bulkcancelnotes')[0].value;

                    calendarViewModel.bulkCancelCalendarMatches.map(x => x.IsEventEdited = true);
                    calendarViewModel.bulkCancelCalendarMatches.map(x => x.IsEdited = true);
                    calendarViewModel.bulkCancelCalendarMatches.map(x => x.ActionStatus = 1);
                    calendarViewModel.bulkCancelCalendarMatches.map(x => x.Notes = cancelNotes);

                    calendarViewModel.saveScheduleDataClicked();

                    window.data("kendoWindow").center().close();
                    popup.center().close();
                });

                $(CancelButtonId).on("click", function () {
                    window.data("kendoWindow").center().close();
                    popup.center().open();
                });

                popup.close();
            });

            $("#cancelButton").click(function () {
                popup.close();
            });
        },
        saveScheduleDataClicked: function (e) {
            calendarViewModel.set("isSavedFromClubLocation", false);
            var calendarMatches = [];

            //if swap match is on then send the swapped matches.
            var isSwapOn = calendarViewModel.get("swapModeEnabled");
            if (isSwapOn == true) {
                //here append the list of matches from the swapped matches array that are not in ds
                var swappedMatches = calendarViewModel.get("swappedMatches");

                if (swappedMatches.length >= 2) {
                    var matches = swappedMatches.map(function (m) {
                        return m.Matches[0];
                    });
                    for (var i = 0; i < matches.length; i++) {
                        var match = matches[i];
                        calendarMatches.push(match);
                    }
                }
            } else {
                if (calendarViewModel.isBulkEventCancel) {
                    calendarMatches = calendarViewModel.getBulkCanceledMatches();
                } else {
                    calendarMatches = calendarViewModel.getChangedMatches();
                }
            }

            //var deletedMatches = calendarViewModel.get("DeletedMatches");
            //calendarMatches = jQuery.merge(calendarMatches, deletedMatches);

            if (calendarMatches.length <= 0) {
                common.showSuccessMessage("There are no changes to update.");
                return;
            }

            calendarViewModel.showProgress();

            //Set Date Format for Calendar Matches --Start
            for (var i = 0; i < calendarMatches.length; i++) {
                var match = calendarMatches[i];

                if (match.MatchDate)
                    match.MatchDate = kendo.toString(match.MatchDate, 'MM/dd/yyyy');

            }
            //Set Date Format for Calendar Matches --End


            for (var i = 0; i < calendarMatches.length; i++) {
                var match = calendarMatches[i];

                if (match.MatchDate) {
                    match.MatchDate = kendo.toString(match.MatchDate, 'MM/dd/yyyy');
                    match.Date = match.MatchDate;
                }
            }
            calendarViewModel.saveMatchesDetails(calendarMatches);
        },
        saveMatchesDetails: function (calendarMatches) {
            var serviceRootUrl = common.getServiceRootUrl();

            $.ajax({
                url: serviceRootUrl + "Calendar/SaveMatchesDetails",
                data: JSON.stringify({ CalendarMatches: calendarMatches, IsAcceptWithConflict: calendarViewModel.get("isAcceptWithConflict"), IsBulkEventCancel: globalisbulkEventCancel }),
                type: "POST",
                contentType: 'application/json; charset=utf-8',
                success: function (d) {
                    calendarViewModel.hideProgress();
                    if (!d) {
                        return;
                    }

                    if (d.ConflictedMatches.length > 0) {
                        calendarViewModel.set("isConflict", true);

                        var conflictMatches = calendarViewModel.get("conflictedMatches");
                        conflictMatches.splice(0, conflictMatches.length);

                        var conflictedMatches = d.ConflictedMatches;

                        for (var i = 0; i < conflictedMatches.length; i++) {
                            if (conflictedMatches[i].Date)
                                conflictedMatches[i].Date = kendo.parseDate(conflictedMatches[i].Date);

                            if (conflictedMatches[i].StartTime)
                                conflictedMatches[i].StartTime = common.getDateFromDbTime(conflictedMatches[i].StartTime);

                            if (conflictedMatches[i].EndTime)
                                conflictedMatches[i].EndTime = common.getDateFromDbTime(conflictedMatches[i].EndTime);

                            conflictMatches.push(conflictedMatches[i]);
                        }

                        var isAcceptWithConflict = (d.IsAnyConflictNonOverWritable == false);
                        calendarViewModel.set("isAcceptWithConflict", isAcceptWithConflict);
                        if (isAcceptWithConflict == true) {
                            calendarViewModel.set("saveLinkText", "Save Matches With Conflicts");
                            common.showMessage('<span class="normal-text">There are some conflicts in the updated matches. Please view conflicts by clicking on "Show Conflict" button above.</span>');
                        } else {
                            calendarViewModel.showConflicts();
                        }
                    } else {
                        if (calendarMatches[0].IsDeleted) {
                            if (calendarMatches[0].IsCustomEventMatch) {
                                calendarViewModel.updateMasterMatchIdForCustomEventRepeatMatches(
                                    calendarMatches[0]);
                            }
                            common.showSuccessMessage(
                                "Matches deleted successfully.", function () {
                                }, false);

                        } else if (calendarViewModel.isBulkEventCancel) {
                            var message = "Your events have been cancelled successfully.";
                            var htmlMessage = '<div style="color:#48749B">' + message + '</div>';
                            var title = "Match Scheduler";

                            var messageWindow = $("#messageWnd");

                            if (!messageWindow.data("kendoWindow")) {
                                messageWindow.kendoWindow({
                                    width: "320px",
                                    title: title,
                                    modal: true,
                                    actions: [
                                        "Close"
                                    ],
                                    close: function () {
                                        location.reload();
                                    }
                                });
                            }

                            messageWindow.parent().addClass('scom tournament-popup');
                            messageWindow.data("kendoWindow").content(htmlMessage);
                            messageWindow.data("kendoWindow").center().open();

                        } else {
                            calendarViewModel.cancelSwappingMode();

                            calendarViewModel.resetEditModeForEventMatches(false);

                            calendarViewModel.set("isConflict", false);
                            calendarViewModel.resetStatus();
                            $("#btnsaveScheduleData").removeClass("active");
                            common.showSuccessMessage("Matches saved successfully.", function () {
                            }, false);
                        }
                    }
                },
                error: function (objError) {
                    calendarViewModel.hideProgress();
                    if (objError.status == 500) {
                        common.showMessage(JSON.parse(objError.responseText).Name);
                    }
                }
            });
        },
        updateMasterMatchIdForCustomEventRepeatMatches: function (calendarMatch) {

            var scheduler = $("#scheduler").data("kendoScheduler");
            var matches = scheduler.dataSource.data();
            var matchesArray = calendarViewModel.getArrayFromDataSourceData(matches);
            var oldMasterMatchId = calendarMatch.MasterMatchId;

            var repeatMaches = Enumerable.From(matchesArray)
                .Where(function (x) {
                    return x.MasterMatchId == oldMasterMatchId;
                })
                .OrderBy(function (x) {
                    return x.MatchID;
                })
                .Select(function (x) {
                    return x;
                }).ToArray();

            if (repeatMaches.length > 0) {

                var newMasterMatchId = repeatMaches[0].TaskId;
                $.map(repeatMaches, function (match, i) {
                    match.set("MasterMatchId", newMasterMatchId);
                });

                scheduler.dataSource.data(matchesArray);
            }
        },
        addSwappedMatchesToCalendar: function (calendarMatches) {

            //here append the list of matches from the swapped matches array that are not in ds
            var swappedMatches = calendarViewModel.get("swappedMatches");

            var matches = swappedMatches.map(function (m) {
                return m.Matches;
            });

            var len = matches.length;
            for (var i = 0; i < len; i++) {

                var match = matches[i];

                var sTime = common.getTime(match.start);
                var eTime = common.getTime(match.end);
                match.Date = kendo.format("{0:d}", new Date(match.Date));
                match.EventDate = kendo.format("{0:d}", new Date(match.EventDate));

                match.StartTime = sTime;
                match.EndTime = eTime;
                match.MatchDate = kendo.format("{0:d}", match.start);

                calendarMatches.push(match);
            }

        },

        /*--- END : Events of Calendar View ---------*/

        loadMultiSelectEventBox: function () {
            $("#multiEventSelectBox").html('');

            $("#multiEventSelectBox").kendoMultiSelectTreeViewSearchBox({
                treeViewControlName: "MultiSelectTreeViewSearchBoxForEvents",
                treeViewDataSource: eventNamesDataSource,
                dataTextField: "EventName"
            });

            $("#multiEventSelectBox").find("span").addClass("k-dropdown-light");
            //checkedItemChanged
            var eventTreeViewList = $("#multiEventSelectBox").data("kendoMultiSelectTreeViewSearchBox");
            eventTreeViewList.checkedItemChanged.bind("checkedItemChanged", function (e) {
                var totalSelectedEvents = eventTreeViewList.totalCheckedItems;

                if (totalSelectedEvents > 0) {
                    calendarViewModel.set("isEventListSelectionChanged", true);
                } else {
                    calendarViewModel.set("isEventListSelectionChanged", false);
                }

                if (totalSelectedEvents == eventNamesDataSource.data().length) {
                    calendarViewModel.set("isSelectAllEventsChecked", true);
                } else {
                    calendarViewModel.set("isSelectAllEventsChecked", false);
                }

                calendarViewModel.setBitForEventOrLocationFilterSelection();
            });
        },
        filterButtonCallback: function (filterTextValue, selectedEventIds) {

        },
        selectAllEventsChangedClicked: function (e) {
            var isSelectAllEventsChecked = calendarViewModel.get("isSelectAllEventsChecked");
            var eventSelectionBox = $("#multiEventSelectBox").data("kendoMultiSelectTreeViewSearchBox");
            eventSelectionBox.setAllNodeSelected(isSelectAllEventsChecked);
            calendarViewModel.set("isEventListSelectionChanged", true);
        },

        isEventListSelectionChanged: false,

        isLocationFilterSelectionChanged: false,

        isProgramDivisionTeamFilterSelectionChanged: false,

        isPosted: false,
        isCustomEventMatchInclude: false,
        isFilterSelected: false,
        setBitForEventOrLocationFilterSelection: function () {
            calendarViewModel.set("isFilterSelected", calendarViewModel.get("isEventListSelectionChanged") ||
                calendarViewModel.get("isLocationFilterSelectionChanged") ||
                calendarViewModel.get("isProgramDivisionTeamFilterSelectionChanged"));
            if (calendarViewModel.get("isFilterSelected") == true) {
                $("#viewMatches").addClass("active");

            } else {
                $("#viewMatches").removeClass("active");
            }
        },

        /*- Tree View Functions -*/

        loadLocationsAndFields: function () {
            $("#multiSelectLocationFieldTreeView").html('');
            $("#multiSelectLocationFieldTreeView").kendoMultiSelectTreeViewSearchBox({
                treeViewControlName: "MultiSelectTreeViewSearchBoxForLocations",
                treeViewDataSource: locationsDataSource,
                dataTextField: "Name"
            });

            $("#multiSelectLocationFieldTreeView").find("span").addClass("k-dropdown-light");
            /*Start - Treeview for mass shift*/
            $("#multiSelectLocationFieldTreeViewForMassShift").kendoMultiSelectTreeViewSearchBox({
                treeViewControlName: "MultiSelectTreeViewSearchBoxForLocationsForMassShift",
                treeViewDataSource: locationsDataSource,
                dataTextField: "Name"
            });
            /*End - Treeview for mass shift*/

            var locationTreeList = $("#multiSelectLocationFieldTreeView").data("kendoMultiSelectTreeViewSearchBox");

            locationTreeList.checkedItemChanged.bind("checkedItemChanged", function (e) {
                var totalSelectedEvents = locationTreeList.totalCheckedItems;
                if (totalSelectedEvents > 0) {
                    calendarViewModel.set("isLocationFilterSelectionChanged", true);
                } else {
                    calendarViewModel.set("isLocationFilterSelectionChanged", false);
                }

                calendarViewModel.setBitForEventOrLocationFilterSelection();
            });

            locationsListDs.read();
            fieldsListDs.read();
        },
        loadProgramsDivisionsAndTeams: function () {
            $("#multiSeletectProgramDivisionTeamTreeView").html('');

            $("#multiSeletectProgramDivisionTeamTreeView").kendoMultiSelectTreeViewSearchBox({
                treeViewControlName: "multiSelectTreeViewSearchBoxForProgramDivisionTeam",
                treeViewDataSource: programDivisionTeamDs,
                dataTextField: "Name"
            });

            $("#multiSeletectProgramDivisionTeamTreeView").find("span").addClass("k-dropdown-light");
            var programDivisionTeamTreeList = $("#multiSeletectProgramDivisionTeamTreeView").data("kendoMultiSelectTreeViewSearchBox");

            programDivisionTeamTreeList.checkedItemChanged.bind("checkedItemChanged", function (e) {
                var totalSelectedEvents = programDivisionTeamTreeList.totalCheckedItems;
                if (totalSelectedEvents > 0) {
                    calendarViewModel.set("isProgramDivisionTeamFilterSelectionChanged", true);
                } else {
                    calendarViewModel.set("isProgramDivisionTeamFilterSelectionChanged", false);
                }

                calendarViewModel.setBitForEventOrLocationFilterSelection();
            });
        },

        getTheLocationsBasedOnFields: function () {
            var match = calendarViewModel.get("selectedMatch");
            if (!match) return;

            var eventId = match.EventID;

            var allocatedFieldsByEvents = calendarViewModel.get("AllocatedFieldsByEvent");
            var len = allocatedFieldsByEvents.length;
            var fields = null;
            for (var i = 0; i < len; i++) {
                if (allocatedFieldsByEvents[i].Key == eventId) {
                    fields = allocatedFieldsByEvents[i].Value;
                    break;
                }
            }

            //filter out the fields array by the locationId...
            if (fields) {
                var filterArray = [];

                for (var j = 0; j < fields.length; j++) {
                    var fId = fields[j];
                    var newFilter = {
                        field: "FieldID",
                        operator: "eq",
                        value: parseInt(fId)
                    };
                    filterArray.push(newFilter);
                }
                fieldsListDs.filter({
                    logic: "or",
                    filters: filterArray
                });

                var locationIds = [];
                var fieldsData = fieldsListDs.view();
                var fieldsLen = fieldsData.length;
                for (var k = 0; k < fieldsLen; k++) {
                    var locId = fieldsData[k].LocationID;
                    var index = locationIds.indexOf(locId);
                    if (index <= 0) {
                        locationIds.push(locId);
                    }
                }
                return locationIds;
            }
            return [];
        },

        filterLocationBasedOnFields: function (
            locationIds,
            locationsDataSource,
            locationDropDownCallback) {
            var filterArray = [];

            for (var j = 0; j < locationIds.length; j++) {
                var locId = locationIds[j];
                var newFilter = {
                    field: "LocationID",
                    operator: "eq",
                    value: parseInt(locId)
                };
                filterArray.push(newFilter);
            }
            locationsDataSource.filter({
                logic: "or",
                filters: filterArray
            });

            /*-- Read Call back --*/
            /*-- Filter the Locations data Source --*/
            if (locationDropDownCallback) {
                locationDropDownCallback();
            } else {
                //filter the field data source  by location
                var locationId = locationsDataSource.view()[0].LocationID;
                calendarViewModel.filterFieldsBasedOnAllocatedFields(locationId);
            }
        },
        filterFieldsBasedOnSelectedLocation: function (locationId) {
            fieldsListDs.filter([]);
            fieldsListDs.filter({ field: "LocationID", operator: "eq", value: locationId });

            var allFields = fieldsListDs.view();
            var lst = calendarViewModel.get("fields");
            lst.splice(0, lst.length);
            for (var i = 0; i < allFields.length; i++) {
                lst.push({ FieldID: allFields[i].FieldID, Name: allFields[i].Name });
            }

            if (lst.length > 0) {
                calendarViewModel.set("field", lst[0]);
            }

        },
        filterFieldsBasedOnAllocatedFields: function (
            locationId, fieldId, fieldsDropDownLoadedCallback) {
            fieldsListDs.filter([]);
            fieldsListDs.filter({ field: "LocationID", operator: "eq", value: locationId });

            if (fieldId) {

                var allFields = fieldsListDs.view();
                var fieldLen = allFields.length;
                for (var k = 0; k < fieldLen; k++) {
                    var curField = allFields[k];
                    if (curField.FieldID == fieldId) {
                        calendarViewModel.set("field", curField);
                    }
                }
            }

            if (fieldsDropDownLoadedCallback) {
                fieldsDropDownLoadedCallback();
            } else {
                if (!fieldId) {
                    calendarViewModel.set("field", fieldsListDs.view()[0]);
                }
            }

        },
        /*- Tree View Functions -*/
        /*-- START : Edit Locations and Fields --*/
        setSelectedEventListByCheckedNodes: function () {
            var selectedEventIds = [];
            var eventSelectionBox = $("#multiEventSelectBox").data("kendoMultiSelectTreeViewSearchBox");
            var checkedEventNodes = [];
            checkedEventNodes = eventSelectionBox.getSelectedNodes();
            if (checkedEventNodes.length > 0) {
                var eventLen = checkedEventNodes.length;
                for (var i = 0; i < eventLen; i++) {
                    selectedEventIds.push(checkedEventNodes[i].EventID);
                }
            }
            calendarViewModel.set("selectedEventsList", selectedEventIds);
        },

        setSelectedLocationsFields: function () {
            var fieldsSelectionBox = $("#multiSelectLocationFieldTreeView").data("kendoMultiSelectTreeViewSearchBox");
            var checkedFieldNodes = [];
            checkedFieldNodes = fieldsSelectionBox.getSelectedChildNodes();

            //Selected Locations and Fields.
            var selectedFieldIds = [];
            if (checkedFieldNodes.length > 0) {
                var fieldLen = checkedFieldNodes.length;

                for (var j = 0; j < fieldLen; j++) {
                    var fieldId = checkedFieldNodes[j].Id;
                    if (fieldId) {
                        selectedFieldIds.push(fieldId);
                    }
                }
            }

            calendarViewModel.set("selectedFieldsList", selectedFieldIds);
        },

        setSelectedTeams: function () {
            var teamsSelectionBox = $("#multiSeletectProgramDivisionTeamTreeView").data("kendoMultiSelectTreeViewSearchBox");
            var checkedTeamNodes = [];
            checkedTeamNodes = teamsSelectionBox.getSelectedChildNodes();

            //Selected Teams.
            var selectedTeamIds = [];
            if (checkedTeamNodes.length > 0) {
                var teamLen = checkedTeamNodes.length;

                for (var j = 0; j < teamLen; j++) {
                    var teamId = checkedTeamNodes[j].Id;
                    if (teamId) {
                        selectedTeamIds.push(teamId);
                    }
                }
            }
            calendarViewModel.set("selectedTeamsList", selectedTeamIds);
        },

        selectLocationFromList: function (locationId, locationDropDown, locationsDs) {
            var dropDown = $(locationDropDown).data("kendoDropDownList");
            dropDown.select(function (dataItem) {
                return dataItem.LocationID === locationId;
            });

            var location = locationsDs.get(locationId);
            calendarViewModel.set("location", location);

            common.stopScroll(dropDown.ul);
        },
        selectFieldFromList: function (fieldId, fieldDropDown, fieldsDs) {
            var fieldDropDownList = $(fieldDropDown).data("kendoDropDownList");
            fieldDropDownList.select(function (dataItem) {
                return dataItem.FieldID === fieldId;
            });

            var field = fieldsDs.get(fieldId);
            calendarViewModel.set("field", field);

            common.stopScroll(fieldDropDownList.ul);
        },
        selectActionFromList: function (actionStatus, actionDropDown, actionStatusDs) {
            var dropDown = $(actionDropDown).data("kendoDropDownList");
            dropDown.select(function (dataItem) {
                return dataItem.ActionStatus === actionStatus;
            });

            var matchAction = actionStatusDs._data[actionStatus];
            calendarViewModel.set("matchActionStatus", matchAction);
            calendarViewModel.set("isNotesVisible", true);
            common.stopScroll(dropDown.ul);
        },
        openLocationFieldSelectionWindow: function () {
            $("#LocationList").parent().addClass("k-dropdown-light");
            $("#FieldsList").parent().addClass("k-dropdown-light");
            var match = calendarViewModel.get("selectedMatch");
            if (match) {
                var locations = calendarViewModel.get("locations");
                locations = calendarViewModel.get("locationsWithTBD");

                calendarViewModel.set("locations", locations);

                calendarViewModel.selectLocationFromList(match.LocationID, "#LocationList", locationsListDs);

                calendarViewModel.filterFieldsBasedOnSelectedLocation(match.LocationID);
                calendarViewModel.selectFieldFromList(match.FieldID, "#FieldsList", fieldsListDs);
            }

            var window1 = $("#selectLocationFieldWindow");
            if (!window1.data("kendoWindow")) {
                window1.kendoWindow({
                    modal: true,
                    width: "650px",

                    title: "Select Location And Field",
                    actions: [
                        "Close"
                    ],
                });

                window1.data("kendoWindow").wrapper.addClass("scom tournament-popup");
                window1.data("kendoWindow").center().open();

                $("#moveMatchButton").on("click", function () {
                    calendarViewModel.saveTheEditedMatch($(".conflictListForMoveMatch"), function () {
                    });
                });

                $("#cancelMoveButton").on("click", function () {
                    $('#selectLocationFieldWindow').data("kendoWindow").close();
                });

            } else {
                window1.data("kendoWindow").center().open();
            }
        },

        updateLocationAndFieldForSuccessfulMove: function () {
            var existingMatch = calendarViewModel.get("selectedMatch");
            if (existingMatch) {
                var location = calendarViewModel.get("location");
                var field = calendarViewModel.get("field");

                existingMatch.LocationID = location.LocationID;
                existingMatch.LocationName = location.Name;
                existingMatch.FieldID = field.FieldID;
                existingMatch.FieldName = field.Name;

                var startTime = common.getTime(existingMatch.start);
                var endTime = common.getTime(existingMatch.end);

                existingMatch.set("StartTime", startTime);
                existingMatch.set("EndTime", endTime);
            }

            var scheduler = $("#scheduler").data("kendoScheduler");
            var scheduleDs = scheduler.dataSource;
            scheduleDs.sync();
        },

        locationSelectionChanged: function (e) {
            e.preventDefault();

            var location = calendarViewModel.get("location");
            var locationId = location.LocationID;
            calendarViewModel.filterFieldsBasedOnAllocatedFields(locationId);
        },
        onLocationChanged: function (e) {
            e.preventDefault();

            var location = calendarViewModel.get("location");
            var locationId = location.LocationID;
            calendarViewModel.filterFieldsBasedOnSelectedLocation(locationId);
        },
        loadLocationDropDown: function (locationDropDown, locationId, isCustomEventMatch) {
            locationsListDs.filter([]);

            locationDropDown.kendoDropDownList({
                dataTextField: "Name",
                dataValueField: "LocationID",
                dataSource: locationsListDs,
                value: locationId,
                change: calendarViewModel.locationSelectionChanged,
                select: function (e) {
                    var dataItem = this.dataItem(e.item.index());
                    calendarViewModel.set("location", dataItem);
                },
                index: 0,
            });

            calendarViewModel.selectLocationFromList(locationId, locationDropDown, locationsListDs);
        },

        loadFieldsDropDown: function (fieldsDropDown, fieldId, locationId) {
            fieldsDropDown.kendoDropDownList({
                dataTextField: "Name",
                dataValueField: "FieldID",
                value: fieldId,
                dataSource: fieldsListDs,
                index: 0,
                select: function (e) {
                    var dataItem = this.dataItem(e.item.index());
                    calendarViewModel.set("field", dataItem);
                },
            });

            if (!locationId) {
                var location = calendarViewModel.get("location");
                if (!location) return;
                locationId = location.LocationID;
            }

            calendarViewModel.filterFieldsBasedOnAllocatedFields(locationId, fieldId, function () {
                calendarViewModel.selectFieldFromList(fieldId, fieldsDropDown, fieldsListDs);
            });
        },

        loadActionDropDown: function (actionDropDown, actionStatus) {
            actionDropDown.kendoDropDownList({
                dataTextField: "Name",
                dataValueField: "ActionStatus",
                value: actionStatus,
                dataSource: actionDataSource,
                index: 0,
                select: function (e) {
                    calendarViewModel.set("isNotesVisible", true);
                    var dataItem = this.dataItem(e.item.index());
                    calendarViewModel.set("matchActionStatus", dataItem);
                    calendarViewModel.selectedMatch.set("ActionStatus", dataItem.ActionStatus);
                    calendarViewModel.selectedMatch.set("IsNoteVisible", dataItem.ActionStatus > 0);
                    calendarViewModel.selectedMatch.set("IsMatchStatusCanceled", dataItem.ActionStatus == 1);
                },
            });
            calendarViewModel.selectActionFromList(actionStatus, actionDropDown, actionDataSource);
        },
        /*-- END : Edit Locations and Fields --*/

        saveTheEditedMatch: function (conflictListElement, successCallback, conflictCallback) {
            calendarViewModel.resetStatus();

            var field = calendarViewModel.get("field");
            var location = calendarViewModel.get("location");

            var startTime = calendarViewModel.get("selectedMatchStartTime");
            var endTime = calendarViewModel.get("selectedMatchEndTime");

            var match = calendarViewModel.get("selectedMatch");

            if (!field || !endTime || !match || !location) return;

            match.set("end", endTime);
            match.set("start", startTime);
            match.set("End", endTime);
            match.set("Start", startTime);
            match.set("MatchDate", kendo.format("{0:d}", match.MatchDate));
            calendarViewModel.updateLocationAndFieldForSuccessfulMove();

            $("#btnsaveScheduleData").addClass("active");
            jQuery('#selectLocationFieldWindow').data("kendoWindow").close();
        },

        /*--Display Conflicts List-*/

        resetTheSelectedItemsWhenMove: function () {
            calendarViewModel.set("conflictsList", []);
            calendarViewModel.set("selectedMatch", null);
            calendarViewModel.set("selectedMatchStartTime", null);
            calendarViewModel.set("selectedMatchEndTime", null);
            ($("#conflictsList").html(''));
        },

        showConflicts: function () {
            var conflictListWindow = $("#ConflictListWindow");
            if (!conflictListWindow.data("kendoWindow")) {
                conflictListWindow.kendoWindow({
                    width: "950px",
                    title: "Show Conflicts",
                    modal: true,
                    actions: [
                        "Close"
                    ]
                });
                kendo.bind(conflictListWindow, calendarViewModel);
            }

            conflictListWindow.data("kendoWindow").wrapper.addClass("scom tournament-popup");
            conflictListWindow.data("kendoWindow").center().open();
            $("#ConflictListWindow table").css({
                "table-layout": "fixed",
            });

            $(".ConflictList .k-listview table td").css({
                "word-break": "break-word"
            });

            if (calendarViewModel.get("isSavedFromClubLocation")) {
                $("#ConflictListWindow  table thead tr th")[2].innerText = "EventName"
                $("#ConflictListWindow  table tbody tr td")[2].innerHTML = calendarViewModel.conflictedMatches[0].eventName
            }

            //Created match is not site wide but conflicted match is site wide
            $("#matchesList .ConflictList table").each(function (index, element) {
                if (calendarViewModel.conflictedMatches[0].ConflictsList[0].Matches[index].EventDetail.IsSiteWideEvent) {
                    $(element).find("thead tr th").eq(3).hide();
                    $(element).find("tbody tr td").eq(3).hide();
                    $(element).find("tbody tr td").eq(0).text(calendarViewModel.conflictedMatches[0].ConflictsList[0].Matches[index].EventDetail.EventName);
                }
            });
        },
        onConflictListToggleClick: function (e) {
            $(e.currentTarget).parents(".createdEvent").find(".ConflictList").toggle();
            $(e.currentTarget).find(".icn-collapse-minus").toggle();
            $(e.currentTarget).find(".icn-expand-plus").toggle();
        },
        conflictedMatches: new kendo.data.ObservableArray([]),
        resetStatus: function () {
            calendarViewModel.set("saveLinkText", "Save");
            calendarViewModel.set("isAcceptWithConflict", false);
            calendarViewModel.set("isConflict", false);
            $("#btnsaveScheduleData").removeClass("active");
            calendarViewModel.set("swappedMatches", new kendo.data.ObservableArray([]));
            calendarViewModel.set("conflictedMatches", new kendo.data.ObservableArray([]));
        },
        getChangedMatches: function () {
            var scheduler = $("#scheduler").data("kendoScheduler");

            var matches = scheduler.dataSource.data();
            var calendarMatches = [];

            var matchesLen = matches.length;

            for (var i = 0; i < matchesLen; i++) {
                var match = matches[i];
                if (match.get("IsEventEdited") == false) {
                    continue;
                }
                match.set("IsEdited", true);
                var sTime = common.getTime(match.start);
                var eTime = common.getTime(match.end);

                match.set("StartTime", sTime);
                match.set("EndTime", eTime);
                match.MatchDate = kendo.format("{0:d}", match.start);
                calendarMatches.push(match);
            }

            return calendarMatches;
        },
        getBulkCanceledMatches: function () {
            var scheduler = $("#scheduler").data("kendoScheduler");
            var matches = scheduler.dataSource.data();
            var bulkCancelMatches = calendarViewModel.bulkCancelCalendarMatches;
            var calendarMatches = [];

            var matchesLen = matches.length;

            for (var i = 0; i < matchesLen; i++) {
                if (bulkCancelMatches.map(b => b.MasterMatchId).includes(matches[i].MasterMatchId)) {
                    var match = matches[i];
                    if (match.get("IsEventEdited") == false) {
                        continue;
                    }
                    match.set("IsEdited", true);
                    var sTime = common.getTime(match.start);
                    var eTime = common.getTime(match.end);

                    match.set("StartTime", sTime);
                    match.set("EndTime", eTime);
                    match.MatchDate = kendo.format("{0:d}", match.start);
                    calendarMatches.push(match);
                }
            }
            return calendarMatches;
        },
        showProgress: function () {
            kendo.ui.progress($("#scheduler"), true);
        },
        hideProgress: function () {
            kendo.ui.progress($("#scheduler"), false);
        },
        /*----- Start  :  Swap Matches  ---*/
        matchId: null,
        swapModeEnabled: false,
        swappedMatches: new kendo.data.ObservableArray([]),
        eventName: null,
        swapTeam1: null,
        swapTeam2: null,
        swapMatchData: new kendo.data.ObservableArray([]),
        swapWithMeTextChangeMatches: function (dataItem) {

            var isSwapStarted = dataItem.get("IsSwapStarted");
            if (isSwapStarted == false) return;

            var event = $("#scheduler");
            var scheduler = event.data("kendoScheduler");
            var dataSource = scheduler.dataSource;

            calendarViewModel.updateStatusOfOtherMatches(dataSource, dataItem, true);
        },
        startSwappingMatches: function (dataItem) {
            calendarViewModel.updateTheMatchSwappingArray(dataItem);
            calendarViewModel.swapWithMeTextChangeMatches(dataItem);
        },
        disableEditModeForEventMatches: function (eventId, roundNumber, isDisabled, taskId) {
            var scheduler = $("#scheduler").data("kendoScheduler");
            var matches = scheduler.dataSource.data();

            var swappedMatchItem = $.grep(matches, function (m) {
                return m.TaskId == taskId;
            });

            var len = swappedMatchItem.length;
            for (var i = 0; i < len; i++) {
                swappedMatchItem[i].set("IsEditDisabled", isDisabled);
            }
        },
        cancelSwappingMode: function () {
            //reset the swap matches array
            var swapmatchesArray = calendarViewModel.get("swappedMatches");
            swapmatchesArray.splice(0, swapmatchesArray.length);
            calendarViewModel.set("swapModeEnabled", false);
            calendarViewModel.resetStatus();
        },
        cancelSwappingProcessClicked: function (e) {
            e.preventDefault();

            calendarViewModel.cancelSwappingMode();
            calendarViewModel.refreshSchedulerDataSourceForSelectedEvents();
        },
        enableEditModeForEventMatches: function (isEnable) {
            var scheduler = $("#scheduler").data("kendoScheduler");
            var matches = scheduler.dataSource.data();
            var matchesArray = $.map(matches, function (match, i) {
                return match.clone(false);
            });

            $.map(matchesArray, function (match, i) {
                match.set("IsEditDisabled", isEnable);
            });

            scheduler.dataSource.data(matchesArray);
        },
        getArrayFromDataSourceData: function (data) {
            var array = $.map(data, function (match, i) {
                return match.clone(false);
            });

            return array;
        },
        resetEditModeForEventMatches: function (isDisabled) {
            var scheduler = $("#scheduler").data("kendoScheduler");
            var matches = scheduler.dataSource.data();

            var matchesArray = calendarViewModel.getArrayFromDataSourceData(matches);
            $.map(matchesArray, function (match, i) {
                match.set("IsEditDisabled", isDisabled);
                match.set("IsEventEdited", false);
            });

            $("#btnsaveScheduleData").removeClass("active");
            scheduler.dataSource.data(matchesArray);
        },

        updateTheDataSourceFromSwappingArray: function () {
            var swapmatchesArray = calendarViewModel.get("swappedMatches");
            if (!swapmatchesArray) return;

            var matchesLen = swapmatchesArray.length;
            if (matchesLen <= 0) return;

            var scheduler = $("#scheduler").data("kendoScheduler");

            var currentDate = scheduler.date();

            var dataSource = scheduler.dataSource;

            var isSwapStarted = false;

            if (dataSource) {
                var dsMatches = dataSource.data();

                for (var i = 0; i < matchesLen; i++) {
                    var swapMatch = swapmatchesArray[i];

                    var taskId = swapMatch.TaskId;
                    var swappedSavedMatch = swapMatch.Matches[0];

                    var matchFromDs = $.grep(dsMatches, function (m) {
                        return m.TaskId == taskId;
                    });

                    if (matchFromDs.length > 0) {
                        if (kendo.toString(swappedSavedMatch.Date, "MM/dd/yyyy") == kendo.toString(currentDate, "MM/dd/yyyy")) {
                            calendarViewModel.updateTheMatchesDetails(matchFromDs[0], swappedSavedMatch);
                        } else {
                            dataSource.remove(matchFromDs[0]);
                        }
                    } else if (kendo.toString(swappedSavedMatch.Date, "MM/dd/yyyy") == kendo.toString(currentDate, "MM/dd/yyyy")) {
                        dataSource.add(swappedSavedMatch);
                    }

                    if (swappedSavedMatch.get("IsSwapStarted") == true) {
                        isSwapStarted = true;
                    }
                }

                if (isSwapStarted == true) {
                    for (var i = 0; i < dsMatches.length; i++) {
                        var match = dsMatches[i];
                        match.IsSwapOn = true;
                    }
                }

            }
        },
        updateStatusOfOtherMatches: function (dataSource, match1, status) {
            if (!match1) {
                match1 = calendarViewModel.getItemFromSwappingArray(match1);
            }

            var matchesToSwapWith = [];
            matchesToSwapWith = $.map(dataSource.data(), function (d, i) {
                return d.clone(false);
            });

            if (!matchesToSwapWith) return;

            for (var i = 0; i < matchesToSwapWith.length; i++) {
                var match = matchesToSwapWith[i];

                if (match.TaskId != match1.TaskId) {
                    match.set("IsSwapOn", status);

                }
            }

            dataSource.data(matchesToSwapWith);
        },
        updateTheMatchesDetails: function (match1, match2) {
            match1.AreaId = match2.AreaId;
            match1.AttendeeTypes = match2.AttendeeTypes;
            match1.Date = match2.Date;

            match1.EventDate = match2.EventDate;
            match1.FieldID = match2.FieldID;
            match1.FieldName = match2.FieldName;
            match1.LocationID = match2.LocationID;
            match1.LocationName = match2.LocationName;
            match1.MatchDate = match2.MatchDate;

            var match1StartTime = match1.StartTime.split(":");
            var match1EndTime = match1.EndTime.split(":");

            var hours = calendarViewModel.getTimeDifference(match1StartTime[0], match1EndTime[0]);
            var mins = calendarViewModel.getTimeDifference(match1StartTime[1], match1EndTime[1]);

            var startDate = new Date(match2.Date);
            var time = match2.StartTime.split(":");
            startDate.setHours(time[0]);
            startDate.setMinutes(time[1]);
            match1.start = startDate;
            match1.Start = startDate;
            match1.StartTime = match2.StartTime;

            var endDate = new Date(match2.Date);
            var endTimeHours = startDate.getHours() + hours;
            var endTimeMins = startDate.getMinutes() + mins;

            endDate.setHours(endTimeHours);
            endDate.setMinutes(endTimeMins);

            match1.end = endDate;
            match1.End = endDate;
            match1.EndTime = kendo.toString(endDate, "HH:mm");

            match1.IsEditDisabled = true;
            match1.IsEventEdited = true;

            $("#btnsaveScheduleData").addClass("active");
            match1.IsEdited = true;
        },
        getTimeDifference: function (start, end) {
            start = parseInt(start);
            end = parseInt(end);

            return (end - start);
        },
        resetTheSwappedMatchesArrayWithDataSource: function (match1, match2) {
            var swapMatch1 = calendarViewModel.getItemFromSwappingArray(match1);
            if (swapMatch1) {
                swapMatch1.set("IsSwapStarted", false);
                calendarViewModel.updateTheMatchesDetails(swapMatch1, match1);
            }

            var swapMatch2 = calendarViewModel.getItemFromSwappingArray(match2);
            if (swapMatch2) {
                calendarViewModel.updateTheMatchesDetails(swapMatch2, match2);
            }
        },
        updateTheSwappedMatchesWithinDataSource: function (dataSource, match1, match2) {
            var tempMatch = match1.clone(false);

            //SET MATCH1
            calendarViewModel.updateTheMatchesDetails(match1, match2);

            ////SET MATCH2
            calendarViewModel.updateTheMatchesDetails(match2, tempMatch);

            match2.set("IsEventEdited", true);

            $("#btnsaveScheduleData").addClass("active");
            match1.set("IsSwapStarted", false);
            match2.set("IsSwapOn", false);

        },
        processMatchSwapping: function (match2) {
            var scheduler = $("#scheduler").data("kendoScheduler");
            var dataSource = scheduler.dataSource;

            if (dataSource) {
                var eventId = match2.EventID;
                var roundId = match2.RoundNumber;
                var taskId = match2.TaskId;
                var matchesData = dataSource.data();
                var swapStartMatch = $.grep(matchesData, function (m) {
                    return m.IsSwapStarted == true;
                });

                var match1 = swapStartMatch[0];
                if (!match1) {
                    match1 = calendarViewModel.getItemFromSwappingArrayByEventAndRound(eventId, roundId, taskId);
                }

                if ((match1.IsCustomEventMatch && match1.LocationName == "TBD" && !match2.IsCustomEventMatch) ||
                    (match2.IsCustomEventMatch && match2.LocationName == "TBD" && !match1.IsCustomEventMatch)) {
                    alert("You can't swap match with TBD location");
                    return;
                }

                calendarViewModel.updateTheSwappedMatchesWithinDataSource(dataSource, match1, match2);
                calendarViewModel.updateTheMatchSwappingArray(match1);
                calendarViewModel.updateTheMatchSwappingArray(match2);

                var date = scheduler.date();
                if (!swapStartMatch[0] && kendo.toString(match1.Date, "MM/dd/yyyy") == kendo.toString(date, "MM/dd/yyyy")) {
                    dataSource.add(match1);
                }

                if (kendo.toString(match2.Date, "MM/dd/yyyy") != kendo.toString(date, "MM/dd/yyyy")) {
                    dataSource.remove(match2);
                }

                calendarViewModel.updateStatusOfOtherMatches(dataSource, match1, false);
                calendarViewModel.enableEditModeForEventMatches(false);
            }
        },

        getItemFromSwappingArrayByEventAndRound: function (eventId, roundNumber, taskId) {
            var swapmatchesArray = calendarViewModel.get("swappedMatches");

            if (swapmatchesArray) {
                var swappedMatchItem = $.grep(swapmatchesArray, function (m) {
                    return m.Matches[0].IsSwapStarted == true;
                });

                if (swappedMatchItem.length <= 0) return null;
                var matches = swappedMatchItem[0].Matches;
                var currentMatch = $.grep(matches, function (m) {
                    return m.IsSwapStarted == true;
                });

                if (currentMatch.length > 0) {
                    return currentMatch[0];
                } else {
                    return null;
                }
            }

            return null;
        },

        getItemFromSwappingArray: function (match) {
            var swapmatchesArray = calendarViewModel.get("swappedMatches");

            if (swapmatchesArray) {
                var taskId = match.TaskId;
                var swappedMatchItem = $.grep(swapmatchesArray, function (m) {
                    return m.TaskId == taskId;
                });

                if (swappedMatchItem.length <= 0) return null;
                var matches = swappedMatchItem[0].Matches;
                var currentMatch = $.grep(matches, function (m) {
                    return m.TaskId == match.TaskId;
                });

                if (currentMatch.length > 0) {
                    return currentMatch[0];
                } else {
                    return null;
                }
            }
            return null;
        },
        //#endregion-------------------
        getObjectsFromArray: function (array, columnName, value) {
            var result = [];
            for (var i = 0; i < array.length; i++) {
                var item = array[i];
                if (item[columnName] == value) {
                    result.push(item);
                }
            }
            return result;
        },
        updateTheMatchSwappingArray: function (match) {
            var matchToStore = match;

            var swapmatchesArray = calendarViewModel.get("swappedMatches");
            if (!swapmatchesArray) return;

            var taskId = matchToStore.TaskId;

            var swappedMatchesItems = $.grep(swapmatchesArray, function (m) {
                return m.TaskId == taskId;
            });

            if (swappedMatchesItems.length > 0) {

                var matchesList = swappedMatchesItems[0].Matches;

                var matches = $.grep(matchesList, function (m) {
                    return m.TaskId == taskId;
                });

                var matchToReplace = matches[0];
                calendarViewModel.updateTheMatchesDetails(matchToReplace, match);
                matchToReplace.IsSwapStarted = match.IsSwapStarted;
                matchToReplace.IsSwapOn = match.IsSwapOn;

            } else {
                var swapMatch = {
                    TaskId: matchToStore.TaskId,
                    IsSwapStarted: matchToStore.IsSwapStarted,
                    Matches: [],
                };

                swapMatch.Matches.push(matchToStore);
                swapmatchesArray.push(swapMatch);

                return;
            }
        },
        disableEditModeForSwap: function (e) {
            var isSwap = calendarViewModel.get("swapModeEnabled");
            if (isSwap == true) {
                e.preventDefault();

                return;
            }
        },

        /*----- End  :  Swap Matches ---*/

        /*------Start Mass Shift--------*/

        isMassShiftOn: true,
        isMassShiftStarted: false,
        massShiftModel: {},
        scheduleDetailsObj: {},
        massShiftLinkText: "Start Mass Shift",
        setMassShift: function () {
            var scheduleData = new sSchedule_ViewModels_ScheduleData();
            scheduleData.createNewDetails();

            calendarViewModel.set("scheduleDetailsObj", scheduleData.scheduleDataModel.get("scheduleDetails"));
            var scheduleDetailsObj = calendarViewModel.get("scheduleDetailsObj");

            var massShiftView = new kendo.View("massShift-template");
            var massShiftViewModel = new sSchedule_ViewModels_MassShiftViewModel(scheduleData.scheduleDataModel.get("scheduleDetails"));

            var massShiftModel = massShiftViewModel.massShiftModel;
            massShiftView.model = massShiftModel;
            $("#massShift").remove();
            massShiftView.render("#massShift");

            calendarViewModel.set("massShiftModel", massShiftModel);
        },
        setMatches: function (matches, massShiftModel) {
            var matchesData = [];

            for (i = 0; i < matches.length; i++) {
                var match = matches[i];
                var isMatchSelectedForMassShift = match.get("IsMatchSelectedForMassShift");
                if (isMatchSelectedForMassShift == false) {
                    continue;
                }

                var massShiftMatch = new matchModel();
                massShiftMatch.set("MatchID", match.TaskId);
                massShiftMatch.set("Date", match.Date);
                massShiftMatch.set("StartTime", match.StartTime);
                massShiftMatch.set("EndTime", match.EndTime);
                massShiftMatch.set("MatchOrderNo", match.MatchOrderNo);
                massShiftMatch.set("RoundNumber", match.RoundNumber);
                massShiftMatch.set("FieldID", match.FieldID);
                massShiftMatch.set("HomeTeamID", match.HomeTeamID);
                massShiftMatch.set("AwayTeamID", match.AwayTeamID);
                massShiftMatch.set("Team1", match.Team1);
                massShiftMatch.set("Team2", match.Team2);
                massShiftMatch.set("LocationID", match.LocationID);
                massShiftMatch.set("LocationName", match.LocationName);
                massShiftMatch.set("FieldName", match.FieldName);
                massShiftMatch.set("Team1Type", match.Team1Type);
                massShiftMatch.set("Team2Type", match.Team2Type);
                matchesData.push(massShiftMatch);
            }

            var matchesForMassShift = massShiftModel.get("matchesForMassShift");
            matchesForMassShift.data(matchesData);
        },
        startMassShift: function () {
            if (calendarViewModel.currentCalendarView != 'day') {
                return;
            }

            var scheduler = $("#scheduler").data("kendoScheduler");
            var matches = scheduler.dataSource.data();

            var isMassShiftStarted = calendarViewModel.get("isMassShiftStarted");
            if (isMassShiftStarted == false) {
                calendarViewModel.set("isMassShiftStarted", true);

                calendarViewModel.set("massShiftLinkText", "Shift Selected Matches");

                for (var i = 0; i < matches.length; i++) {
                    matches[i].set("IsMassShiftOn", true);
                }
            } else {

                var massShiftModel = calendarViewModel.get("massShiftModel");
                var massshiftWindow = $("#massshiftWindow");

                if (massshiftWindow.length <= 0) {
                    calendarViewModel.setMassShift(massShiftModel);
                    massshiftWindow = $("#massshiftWindow");
                    massShiftModel = calendarViewModel.get("massShiftModel");
                }

                if (!massshiftWindow.data("kendoWindow")) {
                    massshiftWindow.kendoWindow({
                        width: 950,
                        height: 600,
                        title: "Mass Shift",
                        modal: true,
                        actions: [
                            "Close"
                        ]
                    });
                }

                calendarViewModel.setMatches(matches, massShiftModel);
                massShiftModel.setMassShiftDefaultDate(scheduler);
                massshiftWindow.data("kendoWindow").center().open();
            }
        },
        /*------End Mass Shift--------*/
        checkFieldAvailability: function () {
            //activeLocationsDataSource.read();
            var fieldAvailabilityView = new kendo.View("showFieldAvailability-template");
            var fieldAvailabilityModel = fieldAvailability.fieldAvailabilityModel;
            fieldAvailabilityView.model = fieldAvailabilityModel;
            fieldAvailabilityView.render(jQuery("#displayFieldAvailabilityDiv"));
            fieldAvailabilityModel.activeLocationsDataSource.read();
            var fieldAvailabilityWindow = $("#fieldAvailabilityWindow");
            if (!fieldAvailabilityWindow.data("kendoWindow")) {
                fieldAvailabilityWindow.kendoWindow({
                    width: "850px",
                    title: "Check Field Availability",
                    modal: true,
                    actions: [
                        "Close"
                    ],
                    close: function () { }
                });
                kendo.bind(fieldAvailabilityWindow, fieldAvailabilityModel);
            }

            var fieldsSelectionBox = $("#multiSelectLocationFieldTreeView").data("kendoMultiSelectTreeViewSearchBox");
            var checkedLocationNodes = [];
            checkedLocationNodes = fieldsSelectionBox.getSelectedNodes();

            //Selected Locations and Fields.
            var selectedLocationIds = [];
            if (checkedLocationNodes.length > 0) {
                var fieldLen = checkedLocationNodes.length;

                for (var j = 0; j < fieldLen; j++) {
                    var locationId = checkedLocationNodes[j].ParentId;
                    if (locationId && selectedLocationIds.indexOf(locationId) < 0) {
                        selectedLocationIds.push(locationId);
                    }
                }
            }
            $(".hdnSelectedLocation").val('');
            if (selectedLocationIds.length == 1) {
                $(".hdnSelectedLocation").val(selectedLocationIds[0]);
            }

            $dialog = fieldAvailabilityWindow.data("kendoWindow");
            $dialog.wrapper.addClass("scom tournament-popup");
            fieldAvailabilityWindow.data("kendoWindow").center().open();
            jQuery('.k-in').css('text-decoration', 'underline');
        },
        /*End==Fiedl Availability*/

        /*==Start Back Link==*/
        getScheduleTabUrl: function () {
            var manageSchedulesTabUrl = jQuery('.manageSchedulesTabUrl').val();
            if (manageSchedulesTabUrl == '')
                return '';

            return manageSchedulesTabUrl + '#/schedules';
        },
        isBackLinkVisible: false,
        /*==End Back Link==*/

        /*Start isInEditMode*/
        isInEditMode: true,
        /*End isInEditMode*/

        /*Start - Export Calendar*/
        exportToICalendar: function (e) {
            var paramList = calendarViewModel.getParametersForSelectedEventsAndFields();
            var portalId = paramList["portalId"];
            var paramString = {
                portalId: portalId,
                selectedEvents: paramList["selectedEvents"],
                selectedFields: paramList["selectedFields"],
                selectedTeams: paramList["selectedTeams"],
                currentDate: paramList["currentDate"],
                currentCalendarView: paramList["currentCalendarView"],
                isPosted: paramList["isPosted"],
                isToCheckForDateRange: paramList["isToCheckForDateRange"],
                timeZone: paramList["timeZone"],
            }
            /*ajax call to generate import matches url*/
            var serviceRootUrl = common.getServiceRootUrl();

            serviceRootUrl += "Calendar/GenerateExportMatchesUrl";
            jQuery.ajax({
                url: serviceRootUrl,
                type: 'POST',
                data: JSON.stringify(paramString),
                contentType: "application/json",
                success: function (d) {
                    if (d == null) {
                        return;
                    }
                    calendarViewModel.showExportMatchesUrlDialog(portalId, d.id, d.key, d.DomainName, d.instanceKey, d.isexportfromicalendar);
                },
                error: function () {

                }
            });
        },

        showExportMatchesUrlDialog: function (
            portalId, id, key, domainName, instancekey, isExportFromICalendarService) {
            if (domainName == null) {
                return;
            }

            if (domainName.length < 1) {
                return;
            }

            var exportMatchesModel = exportMatchesToICalendarl.exportMatchesToICalendarlModel;
            var exportICalendarHandlerUrl = "";

            if (isExportFromICalendarService) {
                exportICalendarHandlerUrl = "webcal://" + domainName + "?instancekey=" + instancekey + "&portalId=" + portalId + "&id=" + id + "&key=" + key;
            } else {
                exportICalendarHandlerUrl = "webcal://" + domainName + "/DesktopModules/sSchedule/sSchedule.Web/Services/ExportToICalendar.ashx?portalId=" + portalId + "&id=" + id + "&key=" + key + "&format=ical";
            }

            exportMatchesModel.set("exportICalendarHandlerUrl", exportICalendarHandlerUrl);

            var exportMatchesView = new kendo.View("exportMatches-template");
            exportMatchesView.render(jQuery("#displayExportMatchesDiv"));

            var exportMatchesWindow = $("#exportMatchesWindow");
            if (!exportMatchesWindow.data("kendoWindow")) {
                exportMatchesWindow.kendoWindow({
                    width: "850px",

                    title: "Sync Events",
                    modal: true,
                    actions: [
                        "Close"
                    ],
                    close: function () {
                        var dialog = $("#exportMatchesWindow").data("kendoWindow");
                        dialog.destroy();
                    }
                });
                kendo.bind(exportMatchesWindow, exportMatchesModel);
            }

            exportMatchesWindow.data("kendoWindow").center().open();
            $("#exportMatchesWindow").data("kendoWindow").wrapper.addClass("scom tournament-popup");

            jQuery('#exportICalendarHandlerUrlTextArea').focus();
            jQuery('#exportICalendarHandlerUrlTextArea').select();
        },
        /*End - Export Calendar*/

        /*Print Calendar*/
        isAgendaViewOn: false,

        printSchedule: function () {
            if (calendarViewModel.currentCalendarView != 'agenda') {
                return;
            }

            var contentDiv = jQuery('.k-scheduler-content');
            var contentDivHeight = contentDiv.height();
            jQuery(contentDiv).css('height', 'auto');

            var ifrm = document.getElementById('printScheduleIframe');
            var content = document.getElementById('schedulerDiv').innerHTML;

            /* Determine what DOM model to use */
            var printDoc = (ifrm.contentWindow || ifrm.contentDocument);
            if (printDoc.document) {
                printDoc = printDoc.document;
            }

            /* Create a HTML document to go into the iFrame */
            /* The title will appear on the printed document */
            printDoc.write("<html><head><title>title</title>");
            printDoc.write("<link rel='stylesheet' type='text/css' href='/resources/shared/kendo/styles/kendo.common.min.css' media='print' />");
            printDoc.write("<link rel='stylesheet' type='text/css' href='/resources/bsb.controls/kendo/kendo.metro.min.css' media='print' />");

            printDoc.write("</head><body onload='this.focus(); this.print();'>");
            printDoc.write(content + "</body></html>");
            printDoc.close();

            jQuery(contentDiv).css('height', contentDivHeight + 'px');
        },
        regionDs: [],
        selectedRegion: "",
        eventName: "",
        locationName: "",
        locationAddress: "",
        city: "",
        zipcode: "",
        isAllDayEvent: false,
        isReminderMailstatus: true,
        isDisableStartTimeEndTime: false,
        getCustomEventDTO: function () {
            var eventName = $("#EventName").val();
            var eventDate = $("#datePicker").data("kendoDatePicker").value();
            var locationName = $("#LocationName").val();
            var locationAddress = $("#LocationAddress").val();
            var locationId = $("#EditLocationList_1").data("kendoDropDownList").value();
            var fieldId = $("#EditFieldList_1").data("kendoDropDownList").value();
            var city = $("#CityName").val();
            var regionId = $("#countryCode").val();
            var postalCode = $("#postalCode").val();
            var startTime = $("#timePicker_Start").data("kendoTimePicker").value();
            var endTime = $("#timePicker_End").data("kendoTimePicker").value();
            var description = $("#textForDescription").val();
            var customRegionCode = $("#countryCode option:selected").text();
            var allDayCheckBox = $("#allDayCheckBox").is(':checked');
            var chkIsReminderEmailSend = $("#chkIsReminderEmailSend").is(':checked');
            var matchId = calendarViewModel.get("matchId");
            var isClubsLocation = $('#radioDropdowns').is(':checked') ? true : false;

            eventDate = kendo.toString(eventDate, 'MM/dd/yyyy');

            if (allDayCheckBox == true) {
                startTime = "12:00";
                endTime = "11:45";
            }
            else {
                startTime = kendo.toString(new Date(startTime), "HH:mm");
                endTime = kendo.toString(new Date(endTime), "HH:mm");
            }

            var eventdetail = {

                PortalId: $(".portalIdHidden").val(),
                EventName: eventName,
                LocationName: locationName,
                LocationAddress: locationAddress,
                locationId: locationId,
                fieldId, fieldId,
                City: city,
                RegionId: regionId,
                Zipcode: postalCode,
                StartTime: startTime,
                EndTime: endTime,
                IsAllDay: allDayCheckBox,
                EventDate: eventDate,
                IsReminderMailSend: chkIsReminderEmailSend,
                Description: description,
                RegionCode: customRegionCode,
                MatchID: matchId,
                IsClubsLocation: isClubsLocation
            };

            return eventdetail;
        },
        showSiteWideEventPopup: function (e) {
            var siteWideEvent = new kendo.View("siteWide-template");
            siteWideEvent.render(jQuery("#siteWideTemplateRenderDiv"));
            var regionData = calendarViewModel.get("regionDs");
            if (regionData.length < 1) {
                calendarViewModel.getAllRegions(function () {
                    calendarViewModel.resetCustomEvents();
                    $("#EditLocationList_1").data("kendoDropDownList").value(e.event.LocationID);
                    $("#EditFieldList_1").data("kendoDropDownList").value(e.event.FieldID);
                });
            } else {
                calendarViewModel.resetCustomEvents();
            }

            var locationDropDown = $("#EditLocationList_1");
            var fieldDropDown = $("#EditFieldList_1");

            var siteWideWindow = $("#siteWideWindow");
            if (!siteWideWindow.data("kendoWindow")) {
                siteWideWindow.kendoWindow({
                    width: "594px",
                    height: "760px",
                    title: "Add Site Wide Event",
                    modal: true,
                    actions: [
                        "Close"
                    ],
                    close: function () {
                        var dialog = $("#siteWideWindow").data("kendoWindow");
                        calendarViewModel.set("siteWideEventId", 0);
                        calendarViewModel.set("tempSiteWideClubsLocation", "");
                        calendarViewModel.set("tempSiteWideClubsField", "");
                        dialog.destroy();
                    }
                });
                kendo.bind(siteWideWindow, calendarViewModel);
            }

            $dialog = siteWideWindow.data("kendoWindow");
            $dialog.wrapper.addClass("scom tournament-popup sitewide-popup");
            calendarViewModel.set("matchId", null);
            $(".cancelsitewide").show();
            $(".deletesitewide").hide();
            if (e.event != undefined) {

                $("#EventName").val(e.event.EventName);
                calendarViewModel.set("siteWideEventId", e.event.EventID);

                if (!e.event.EventDetail.IsClubsLocation) {
                    $("#LocationName").val(e.event.LocationName);
                }

                fieldsListDs.filter([]);
                fieldsListDs.filter({ field: "LocationID", operator: "eq", value: e.event.LocationID });
                calendarViewModel.set("editFieldDataSource", fieldsListDs.view());


                if (e.event.EventDetail.IsClubsLocation) {
                    document.getElementById('radioDropdowns').checked = true;
                    document.getElementById('radioTextbox').checked = false;
                } else {
                    document.getElementById('radioDropdowns').checked = false;
                    document.getElementById('radioTextbox').checked = true;
                }
                $("#LocationAddress").val(e.event.EventDetail.Street);
                $("#CityName").val(e.event.EventDetail.City);
                $("#postalCode").val(e.event.EventDetail.PostalCode);
                $("#textForDescription").val(e.event.EventDetail.Description);
                setTimeout(function () {
                    $("#datePicker").data("kendoDatePicker").value(e.event.Date);
                    calendarViewModel.set("selectedRegion", e.event.EventDetail.IsSiteWideEventWithLocation ? regionData[0].RegionId : e.event.EventDetail.RegionId);
                    $("#timePicker_Start").data("kendoTimePicker").value(e.event.start);
                    $("#timePicker_End").data("kendoTimePicker").value(e.event.end);
                }, 500);

                if (e.event.isAllDay) {
                    $('#allDayCheckBox').prop('checked', true);
                    calendarViewModel.set("isDisableStartTimeEndTime", true);
                }
                else {
                    $('#allDayCheckBox').prop('checked', false);
                    calendarViewModel.set("isDisableStartTimeEndTime", false);
                }
                if (e.event.IsReminderMailSend) {
                    $('#chkIsReminderEmailSend').prop('checked', true);
                }
                else {
                    $('#chkIsReminderEmailSend').prop('checked', false);
                }
                $(".cancelsitewide").hide();
                $(".deletesitewide").show();
                $('.k-window-title').text("Edit Site Wide Event");

                if (e.event.EventDetail.IsSiteWideEventWithLocation) {
                    calendarViewModel.set("savedSiteWideclubsLocation", e.event.LocationID);
                    calendarViewModel.set("savedSiteWideclubsField", e.event.FieldID);
                }
                else {
                    calendarViewModel.set("savedSiteWideclubsLocation", "");
                    calendarViewModel.set("savedSiteWideclubsField", "");
                }

                calendarViewModel.set("matchId", e.event.TaskId);
            }

            if (e.event == undefined) {
                locationDropDown.data("kendoDropDownList").value("");
                fieldDropDown.data("kendoDropDownList").value("");

                calendarViewModel.set("savedSiteWideclubsLocation", "");
                calendarViewModel.set("savedSiteWideclubsField", "");

                fieldsListDs.filter([]);
                fieldsListDs.filter({ field: "LocationID", operator: "eq", value: locationDropDown.data("kendoDropDownList").value() });
                calendarViewModel.set("editFieldDataSource", fieldsListDs.view())
            }

            siteWideWindow.data("kendoWindow").center().open();
            $("#siteWideWindow").data("kendoWindow").wrapper.addClass("scom tournament-popup");
            beautifyToggleButton("input[data-role=\"beautify-toggle-button\"]");

            locationsListDs.filter([]);

            locationDropDown.kendoDropDownList({
                dataTextField: "Name",
                dataValueField: "LocationID",
                dataSource: locationsListDs,
                optionLabel: "",
                change: function () {

                    var locationId = locationDropDown.data("kendoDropDownList").value();
                    var locationText = locationDropDown.data("kendoDropDownList").text();

                    locationId = locationText === 'Select Location' ? 0 : locationId;

                    fieldsListDs.filter([]);

                    fieldsListDs.filter({ field: "LocationID", operator: "eq", value: locationId });
                    calendarViewModel.set("editFieldDataSource", fieldsListDs.view());

                    calendarViewModel.set("tempSiteWideClubsLocation", locationId);

                    $("#EditFieldList_1").data("kendoDropDownList").value('');
                    $("#EditFieldList_1 + span").hide();

                },
                index: 0,
            });

            fieldDropDown.kendoDropDownList({
                dataTextField: "Name",
                dataValueField: "LocationID",
                dataSource: calendarViewModel.get("editFieldDataSource"),
                change: function () {
                    calendarViewModel.set("tempSiteWideClubsField", fieldDropDown.data("kendoDropDownList").value());
                },
                index: 0,
            })

            $("#EditLocationList_1-list .k-list-optionlabel").css("background-color", "white");
            $("#EditLocationList_1-list .k-list-optionlabel").css("border-color", "white");
            $("#EditLocationList_1-list .k-list-optionlabel").css("color", "#48749B");

            $("#EditFieldList_1-list .k-list-optionlabel").css("background-color", "white");
            $("#EditFieldList_1-list .k-list-optionlabel").css("border-color", "white");
            $("#EditFieldList_1-list .k-list-optionlabel").css("color", "#48749B");

            $(siteWideWindow).kendoValidator({
                validateOnBlur: true,
                rules: {
                    ruleValidDate: function (input) {
                        if (input.is("[name=datePicker]")) {
                            var currentDate = new Date();
                            var date = kendo.parseDate(kendo.format('{0:d}', input.val()));
                            currentDate = kendo.parseDate(kendo.format('{0:d}', currentDate));
                            if (date < currentDate) {
                                return false;
                            } else {
                                return true;
                            }
                        }
                        return true;
                    },
                    ruleValidEventName: function (input) {
                        if (input.is("[name=EventName]")) {
                            var chaeacterReg = /^[A-Za-z0-9;:+=?!@$%\*\s#&/\\_''‘’)(.,\-\\[\]]*$/;
                            var eventName = $("#EventName").val().trim();
                            if (!chaeacterReg.test(eventName)) {
                                return false;
                            } else {
                                return true;
                            }
                        }
                        return true;
                    },
                    ruleValidLocationName: function (input) {
                        if (input.is("[name=LocationName]")) {
                            if (!$('#radioDropdowns').is(':checked')) {
                                var chaeacterReg = /^[A-Za-z0-9;:+=?!@$%\*\s#&/\\_''‘’)(.,\-\\[\]]*$/;
                                var locationName = $("#LocationName").val().trim();
                                if (!chaeacterReg.test(locationName)) {
                                    return false;
                                } else {
                                    return true;
                                }
                            }
                        }
                        return true;
                    },
                    ruleValidLocationNameRequire: function (input) {
                        if (input.is("[name=LocationName]")) {
                            if (!$('#radioDropdowns').is(':checked')) {
                                var locationName = $("#LocationName").val().trim();
                                if (locationName == "") {
                                    return false;
                                } else {
                                    return true;
                                }
                            }
                        }
                        return true;
                    },
                    ruleValidEventNameRequire: function (input) {
                        if (input.is("[name=EventName]")) {
                            var eventName = $("#EventName").val().trim();
                            if (eventName == "") {
                                return false;
                            } else {
                                return true;
                            }
                        }
                        return true;
                    },
                    ruleValidLocationAdress: function (input) {
                        if (input.is("[name=LocationAddress]")) {
                            if (!$('#radioDropdowns').is(':checked')) {
                                var chaeacterReg = /^[A-Za-z0-9;:+=?!@$%\*\s#&/\\_''‘’)(.,\-\\[\]]*$/;
                                var locationAddress = $("#LocationAddress").val().trim();
                                if (!chaeacterReg.test(locationAddress)) {
                                    return false;
                                } else {
                                    return true;
                                }
                            }
                        }
                        return true;
                    },
                    ruleValidCity: function (input) {
                        if (input.is("[name=CityName]")) {
                            if (!$('#radioDropdowns').is(':checked')) {
                                var chaeacterReg = /^[A-Za-z0-9;:+=?!@$%\*\s#&/\\_''‘’)(.,\-\\[\]]*$/;
                                var cityName = $("#CityName").val().trim();
                                if (!chaeacterReg.test(cityName)) {
                                    return false;
                                } else {
                                    return true;
                                }
                            }
                        }
                        return true;
                    },
                    ruleValidDescription: function (input) {
                        if (input.is("[name=Description]")) {
                            var chaeacterReg = /^[A-Za-z0-9;:+=?!@$%\*\s#&/\\_''‘’)(.,\-\\[\]]*$/;
                            var description = $("#textForDescription").val().trim();
                            if (!chaeacterReg.test(description)) {
                                return false;
                            } else {
                                return true;
                            }
                        }
                        return true;
                    },

                    ruleValidZip: function (input) {
                        if (input.is("[name=postalCode]")) {
                            if (!$('#radioDropdowns').is(':checked')) {
                                var postaCode = $("#postalCode").val().trim();
                                if (postaCode == "")
                                    return true;
                                var isValidZip = /(^\d{5}$)|(^\d{5}-\d{4}$)/.test(postaCode);
                                if (!isValidZip) {
                                    return false;
                                } else {
                                    return true;
                                }
                            }
                        }
                        return true;
                    },
                    ruleValidStartTimeRequire: function (input) {
                        if (input.is("[name=timePicker_Start]")) {
                            var allDayCheckBox = $("#allDayCheckBox").is(':checked');
                            if (allDayCheckBox == true) {
                                return true;
                            }
                            var startTime = $("#timePicker_Start").val().trim();
                            if (startTime == "") {
                                return false;
                            } else {
                                return true;
                            }
                        }
                        return true;
                    },
                    ruleValidEndTimeRequire: function (input) {
                        if (input.is("[name=timePicker_End]")) {
                            var allDayCheckBox = $("#allDayCheckBox").is(':checked');
                            if (allDayCheckBox == true) {
                                return true;
                            }
                            var endTime = $("#timePicker_End").val().trim();
                            if (endTime == "") {
                                return false;
                            } else {
                                return true;
                            }
                        }
                        return true;
                    },
                    ruleValidStartTime: function (input) {
                        if (input.is("[name=timePicker_Start]")) {
                            var allDayCheckBox = $("#allDayCheckBox").is(':checked');
                            if (allDayCheckBox == true) {
                                return true;
                            }
                            var startTime = parseInt(kendo.toString(kendo.parseDate(input.val()), 'mm'));
                            if (common.isValidMinute(startTime)) {
                                return true;
                            } else {
                                return false;
                            }
                        }
                        return true;
                    },
                    ruleValidEndTime: function (input) {
                        if (input.is("[name=timePicker_End]")) {
                            var allDayCheckBox = $("#allDayCheckBox").is(':checked');
                            if (allDayCheckBox == true) {
                                return true;
                            }
                            var endTime = parseInt(kendo.toString(kendo.parseDate(input.val()), 'mm'));
                            if (common.isValidMinute(endTime)) {
                                return true;
                            } else {
                                return false;
                            }
                        }
                        return true;
                    },
                    ruleValidEndTimeAsPerStartTime: function (input) {
                        if (input.is("[name=timePicker_End]")) {
                            var strStartTime = $("#timePicker_Start").data("kendoTimePicker").value();
                            var strEndTime = $("#timePicker_End").data("kendoTimePicker").value();

                            var startTime = kendo.toString(strStartTime, "HH:mm tt");
                            var endTime = kendo.toString(strEndTime, "HH:mm tt");
                            var allDayCheckBox = $("#allDayCheckBox").is(':checked');
                            if (allDayCheckBox == true) {
                                return true;
                            }
                            if (startTime > endTime || startTime == endTime) {
                                return false;
                            }
                        }
                        return true;
                    },
                    ruleInvalidZip: function (input) {
                        if (input.is("[name=postalCode]")) {
                            if (!$('#radioDropdowns').is(':checked')) {
                                var postaCode = $("#postalCode").val().trim();
                                if (postaCode == "00000") {
                                    return false;
                                } else {
                                    return true;
                                }
                            }
                        }
                        return true;
                    },
                    editlocationListRequired: function (input) {
                        if ($('#radioDropdowns').is(':checked')) {
                            if (input.is("[name=editlocationList]")) {
                                return input[0].selectedIndex > 0;
                            }
                        }
                        return true;
                    },
                    editfieldListRequired: function (input) {
                        if ($('#radioDropdowns').is(':checked')) {
                            if (input.is("[name=editfieldList]")) {
                                return input[0].selectedIndex > 0;
                            }
                        }
                        return true;
                    }
                },
                messages: {
                    ruleValidEndTimeAsPerStartTime: "End time must be after the start time.",
                    ruleValidDate: "Please select or enter a valid start date.",
                    ruleValidEventName: "Input can contain letters, numbers, spaces, and the characters ! @ $ % * [ ] , + = _ ; \ ? : ( ) # & / ' . -",
                    ruleValidLocationName: "Input can contain letters, numbers, spaces, and the characters ! @ $ % * [ ] , + = _ ; \ ? : ( ) # & / ' . -",
                    ruleValidLocationNameRequire: "Please provide Location Name.",
                    ruleValidEventNameRequire: "Please provide Event Name.",
                    ruleValidLocationAdress: "Input can contain letters, numbers, spaces, and the characters ! @ $ % * [ ] , + = _ ; \ ? : ( ) # & / ' . -",
                    ruleValidCity: "Input can contain letters, numbers, spaces, and the characters ! @ $ % * [ ] , + = _ ; \ ? : ( ) # & / ' . -",
                    ruleValidDescription: "Input can contain letters, numbers, spaces, and the characters ! @ $ % * [ ] , + = _ ; \ ? : ( ) # & / ' . -",
                    ruleValidZip: "Invalid Zip Code!",
                    ruleValidStartTimeRequire: "Invalid, must be formatted ##:## AM/PM",
                    ruleValidEndTimeRequire: "Invalid, must be formatted ##:## AM/PM",
                    ruleValidStartTime: "Only 00,15,30,45 minutes are allowed time.",
                    ruleValidEndTime: "Only 00,15,30,45 minutes are allowed time.",
                    ruleInvalidZip: "Invalid Zip Code!",
                    editlocationListRequired: "Please select a location from the dropdown",
                    editfieldListRequired: "Please select a field from the dropdown"
                }
            }).data("kendoValidator");

            function toggleSections() {
                if ($('#radioTextbox').is(':checked')) {
                    $('#sitewideTextboxSection').show();
                    $('#sitewideDropdownSection').hide();
                    $("#EditLocationList_1").data("kendoDropDownList").value("");
                    $("#EditFieldList_1").data("kendoDropDownList").value("");
                } else if ($('#radioDropdowns').is(':checked')) {
                    $('#sitewideTextboxSection').hide();
                    $('#sitewideDropdownSection').show();
                    var locationId = calendarViewModel.tempSiteWideClubsLocation != "" ? calendarViewModel.tempSiteWideClubsLocation : calendarViewModel.savedSiteWideclubsLocation;
                    var fieldId = calendarViewModel.tempSiteWideClubsField != "" ? calendarViewModel.tempSiteWideClubsField : calendarViewModel.savedSiteWideclubsField;
                    $("#EditLocationList_1").data("kendoDropDownList").value(locationId);
                    $("#EditFieldList_1").data("kendoDropDownList").value(fieldId);
                }
            }

            $(document).ready(function () {
                toggleSections();
                $('input[name="toggleOption"]').change(function () {
                    toggleSections();
                });
            });

            calendarViewModel.initGoogleMap();
        },

        getAllRegions: function (readCallback) {
            var regionData = calendarViewModel.get("regionDs");
            if (regionData.length < 1) {
                getRegionsDataSource(function (data) {
                    calendarViewModel.set("regionDs", data);
                    readCallback(data);
                    if (data.length > 0)
                        calendarViewModel.set("selectedRegion", data[0].RegionId);
                });
            }
        },

        resetCustomEvents: function () {
            $("#datePicker").data("kendoDatePicker").value(new Date());
            $("#timePicker_Start").data("kendoTimePicker").value("08:00 AM");
            $("#timePicker_End").data("kendoTimePicker").value("09:00 AM");
            $("#EditLocationList_1").data("kendoDropDownList").value("");
            $("#EditFieldList_1").data("kendoDropDownList").value("");
            calendarViewModel.isReminderMailstatus = true;
            calendarViewModel.isAllDayEvent = false;
            var regionData = calendarViewModel.get("regionDs");
            calendarViewModel.set("selectedRegion", regionData[0].RegionId);
            calendarViewModel.eventName = "";
            calendarViewModel.locationName = "";
            calendarViewModel.locationAddress = "";
            calendarViewModel.city = "";
            calendarViewModel.zipcode = "";
            calendarViewModel.isDisableStartTimeEndTime = false;
            $("#allDayCheckBox").trigger("elementRebind");
        },
        onSaveClick: function () {
            calendarViewModel.set("isSavedFromClubLocation", true);
            var siteWideWindow = $("#siteWideWindow");
            var validator = siteWideWindow.data("kendoValidator");
            var isValid = validator.validate();

            if ($('#radioDropdowns').is(':checked') && !isValid) {
                return;
            }

            var siteWideWindow = $("#siteWideWindow");
            var validator = siteWideWindow.data("kendoValidator");
            var isValid = validator.validate();
            if (isValid == false) {
                return;
            }
            $('.bsb-btn').dblclick(false);
            kendo.ui.progress($("#siteWideWindow"), true);
            customEventDetails = calendarViewModel.getCustomEventDTO();

            var isClubLocation = $('#radioDropdowns').is(':checked') ? true : false;

            if (isClubLocation) {
                customEventDetails.LocationName = $("#EditLocationList_1").data("kendoDropDownList").text();
                customEventDetails.FieldName = $("#EditFieldList_1").data("kendoDropDownList").text();
                customEventDetails.RegionId = "";
                customEventDetails.RegionCode = "";
            }

            saveCustomEvent(customEventDetails, isClubLocation, function (e) {
                kendo.ui.progress($("#siteWideWindow"), false);
                $("#siteWideWindow").data("kendoWindow").close();
                calendarViewModel.refreshSchedulerDataSourceForSelectedEvents();

            });
        },

        onCancelClick: function () {
            $("#siteWideWindow").data("kendoWindow").close();
        },
        onDeleteClick: function () {
            customEventDetails = calendarViewModel.getCustomEventDTO();

            deleteCustomEvent(customEventDetails, function (e) {
                calendarViewModel.refreshSchedulerDataSourceForSelectedEvents();
            });

            $("#siteWideWindow").data("kendoWindow").close();
        },
        isAllDayChanged: function () {

            var allDayCheckBox = $("#allDayCheckBox").is(':checked');
            var siteWideWindow = $("#siteWideWindow");
            var validator = siteWideWindow.data("kendoValidator");
            if (allDayCheckBox == true) {
                calendarViewModel.set("isDisableStartTimeEndTime", true);
                validator.validateInput($("input[name=timePicker_End]"));
                validator.validateInput($("input[name=timePicker_Start]"));
            }
            else {
                calendarViewModel.set("isDisableStartTimeEndTime", false);
                validator.validateInput($("input[name=timePicker_End]"));
                validator.validateInput($("input[name=timePicker_Start]"));
            }
        },
        dateOpen: function (e) {
            var dtPicker = e.sender.element;
            var datePicker = dtPicker.data("kendoDatePicker");
            datePicker.min(new Date());
        },
        initGoogleMap: function () {
            if (!window.google || !window.google.maps) {
                var googleURLShortnerAPIKey = $('.googleMapApikey').val();
                var urlShortnerBaseURL = 'https://maps.googleapis.com/maps/api/js?&key=' + googleURLShortnerAPIKey + '&v=3.exp' + '&libraries=places';
                if (googleURLShortnerAPIKey.length > 0) {
                    $.ajax({
                        type: "GET",
                        url: urlShortnerBaseURL,
                        dataType: 'jsonp',
                        success: function (data) {
                            calendarViewModel.initializeGoogleAutocompleteAddress();
                        }
                    });
                }
            }
            else {
                calendarViewModel.initializeGoogleAutocompleteAddress();
            }
        },
        initializeGoogleAutocompleteAddress: function () {
            autocomplete = new google.maps.places.Autocomplete(
                (document.getElementById('LocationAddress')),
                { types: ['geocode'] });

            google.maps.event.addListener(autocomplete, 'place_changed',
                function () {
                    calendarViewModel.fillAddressInField();
                });
        },
        fillAddressInField: function () {
            var place = autocomplete.getPlace();
            for (var i = 0; i < place.address_components.length; i++) {
                var addressType = place.address_components[i].types[0];
                var valueOfAddressField = place.address_components[i][addressField[addressType]];

                switch (addressType) {
                    case 'locality':
                        calendarViewModel.set("city", valueOfAddressField);
                        break;
                    case 'administrative_area_level_1':
                        var regionDs = calendarViewModel.get("regionDs");
                        for (var j = 0; j < regionDs.length; j++) {
                            if (valueOfAddressField == regionDs[j].Code) {
                                calendarViewModel.set("selectedRegion", regionDs[j].RegionId);
                                break;
                            }
                        }
                        break;
                    case 'postal_code':
                        calendarViewModel.set("zipcode", valueOfAddressField);
                        break;
                }
            }
        },

        /*Print Calendar*/

        selectedTeamIdsInUrl: "",
        selectedFieldIdInUrl: -1,
        isTeamFilterVisible: true,
    });

    function getScheduleEventServiceRootUrl() {
        var moduleId = $('#DNNModuleId').val();
        var sf = $.ServicesFramework(moduleId);
        return sf.getServiceRoot('sScheduleEventServices');
    };

    /*----#region Calendar Functions ----------*/
    function getRegionsDataSource(readCallBack) {
        var crudServiceBaseUrl = getScheduleEventServiceRootUrl() + "Locations";
        $.ajax({
            url: crudServiceBaseUrl + "/GetAllRegionsByCountryId",
            type: 'GET',
            dataType: 'json',
            data: { portalId: $(".portalIdHidden").val(), countryId: 221 },
            contentType: "application/json; charset=utf-8",
            success: function (data) {
                if (!readCallBack) return;
                readCallBack(data);
            },
            error: function (xhr, status, error) {
                var response = JSON.parse(xhr.responseText);
                TeamBuilder.CustomEvent.showErrorNotification('Error: ' + response.Name);
            }
        });
    }

    function saveCustomEvent(customEventDetails, isClubLocation, readCallBack) {
        var crudServiceBaseUrl = getScheduleEventServiceRootUrl() + "Calendar/";
        var customEventDetails = customEventDetails;
        var ApiUrl = isClubLocation ? crudServiceBaseUrl + "SavePortalMatchDetailsForClubs" : crudServiceBaseUrl + "SavePortalMatchDetails";

        $.ajax({
            type: 'POST',
            url: crudServiceBaseUrl + "SavePortalMatchDetailsForClubs",
            data: JSON.stringify(customEventDetails),
            contentType: "application/json",
            success: function (response) {
                if (!readCallBack) return;
                readCallBack(response);
            },
            error: function (xhr) {
                try {
                    var response;
                    var responseText = $.parseJSON(xhr.responseText);
                    if (xhr.status == 200) {
                        response = responseText;
                    } else {
                        response = { status: xhr.status, responseText: responseText };
                    }
                    if (response.status && response.status == 401) {
                        TeamBuilder.CustomEvent.showErrorNotification(" Access denied");
                    }
                    if (response.status && response.status == 409) {
                        var res = response.responseText;
                        var messageWindow = $("#conflictMessageWnd");
                        if (response.responseText.ScheduledMatches[0].ConflictsList.length > 0) {
                            calendarViewModel.set("isConflict", true);

                            var conflictMatches = calendarViewModel.get("conflictedMatches");
                            conflictMatches.splice(0, conflictMatches.length);

                            var conflictedMatches = response.responseText.ScheduledMatches[0];
                            if (conflictedMatches.Date) {
                                conflictedMatches.Date = kendo.parseDate(conflictedMatches.Date);
                            }

                            if (conflictedMatches.StartTime) {
                                conflictedMatches.StartTime = kendo.parseDate(conflictedMatches.StartTime);
                            }

                            if (conflictedMatches.EndTime) {
                                conflictedMatches.EndTime = kendo.parseDate(conflictedMatches.EndTime);
                            }
                            conflictedMatches.LocationName = response.responseText.ScheduledMatches[0].EventDetail.LocationName
                            conflictedMatches.FieldName = response.responseText.ScheduledMatches[0].EventDetail.FieldName
                            conflictedMatches.IsSiteWideEventWithLocation = response.responseText.ScheduledMatches[0].IsSiteWideEventWithLocation
                            conflictedMatches.eventName = response.responseText.ScheduledMatches[0].EventDetail.EventName
                            conflictMatches.push(conflictedMatches);

                            var isAcceptWithConflict = (response.IsAnyConflictNonOverWritable == false);
                            calendarViewModel.set("isAcceptWithConflict", isAcceptWithConflict);
                            kendo.ui.progress($("#siteWideWindow"), false);
                            if (isAcceptWithConflict == true) {
                                calendarViewModel.set("saveLinkText", "Save Matches With Conflicts");
                                common.showMessage('<span class="normal-text">There are some conflicts in the updated matches. Please view conflicts by clicking on "Show Conflict" button above.</span>');
                            } else {
                                calendarViewModel.set("conflictedMatches[0].ConflictsList", response.responseText.ScheduledMatches[0].ConflictsList)
                                calendarViewModel.showConflicts();
                            }

                        }
                    }
                } catch (e) { }
            }
        });
    }

    function deleteCustomEvent(customEventDetails, readCallBack) {
        var crudServiceBaseUrl = getScheduleEventServiceRootUrl() + "Calendar/";
        var customEventDetails = customEventDetails;
        $.ajax({
            type: 'POST',
            url: crudServiceBaseUrl + "DeletePortalMatchDetails",
            data: JSON.stringify(customEventDetails),
            contentType: "application/json",
            success: function (response) {
                if (!readCallBack) return;
                readCallBack(response);
            },
            error: function (xhr) {
                try {
                    var response;
                    var responseText = $.parseJSON(xhr.responseText);
                    if (xhr.status == 200) {
                        response = responseText;
                    } else {
                        response = { status: xhr.status, responseText: responseText };
                    }
                    if (response.status && response.status == 401) {
                        TeamBuilder.CustomEvent.showErrorNotification(" Access denied");
                    }
                    if (response.status && response.status == 409) {
                        var res = response.responseText;
                        var messageWindow = $("#conflictMessageWnd");
                        if (showConflict != null) {
                            showConflict(response);
                        }
                    }
                } catch (e) { }
            }
        });
    }

    function occurrencesInRangeByResource(start, end, resourceFieldName, event, resources) {
        var scheduler = $("#scheduler").getKendoScheduler();

        var occurrences = scheduler.occurrencesInRange(start, end);

        var idx = occurrences.indexOf(event);
        if (idx > -1) {
            occurrences.splice(idx, 1);
        }
        event = $.extend({}, event, resources);

        return filterByResource(occurrences, resourceFieldName, event[resourceFieldName]);
    }

    function filterByResource(occurrences, resourceFieldName, value) {
        var result = [];
        var occurrence;

        for (var idx = 0, length = occurrences.length; idx < length; idx++) {
            occurrence = occurrences[idx];

            if (occurrence[resourceFieldName] === value) {
                result.push(occurrence);
            }
        }

        return result;
    }

    function checkForMinimumEventDate(start, end, event) {
        var eventDate = event.EventDate;
        if (end < eventDate) return calendar_failedMove;
        else return calendar_successMove;
    }

    function checkAvailabilityWithOccupiedFields(start, end, event, resources) {
        var occurrences = occurrencesInRangeByResource(start, end, "AreaId", event, resources);
        var len = occurrences.length;
        if (len > 0) {
            for (var i = 0; i < len; i++) {
                var item = occurrences[i];
                var attendeeType = item.AttendeeTypes;
                if (attendeeType == 2) {
                    return calendar_failedMove;
                }
            }

            for (var i = 0; i < len; i++) {
                var item = occurrences[i];
                var attendeeType = item.AttendeeTypes;
                if (attendeeType == 4) {
                    return calendar_askForConfimation;
                    break;
                } else {
                    return calendar_failedMove;
                }
            }
        } else
            return calendar_successMove;
    }

    /*----#endregion Calendar Functions ----------*/

    /*----#region Routing ----------*/

    var editMatchesRouter = new kendo.Router();

    editMatchesView.model = calendarViewModel;

    editMatchesRouter.route("/editMatches", function () {
        sSchedule_portalId = $('.portalIdHidden').val();
        editMatchesView.render("#app");
        calendarViewModel.createChildPortalCombo();
        calendarViewModel.loadAssociatedPortals();
        var eventId = $('.eventIdHidden').val();;
        if (eventId) {
            calendarViewModel.set("selectedEventId", eventId);
            calendarViewModel.set("isToCheckForDateRange", false);
            calendarViewModel.set("isSelectAllEventsChecked", false);
            calendarViewModel.set("isBackLinkVisible", true);
            calendarViewModel.set("isTeamFilterVisible", true);
            calendarViewModel.set("isCustomEventMatchInclude", true);
            calendarViewModel.loadView();
        } else {
            calendarViewModel.set("isToCheckForDateRange", true);
            calendarViewModel.set("isSelectAllEventsChecked", true);
            calendarViewModel.set("isBackLinkVisible", true);
            calendarViewModel.set("isTeamFilterVisible", true);
            calendarViewModel.set("isCustomEventMatchInclude", true);
            calendarViewModel.loadView();
        }
        var scheduler = $("#scheduler").data("kendoScheduler");
        scheduler.wrapper.on("click", ".k-scheduler-table td, .k-event", function (e) {
            if (!isTouchDevice()) {
                if ($(e.target).hasClass("swapMatchLink"))
                    return;
                var target = $(e.currentTarget);

                if (target.hasClass("k-event") || $(e.target).hasClass("k-task")) {
                    var event = scheduler.occurrenceByUid(target.data("uid"));
                    scheduler.editEvent(event);
                }
                if ($(e.target).hasClass("k-task")) {
                    var event = scheduler.occurrenceByUid($(e.target).data("uid"));
                    scheduler.editEvent(event);
                }
            }
        });
    });

    editMatchesRouter.route("/gameScheduleCalendar", function () {
        editMatchesView.render("#app");
        calendarViewModel.createChildPortalCombo();
        calendarViewModel.loadAssociatedPortals();
        calendarViewModel.set("isToCheckForDateRange", true);
        calendarViewModel.set("isSelectAllEventsChecked", true);
        calendarViewModel.set("isPosted", true);
        calendarViewModel.set("isCustomEventMatchInclude", true);
        calendarViewModel.set("isInEditMode", false);
        calendarViewModel.set("isTeamFilterVisible", true);
        calendarViewModel.loadView();

    });

    editMatchesRouter.route("/gameScheduleCalendar/teamId/:teamId", function (teamId) {
        editMatchesView.render("#app");
        calendarViewModel.set("selectedTeamIdsInUrl", teamId);
        calendarViewModel.set("isToCheckForDateRange", true);
        calendarViewModel.set("isPosted", true);
        calendarViewModel.set("isCustomEventMatchInclude", true);
        calendarViewModel.set("isInEditMode", false);
        calendarViewModel.set("isTeamFilterVisible", true);
        calendarViewModel.loadView();

    });
    editMatchesRouter.route("/gameScheduleCalendar/day/:matchDate", function (matchDate) {
        editMatchesView.render("#app");
        calendarViewModel.currentCalendarView = 'day';
        calendarViewModel.set("isPosted", true);
        calendarViewModel.set("isCustomEventMatchInclude", true);
        calendarViewModel.set("isToCheckForDateRange", true);
        calendarViewModel.set("isInEditMode", false);
        calendarViewModel.loadView();
        var scheduler = $("#scheduler").data("kendoScheduler");
        scheduler.view("day");
        calendarViewModel.set('currentCalendarDate', matchDate);
    });
    editMatchesRouter.route("/gameScheduleCalendar/fieldId/:fieldId", function (fieldId) {
        editMatchesView.render("#app");
        calendarViewModel.set("selectedFieldIdInUrl", fieldId);
        calendarViewModel.set("isToCheckForDateRange", true);
        calendarViewModel.set("isPosted", true);
        calendarViewModel.set("isCustomEventMatchInclude", true);
        calendarViewModel.set("isInEditMode", false);
        calendarViewModel.set("isTeamFilterVisible", true);
        calendarViewModel.loadView();
    });

    editMatchesRouter.start();

    /*----#endregion Routing ----------*/

    return {
        calendarViewModel: calendarViewModel,
    };
};

function schedulerTooltip(scope) {
    var $thisInfo = null;
    if (!jQuery.fn.tipTip) return;
    if (isTouchDevice()) {
        var $info = jQuery(".tipInfo.match", scope || document.body).not(".converted");
        $info.each(function () {
            $thisInfo = $(this);
            $thisInfo.on('click', function (e) {
                $thisInfo.data('triggerEvent', e);
            });
        });
        $info.addClass("converted").tipTip({
            activation: 'click', defaultPosition: "top", maxWidth: "420px",
            enter: function () {
                setTimeout(function () {
                    var $tooltip = $('.tiptip_head');
                    if ($tooltip.length) {
                        var anchor = $('<a href="javascript:void(0)" id="scheduler-action-btn"><i class="fa fa-pencil-square-o"></i></a>');
                        $tooltip.append(anchor);
                        anchor.on('click', function (e) {
                            e.preventDefault();
                            var event = $thisInfo.data('triggerEvent');
                            var scheduler = $("#scheduler").data("kendoScheduler");
                            if ($(event.target.offsetParent).hasClass("swapMatchLink"))
                                return;
                            var target = $(event.currentTarget.parentElement);

                            if (target.hasClass("k-event") || $(event.target).hasClass("k-task")) {
                                var event = scheduler.occurrenceByUid(target.data("uid"));
                                scheduler.editEvent(event);
                            }
                            if ($(event.target).hasClass("k-task")) {
                                var event = scheduler.occurrenceByUid($(event.target).data("uid"));
                                scheduler.editEvent(event);
                            }
                        });
                    }
                }, 400)
            }
        });
    } else {
        var $info = jQuery(".tipInfo.match", scope || document.body).not(".converted");
        $info.addClass("converted").tipTip({ defaultPosition: "top", maxWidth: "420px", });
    }
}

function isTouchDevice() {
    return 'ontouchstart' in window || navigator.maxTouchPoints > 0;
}

//#region SWAP MATCHES

function swapMatchEndClicked(currentLink) {
    if (confirm("Are you sure you want to swap these two matches?")) {
        var event = $(currentLink).parents('div .k-event');
        var taskElement = event.find(".match");
        var calendarViewModel = editMatchesView.model;
        var uid = taskElement.data("uid");

        var scheduler = $("#scheduler").data("kendoScheduler");
        var dataSource = scheduler.dataSource;

        if (dataSource) {
            var dataItem = dataSource.getByUid(uid);
            calendarViewModel.processMatchSwapping(dataItem);
        }
    }
}

function swapMatchStartClicked(currentLink) {
    var event = $(currentLink).parents('div .k-event');
    var taskElement = event.find(".match");
    var calendarViewModel = editMatchesView.model;
    var uid = taskElement.data("uid");
    var scheduler = $("#scheduler").data("kendoScheduler");
    var dataSource = scheduler.dataSource;
    var dataItem = dataSource.getByUid(uid);
    var taskId = dataItem.TaskId;
    var common = new Sschedule_commonFunctions();

    if (dataItem.IsCustomEventMatch && dataItem.EventType == 'Other') {
        common.showMessage("You are not allowed to swap Other type Custom Event!", null, true);
        return;
    }

    var isSwap = calendarViewModel.get("swapModeEnabled");
    if (isSwap == true) {

    } else {
        var calendarMatches = calendarViewModel.getChangedMatches();
        if (calendarMatches && calendarMatches.length > 0) {
            common.showMessage("There are some unsaved changes to matches. Please commit them first.");
            return;
        }
        else {
            calendarViewModel.resetEditModeForEventMatches(true);
            calendarViewModel.set("swapModeEnabled", true);
        }
    }
    scheduler = $("#scheduler").data("kendoScheduler");

    if (scheduler.dataSource) {
        dataItem = scheduler.dataSource.getByUid(uid);
        dataItem.set("IsSwapStarted", true);
        calendarViewModel.startSwappingMatches(dataItem);
        calendarViewModel.disableEditModeForEventMatches(dataItem.EventID, dataItem.RoundNumber, true);
    }
}

//#endregion SWAP MATCHES

function massShiftMatchSelectionChanged(isMatchSelectedForMassShiftCheckbox) {
    var event = $(isMatchSelectedForMassShiftCheckbox).parents('div .k-event');
    var taskElement = event.find(".match");

    var uid = taskElement.data("uid");
    var scheduler = $("#scheduler").data("kendoScheduler");
    var dataSource = scheduler.dataSource;
    var isChecked = isMatchSelectedForMassShiftCheckbox.checked;

    if (dataSource) {
        var dataItem = dataSource.getByUid(uid);
        dataItem.IsMatchSelectedForMassShift = isChecked;
    }
}

$(document).click(function (e) {
    var eventcontainer = $("#multiEventSelectBox");
    var locationcontainer = $("#multiSelectLocationFieldTreeView");
    var divisioncontainer = $("#multiSeletectProgramDivisionTeamTreeView");
    if (eventcontainer.has(e.target).length === 0 && locationcontainer.has(e.target).length === 0 && divisioncontainer.has(e.target).length === 0) {
        jQuery('.treeViewSearchBox').hide();
    }
});

$(document).ready(function () {
    $("#scheduler").on("click", ".k-event", function (e) {
        if (globalisbulkEventCancel) {
            var scheduler = $("#scheduler").getKendoScheduler();
            var event = scheduler.occurrenceByUid($(this).data("uid"));
            var btnNextForCancelEvents = document.getElementById('btnNextForCancelEvents');

            if ($(this).hasClass("bulkcancelselection")) {
                $(this).removeClass("bulkcancelselection");
                editMatchesView.model.bulkCancelCalendarMatches.remove(event);

                if (editMatchesView.model.bulkCancelCalendarMatches.length == 0) {
                    btnNextForCancelEvents.setAttribute("disabled", "true");
                    btnNextForCancelEvents.style.pointerEvents = "none";
                }
            }
            else {
                if (event.IsHideEditOptions == true) {
                    var message = "You are not allowed to edit another portal’s game.";
                    var htmlMessage = '<div style="color:#FF0000">' + message + '</div>';
                    var title = "Match Scheduler";
                    var messageWindow = $("#messageWnd");
                    if (!messageWindow.data("kendoWindow")) {
                        messageWindow.kendoWindow({
                            width: "320px",
                            title: title,
                            modal: true,
                            actions: [
                                "Close"
                            ],
                        });
                    }
                    messageWindow.parent().addClass('scom tournament-popup');
                    messageWindow.data("kendoWindow").content(htmlMessage);
                    messageWindow.data("kendoWindow").center().open();

                } else {
                    if (event.ActionStatus == 1 || event.IsCustomEventMatch == true || event.RunningMatchCount == true) {
                        return 0;
                    }
                    $(this).addClass("bulkcancelselection");
                    editMatchesView.model.bulkCancelCalendarMatches.push(event);
                }
                if (editMatchesView.model.bulkCancelCalendarMatches.length > 0) {
                    btnNextForCancelEvents.removeAttribute("disabled", "true");
                    btnNextForCancelEvents.style.removeProperty("pointer-events");
                }
            }
        }
    });

    $("#scheduler").on("click", ".k-task", function (e) {
        if (globalisbulkEventCancel) {
            var scheduler = $("#scheduler").getKendoScheduler();
            var event = scheduler.occurrenceByUid($(this).data("uid"));
            var btnNextForCancelEvents = document.getElementById('btnNextForCancelEvents');

            if ($(this).hasClass("bulkcancelselection")) {
                $(this).removeClass("bulkcancelselection");
                editMatchesView.model.bulkCancelCalendarMatches.remove(event);

                if (editMatchesView.model.bulkCancelCalendarMatches.length == 0) {
                    btnNextForCancelEvents.setAttribute("disabled", "true");
                    btnNextForCancelEvents.style.pointerEvents = "none";
                }
            }
            else {
                if (event.IsHideEditOptions == true) {
                    var message = "You are not allowed to edit another portal’s game.";
                    var htmlMessage = '<div style="color:#FF0000">' + message + '</div>';
                    var title = "Match Scheduler";
                    var messageWindow = $("#messageWnd");
                    if (!messageWindow.data("kendoWindow")) {
                        messageWindow.kendoWindow({
                            width: "320px",
                            title: title,
                            modal: true,
                            actions: [
                                "Close"
                            ],
                        });
                    }
                    messageWindow.parent().addClass('scom tournament-popup');
                    messageWindow.data("kendoWindow").content(htmlMessage);
                    messageWindow.data("kendoWindow").center().open();
                } else {
                    if (event.ActionStatus == 1 || event.IsCustomEventMatch == true || event.RunningMatchCount == true) {
                        return 0;
                    }
                    $(this).addClass("bulkcancelselection");
                    editMatchesView.model.bulkCancelCalendarMatches.push(event);
                }

                if (editMatchesView.model.bulkCancelCalendarMatches.length > 0) {
                    btnNextForCancelEvents.removeAttribute("disabled", "true");
                    btnNextForCancelEvents.style.removeProperty("pointer-events");
                }
            }
        }
    });
})
