var common = new Sschedule_commonFunctions();
var scheduleEventId = 0;
var sSchedule_ViewModels_VerifyScheduleViewModel = function (scheduleData) {

    //#region ------------- Model --------------------------
    var scheduleDataSource = new sSchedule_dataSources_scheduleDataSource();

    var scheduleDetails = scheduleData.scheduleDataModel.get("scheduleDetails");
    var dataSources = new sSchedule_dataSources_schedulingteamsDataSource();
    var locationsDataStore = new sSchedule_dataSources_locationDataSource();
    var childPortalDataSource = new sSchedule_dataSources_childPortalDataSource();
    var masterPortalId = jQuery('.masterPortalIdHidden').val();
    var isStackOfficialsIntegrationEnabled = jQuery('.hdn_isStackOfficialsIntegrationEnabled').val();

    var allLocationsDS = locationsDataStore.getDsByName("LocationsListDs", function (options, operation) {
        if (operation == "read") {
            var params = { portalId: masterPortalId, isActiveLocationOnly: false, needToIncludeTBDLocation: true };
            return params;
        }
    });
    var columnsForAllActivityTypeGrid = [
        {
            title: "Swap",
            width: "2%",
            headerAttributes: { class: "bg-blue small-font", valign: "middle", align: "center" }
        },
        {
            field: "MatchOrderNo",
            title: "Order",
            width: "3%",
            headerAttributes: { class: "bg-blue small-font", valign: "middle", align: "center" }
        },
        {
            field: "RoundNumber",
            title: "Round",
            width: "3%",
            headerAttributes: { class: "bg-blue small-font", valign: "middle", align: "center" }
        },
        {
            field: "HomeTeamID",
            title: "Home VS Away Team",
            template: '<span>#=Team1#</span><br/>VS<br/><span>#=Team2#</span>',
            width: "20%",
            headerAttributes: { class: "bg-blue small-font", valign: "middle", align: "left" }
        },
        {
            field: "Date",
            type: "date",
            title: "Match Date",
            template: '#if(FieldID> 0 ){# <span data-bind="invisible:isByeType">#= kendo.toString(Date,"MM/dd/yyyy [ddd]")#</span> #}#',
            width: "12%",
            headerAttributes: { class: "bg-blue small-font", valign: "middle", align: "left" }
        },
        {
            field: "StartTime",
            title: "Start Time",
            template: '#if(FieldID> 0 ){# <span>#= kendo.toString(StartTime,"hh:mm tt")#</span> #}#',
            width: "10%",
            headerAttributes: { class: "bg-blue small-font", valign: "middle", align: "left" }
        },
        {
            field: "EndTime",
            title: "End Time",
            template: '#if(FieldID> 0 ){# <span>#= kendo.toString(EndTime,"hh:mm tt") #</span> #}#',
            width: "10%",
            headerAttributes: { class: "bg-blue small-font", valign: "middle", align: "left" }
        },
        {
            field: "LocationID",
            title: "Locations & Fields",
            template: '#if(FieldID> 0 ){# <span>#=LocationName#</span>&nbsp;/&nbsp;<span>#=FieldName#</span> #}#',
            width: "18%",
            headerAttributes: { class: "bg-blue small-font", valign: "middle", align: "left" }
        },
        {
            title: "&nbsp;",
            template: '#if(ActionStatus> 0 ){# <span>#=StatusName#</span>&nbsp; #}#',
            headerAttributes: { class: "bg-blue small-font", valign: "middle", align: "left" }
        },
        {
            title: "<span>Assigned Officials</span>",
            width: "10%",
            headerAttributes: { class: "bg-blue small-font assignedOfficials", valign: "middle", align: "left" }
        },
        {
            command: [
                { name: "edit", text: { update: "Save" }, template: "" },
                { name: "destroy" }],
            width: "18%",
            headerAttributes: { class: "bg-blue small-font", valign: "middle", align: "center" }
        }
    ];
    var columnsForDoubleEliminationTournamentGrid = [
        {
            title: "Swap",
            headerAttributes: { class: "bg-blue small-font", valign: "middle", align: "center" }


        },
        {
            field: "MatchOrderNo",
            title: "Order",
            headerAttributes: { class: "bg-blue small-font", valign: "middle", align: "center" }
        },
        {
            field: "RoundNumber",
            title: "Round",
            headerAttributes: { class: "bg-blue small-font", valign: "middle", align: "center" }
        },
        {
            field: "IsLooserBracketMatch",
            title: "LooserBracketMatch",
            hidden: true,
            groupHeaderTemplate: "#if(value){#<span class='h4 blue-text no-margin'>Consolation Bracket</span>#}else{#<span class='h4 blue-text no-margin'>Winners Bracket</span>#}#"
        },
        {
            field: "HomeTeamID",
            title: "Home VS Away Team",
            template: '<span>#=Team1#</span><br/>VS<br/><span>#=Team2#</span>',
            headerAttributes: { class: "bg-blue small-font", valign: "middle", align: "left" }
        },
        {
            field: "Date",
            type: "date",
            title: "Match Date",
            template: '#if(FieldID> 0 ){# <span data-bind="invisible:isByeType">#= kendo.toString(Date,"MM/dd/yyyy [ddd]")#</span> #}#',
            headerAttributes: { class: "bg-blue small-font", valign: "middle", align: "left" }
        },
        {
            field: "StartTime",
            title: "Start Time",
            template: '#if(FieldID> 0 ){# <span>#= kendo.toString(StartTime,"hh:mm tt")#</span> #}#',
            headerAttributes: { class: "bg-blue small-font", valign: "middle", align: "left" }
        },
        {
            field: "EndTime",
            title: "End Time",
            template: '#if(FieldID> 0 ){# <span>#= kendo.toString(EndTime,"hh:mm tt") #</span> #}#',
            headerAttributes: { class: "bg-blue small-font", valign: "middle", align: "left" }
        },
        {
            field: "LocationID",
            title: "Locations & Fields",
            template: '#if(FieldID> 0 ){# <span>#=LocationName#</span>&nbsp;/&nbsp;<span>#=FieldName#</span> #}#',
            headerAttributes: { class: "bg-blue small-font", valign: "middle", align: "left" }
        },
        {
            title: "&nbsp;",
            template: '#if(ActionStatus > 0 ){# <span>#=StatusName#</span>&nbsp; #}#',
            headerAttributes: { class: "bg-blue small-font", valign: "middle", align: "left" }
        },
        {
            title: "<span>Assigned Officials</span>",
            width: "10%",
            headerAttributes: { class: "bg-blue small-font assignedOfficials", valign: "middle", align: "left" }
        },
        {
            command: [
                { name: "edit", text: { update: "Save" }, template: "" },
                { name: "destroy" }],
            title: "&nbsp;",
            width: "18%",
            headerAttributes: { class: "bg-blue small-font", valign: "middle", align: "center" },
        }
    ];
    var portalGroupsLocationsDS = locationsDataStore.getDsByName("PortalGroupsLocationsDs", function (options, operation) {
        if (operation == "read") {
            var params = { masterPortalId: masterPortalId, needToIncludeTBDLocation: true };
            return params;
        }
    }, null, function () {
        verifyScheduleModel.set("allLocationsDS", portalGroupsLocationsDS);
    });

    var fieldsDataSources = new sSchedule_dataSources_fieldsDataSource();
    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 = [];
        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 portalGroupsFieldsDS = 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: masterPortalId, needToIncludeTBDField: true };
            return params;
        }
    }, function () {
        verifyScheduleModel.set("allFieldsDs", portalGroupsFieldsDS);
    });


    var fieldAvailability = new sSchedule_viewModels_checkFieldAvailabilityViewModel();

    var verifyScheduleModel = kendo.observable({
        portal: null,

        /*-----start region shared portal------*/
        associatedPortals: new kendo.data.ObservableArray([]),
        loadAssociatedPortals: function () {
            var associatedPortalsDs = childPortalDataSource.getDsByName(function () {
                return { portalId: $('.masterPortalIdHidden').val() }
            }, function () {
                verifyScheduleModel.setAssociatedPortal();
            });
            var list = verifyScheduleModel.associatedPortals;
            if (list.length > 0) {
                verifyScheduleModel.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 = verifyScheduleModel.get("portal");
            if (portal == null)
                return;
            $('.masterPortalIdHidden').val(portal.PortalID);
            sSchedule_portalId = portal.PortalID;

            verifyScheduleModel.loadAllLocationsAndFields();
            verifyScheduleModel.loadMatchesGrid();
        },
        setAssociatedPortal: function () {
            var associatedPortals = verifyScheduleModel.associatedPortals;
            var dataLength = associatedPortals.length;

            for (var i = 0; i < dataLength; i++) {
                if (associatedPortals[i].PortalID == sSchedule_portalId) {
                    verifyScheduleModel.set("portal", associatedPortals[i]);
                    break;
                }
            }
        },
        createChildPortalCombo: function () {
            $("#childPortalDiv").html('');
            var childPortalView = new kendo.View("childPortal-template", { model: verifyScheduleModel });
            childPortalView.render(("#childPortalDiv"));
        },
        /*-----end region shared portal------*/
        matchesGrid: "#schedulePreviewGrid_six",
        doubleEliminationmatchesGrid: "#schedulePreviewGrid_six_doubleElimination",
        commonMatchesGrid: "#schedulePreviewGrid_six",
        allLocationsDS: allLocationsDS,
        allFieldsDs: allFieldsDs,
        portalGroupsLocationsDS: portalGroupsLocationsDS,
        portalGroupsFieldsDS: portalGroupsFieldsDS,
        eventExistForMultiplePortal: false,
        scheduleDetails: scheduleDetails,
        eventScore: scheduleData.scheduleDataModel.eventScore,
        isNotesVisible: false,
        editFieldDataSource: allFieldsDs,
        //Navigation Button Events
        goToPrevStep: function (e) {
            e.preventDefault();
            if (scheduleDetails.get("AutomationLevel") == common.automationTypes.PDTF.name || scheduleDetails.get("AutomationLevel") == common.automationTypes.Tournament.name) {
                document.location = "#/scheduleoverview";
                verifyScheduleRouter.navigate("/scheduleoverview");
            } else if (scheduleDetails.get("AutomationLevel") == common.automationTypes.P.name) {
                document.location = "#/schedulemembers";
                verifyScheduleRouter.navigate("/schedulemembers");
            } else {
                scheduleData.goToSchedulingDetailsStep(verifyScheduleRouter);
            }
        },
        goToNextStep: function (e) {
            e.preventDefault();
            verifyScheduleModel.redirectToNextStep();
        },
        matchDate: function (e) {
            return common.getMatchDate(e.Date);
        },
        matchDateDay: function (e) {
            return common.getMatchDateDay(e.Date);
        },
        Team: null,
        TeamCoachDS: new kendo.data.ObservableArray([]),
        TeamCoach: new Array(),
        TeamIdList: new kendo.data.ObservableArray([]),
        EventName: scheduleDetails.get("ScheduleName"),
        redirectToNextStep: function () {
            verifyScheduleModel.resetAcceptButton();
            scheduleData.scheduleDataModel.set("isScheduleDetailsChanged", false);
            verifyScheduleModel.set("isNextLinkVisible", true);
            verifyScheduleModel.set("isAcceptScheduleLinkVisible", false);

            var eventId = scheduleDetails.get("ScheduleEventId");
            var level = scheduleDetails.get("AutomationLevel");

            var routeUrl = "#/schedulepreview";
            if (eventId > 0) {
                routeUrl = "#/schedulepreview?eventId=" + eventId + "&automationLevel=" + level;
            }
            var params = common.getUrlVars();
            if (params.viewEvent != undefined) {
                if (routeUrl.includes("?")) {
                    routeUrl = routeUrl + "&viewEvent=" + params.viewEvent;
                }
                else {
                    routeUrl = routeUrl + "?viewEvent=" + params.viewEvent;
                }
            }
            document.location = routeUrl;
            verifyScheduleRouter.navigate(routeUrl);
        },
        acceptSchedule: function (e) {
            verifyScheduleModel.showProgress();
            var topValueToScroll = $(".k-loading-image").offset().top;
            $("html").scrollTop(topValueToScroll);
            setTimeout(function () {
                verifyScheduleModel.set("isAcceptScheduleLinkVisible", false);
                scheduleData.scheduleDataModel.tournamentEventId = -1;

                //Here save the preview to database, and then go to next step.
                var scheduledMatchesDs = scheduleDataSource.getDsByName("GenerateScheduleDs", null, function (d) {
                    //**-Success Callback--**//
                    verifyScheduleModel.hideProgress();
                    //scheduleData.clearMatchesGridDataSource();

                    //Conflict
                    if (d.status && d.status == 409 || d.status == 400) {
                        verifyScheduleModel.set("isAcceptScheduleLinkVisible", true);
                        var res = d.responseText;
                        var grid = jQuery(verifyScheduleModel.matchesGrid).data("kendoGrid");
                        if (d.status == 400) {
                            common.showMessage('Some Matches are there for Unallocated Team');
                            return;
                        }
                        var isConflictOverwritable = verifyScheduleModel.isAllConflictOverwritable(res.ScheduledMatches);
                        var isPrevState = verifyScheduleModel.get("isAcceptWithConflict");

                        if (isConflictOverwritable == true) {
                            //reset the schedule details list to return matches
                            scheduleDetails.set("ScheduledMatches", res.ScheduledMatches);
                            //then move to next step.
                            if (isPrevState == true) {
                                verifyScheduleModel.redirectToNextStep();
                            } else {
                                verifyScheduleModel.set("acceptText", "Accept Conflict & Continue");
                                verifyScheduleModel.set("isAcceptWithConflict", isConflictOverwritable);
                            }
                        } else {
                            verifyScheduleModel.resetAcceptButton();
                        }
                        scheduleData.clearMatchesGridDataSource();
                        scheduleData.loadLocalMatchesData(res.ScheduledMatches);
                        if (isStackOfficialsIntegrationEnabled.toLowerCase() === "true" && scheduleDetails.IsPosted && (scheduleDetails.ScheduleType == 1 || scheduleDetails.ScheduleType == 3)) {
                            for (i = 0; i < scheduleData.localMatchesDataSource._data.length; i++) {
                                scheduleData.localMatchesDataSource._data[i].isGameAndSchedulePosted = true;
                            }
                        }
                        //verifyScheduleModel.loadMatchesGrid();
                        GenerateBracket(scheduleDetails.get("AutomationLevel"), scheduleData.localMatchesDataSource._data,
                            'bracketPreviewGrid_six', scheduleData.scheduleDataModel.eventScore,
                            true, false, false, scheduleDetails.get("IsSingleEliminationOn"), scheduleDetails.get("Teams"));
                        verifyScheduleModel.expandAllConflicts();

                        //Anchor to first conflict
                        var container = $.browser.opera ? $("html") : $("html, body");
                        if (scheduleDetails.get("AutomationLevel") == common.automationTypes.Tournament.name) {
                            if ($('.hardConflictLink').length > 0) {
                                var topValueToScroll = 0;
                                $.each($('.hardConflictLink'), function (index, item) {
                                    if (topValueToScroll == 0) {
                                        topValueToScroll = $(item).offset().top;
                                    } else {
                                        if (topValueToScroll > $(item).offset().top) {
                                            topValueToScroll = $(item).offset().top;
                                        }
                                    }
                                });
                                container.animate({ scrollTop: topValueToScroll }, 'slow');
                            }
                            else {
                                var topValueToScroll = 0;
                                $.each($('.conflictLink'), function (index, item) {
                                    if (topValueToScroll == 0) {
                                        topValueToScroll = $(item).offset().top;
                                    } else {
                                        if (topValueToScroll > $(item).offset().top) {
                                            topValueToScroll = $(item).offset().top;
                                        }
                                    }
                                });
                                container.animate({ scrollTop: topValueToScroll }, 'slow');
                            }
                        }
                        else {
                            if ($('.hardConflictLink').length) {
                                container.animate({ scrollTop: jQuery('.hardConflictLink').parent().parent().offset().top }, 'slow');
                            }
                            else {
                                container.animate({ scrollTop: jQuery('.conflictLink').parent().parent().offset().top }, 'slow');
                            }
                        }
                    } else {
                        //Get the Created Schedule here.
                        var generatedDetails = d;
                        var details = generatedDetails.SchedulingDetails;
                        if (!details) return;

                        var eventId = details.ScheduleEventId;
                        var masterEventId = details.MasterEventId;

                        if (eventId) {
                            scheduleDetails.set("ScheduleEventId", eventId);
                            scheduleDetails.set("MasterEventId", masterEventId);
                        }
                        var groupId = details.GroupId;
                        if (groupId) {
                            scheduleDetails.set("GroupId", groupId);
                        }
                        //Set the GroupTeamIDs here from returned Values
                        var teams = generatedDetails.SchedulingDetails.Teams;
                        scheduleDetails.set("Teams", teams);
                        scheduleDetails.set("AcceptedTeams", teams);
                        //scheduleData.clearMatchesGridDataSource();
                        //scheduleData.loadLocalMatchesData(d.ScheduledMatches);
                        //var matches = scheduleData.localMatchesDataSource.data();
                        scheduleDetails.set("ScheduledMatches", d.ScheduledMatches);
                        verifyScheduleModel.redirectToNextStep();
                    }
                    //**-Success Callback--**//
                }, function (xhr, status, error) {
                    //**-Error Callback--**//
                    var errorMes = JSON.parse(xhr.xhr.responseText);
                    if (xhr.xhr.status != 409 && xhr.xhr.status != 400) {
                        common.showMessage(errorMes.Name);
                    }
                    //**-Error Callback--**//
                });

                var models = new sSchedule_common_dataModels();
                var model = models.getModel("MatchScheduling");
                var nItem = new model().toJSON();
                scheduledMatchesDs.add(nItem);
                var list = scheduleData.localMatchesDataSource.data();


                var fieldAvailibilities = scheduleDetails.get("FieldAvailabilities");
                var teamAvailabilities = scheduleDetails.get("TeamAvailabilities");
                var teamMatches = scheduleDetails.get("TeamsMatches");

                nItem = scheduledMatchesDs.data()[scheduledMatchesDs.data().length - 1];

                var portalId = $('.masterPortalIdHidden').val();

                if (!portalId || portalId < 1) {
                    return;
                }
                nItem.set("PortalId", portalId);
                nItem.set("Id", 1);
                nItem.set("ScheduledMatches", list);
                nItem.set("FieldAvailabilities", fieldAvailibilities);
                nItem.set("TeamAvailabilities", teamAvailabilities);
                nItem.set("TeamsMatches", teamMatches);
                nItem.set("SchedulingDetails", scheduleDetails);
                nItem.set("IsAcceptWithConflict", verifyScheduleModel.get("isAcceptWithConflict"));
                //nItem.set("IsEditedFromCalendar", true);
                scheduledMatchesDs.sync();
            }, 10);
        },
        isBackLinkVisible: false,
        isAcceptScheduleLinkVisible: false,
        isNextLinkVisible: true,
        isAddNewVisible: true,
        addNewItemText: ' New Match',
        acceptText: "Save & Continue", // Accept 
        isSelectField: false,
        eventField: "",
        swapMatchList: [],
        toggleSwapMatchesVisisbility: function () {
            var data = scheduleData.localMatchesDataSource.data();
            if (data.length > 1) //&& scheduleDetails.get("AutomationLevel") != common.automationTypes.Tournament.name
                verifyScheduleModel.set("isSwapVisible", true);

            else
                verifyScheduleModel.set("isSwapVisible", false);

            if (data.length > 0) {
                var hideOptionCount = 0;
                for (var i = 0; i < data.length; i++) {
                    if (data[i].IsHideEditOptions) {
                        hideOptionCount += 1;
                    }
                }

                if (data.length == hideOptionCount) {
                    verifyScheduleModel.set("isSwapButtonVisible", false);
                }
                else {
                    verifyScheduleModel.set("isSwapButtonVisible", true);
                }
            }
        },
        isSwapVisible: false,
        isByeType: function (e) {
            return e.AwayTeamID == verifyScheduleModel.byeTeamId;
        },
        getBlackoutDates: function () {
            var blackoutDates = scheduleDetails.get("BlackOutDates");
            blackoutDates.splice(0, blackoutDates.length);

            //Add Team Blackout to Blackout list
            jQuery.each(scheduleDetails.get("TeamBlackout"), function (index, item) {
                blackoutDates.push(item);
            });

            //Add Location Blackout to Blackout list
            jQuery.each(scheduleDetails.get("LocationBlackout"), function (index, item) {
                blackoutDates.push(item);
            });

            //Add Field Blackout to Blackout list
            jQuery.each(scheduleDetails.get("FieldBlackout"), function (index, item) {
                blackoutDates.push(item);
            });
        },
        setMinMatchDate: function (e) {
            var startDatePicker = $("#MatchDate").kendoDatePicker().data("kendoDatePicker");
            if (startDatePicker == null) return;
            startDatePicker.min(scheduleDetails.StartDate);

            startDatePicker.readonly(false);
            startDatePicker.enable(true);
            if (e.model.IsMatchStatusCanceled == true) {
                startDatePicker.enable(false);
            }
        },
        showSchedulePreview: function () {
            //ask for confirmation before generating schedule manually
            verifyScheduleModel.showProgress();
            verifyScheduleModel.set("isAcceptScheduleLinkVisible", false);
            verifyScheduleModel.set("isNextLinkVisible", false);
            scheduleData.clearMatchesGridDataSource();

            var newModel = scheduleData.getModelFromScheduleDetails();
            var serviceRootUrl = common.getServiceRootUrl();
            serviceRootUrl += "SchedulingDetails/GenerateSchedulePreview";

            //set blackout date format
            var blackoutDates = newModel.BlackOutDates;
            for (var i = 0; i < blackoutDates.length; i++) {
                blackoutDates[i].StartTime = common.getTimeSpanFromDate(blackoutDates[i].DisplayStartTime);
                blackoutDates[i].EndTime = common.getTimeSpanFromDate(blackoutDates[i].DisplayEndTime);
                blackoutDates[i].DateFrom = kendo.toString(blackoutDates[i].DateFrom, 'MM/dd/yyyy');
                blackoutDates[i].DateTo = kendo.toString(blackoutDates[i].DateTo, 'MM/dd/yyyy');
                //blackoutDates[i].DisplayStartTime = kendo.toString(blackoutDates[i].DisplayStartTime, 'MM/dd/yyyy');
                //blackoutDates[i].DisplayEndTime = kendo.toString(blackoutDates[i].DisplayEndTime, 'MM/dd/yyyy');
            }

            $.ajax({
                type: "POST",
                data: JSON.stringify(newModel),
                url: serviceRootUrl,
                contentType: "application/json",
                success: function (d) {
                    verifyScheduleModel.resetAcceptButton();


                    scheduleData.scheduleDataModel.set("isScheduleDetailsChanged", false);
                    verifyScheduleModel.toggleSwapMatchesVisisbility();

                    var scheduledMatches = d.ScheduledMatches;

                    scheduleDetails.set("FieldAvailabilities", d.FieldAvailabilities);
                    scheduleDetails.set("TeamAvailabilities", d.TeamAvailabilities);
                    scheduleDetails.set("TeamsMatches", d.TeamsMatches);
                    verifyScheduleModel.hideProgress();
                    var orderedMatches = Enumerable.From(scheduledMatches).OrderBy(function (x) { return x.MatchOrderNo; }).Select(function (x) { return x; }).ToArray();

                    scheduleData.loadLocalMatchesData(orderedMatches);
                    var isAwayTeamDisplayFirst = false;
                    switch (newModel.ActivityType) {
                        case ActivityType.BaseballActivity:
                        case ActivityType.BaseballSoftballActivity:
                        case ActivityType.BasketballActivity:
                        case ActivityType.CheerActivity:
                        case ActivityType.FootballActivity:
                        case ActivityType.HockeyActivity:
                        case ActivityType.LacrosseActivity:
                        case ActivityType.TennisActivity:
                        case ActivityType.SoftballActivity:
                        case ActivityType.FlagFootballActivity:
                            isAwayTeamDisplayFirst = true;
                            break;
                        default:
                            isAwayTeamDisplayFirst = false;
                    }
                    var automationLevel = scheduleDetails.get("AutomationLevel");
                    var eventTypeId = scheduleDetails.get("ScheduleType");
                    if (isAwayTeamDisplayFirst && automationLevel != common.automationTypes.Tournament.name && eventTypeId != ScheduleType.Practice)
                        isAwayTeamDisplayFirst = true;
                    else {
                        isAwayTeamDisplayFirst = false;
                    }
                    scheduleDetails.set("IsAwayTeamDisplayFirst", isAwayTeamDisplayFirst);
                    verifyScheduleModel.loadMatchesGrid();
                    verifyScheduleModel.set("isAcceptScheduleLinkVisible", true);
                    scheduleData.scheduleDataModel.set("isFireScheduleAlgorithm", false);
                },
                error: function () {
                    verifyScheduleModel.hideProgress();
                }
            });
        },

        //#region-------Progress Indicator Section-----

        showProgress: function () {
            common.showProgress("#verifyScheduleTable");
        },
        hideProgress: function () {
            common.hideProgress("#verifyScheduleTable");
        },
        isToFireAlgorithm: function () {
            var matches = scheduleData.localMatchesDataSource.data();
            if (scheduleData.scheduleDataModel.get("isScheduleDetailsChanged") == true || matches.length <= 0) {
                return true;
            }
            return false;
        },

        showPreview: function () {
            common.showConfirmWindow("If you will generate new schedule, the existing matches details will be lost. Do you still want to continue?", function () {
                verifyScheduleModel.showSchedulePreview();
            });
        },

        //#endregion-------Progress Indicator Section-----

        gridDetailInit: function (e) {
            var grid = $(verifyScheduleModel.matchesGrid).data("kendoGrid");

            var parentDataItem = grid.dataItem(e.masterRow);
            var conflictsList = parentDataItem.get("ConflictsList");

            var conflictRowOrderColumn = e.masterRow.find("td.k-col:nth(1)");
            if (conflictsList == null) {
                parentDataItem.set("ConflictsList", []);
            }

            var conflictsLen = parentDataItem.ConflictsList.length;
            var hardConflictList = null;
            var conflictLink, conflictList, displayConflictList;
            if (conflictsLen > 0) {

                $(conflictRowOrderColumn).css("width", "5%");
                $(conflictRowOrderColumn).attr("align", "right");
                hardConflictList = Enumerable.From(conflictsList)
                    .Where(function (x) {
                        return x.IsOverwritable == false;
                    })
                    .Select(function (x) {
                        return x;
                    }).ToArray();
                if (hardConflictList.length > 0) {
                    conflictLink = $('<a class="hardConflictLink" href="javascript:void(0);"></a>');
                    conflictList = $('<div class="hardConflictList"></div>');
                    displayConflictList = hardConflictList;
                } else {
                    conflictLink = $('<a class="conflictLink" href="javascript:void(0);"></a>');
                    conflictList = $('<div class="conflictList"></div>');
                    displayConflictList = parentDataItem.ConflictsList;
                }
                conflictLink.kendoTooltip({
                    content: function (e) {
                        var conflictDiv = $('<div></div>');
                        $.each(displayConflictList, function (index, value) {
                            conflictDiv.append('<p>' + value.Message + '</p>');
                            var isPortalNameHeaderAppend = false;
                            var isPortalName = false;

                            if (value.Matches.length > 0) {
                                var conflictMatchesTable = $('<table width="700px" cellspacing="0" cellpadding="0"></table>');

                                $.each(value.Matches, function (index3, value3) {
                                    if (value3.PortalID != 0) {
                                        isPortalName = true;
                                    }
                                });

                                $.each(value.Matches, function (index1, value1) {
                                    var matchDetailRow = $('<tr></tr>');

                                    if ($('.hdn_isUmbrellaScheduleEnabled').val() == "True") {
                                        if (isPortalName) {
                                            if (isPortalNameHeaderAppend == false) {
                                                conflictMatchesTable.append('<thead><tr><th>Portal</th><th>Order(Round)</th><th>Event Name</th><th>Match Date</th><th>Start-End Time</th><th>Team VS Team</th><th>Locations &amp; Fields</th></tr></thead>');
                                                isPortalNameHeaderAppend = true;
                                            }
                                            if (value1.PortalID != 0) {
                                                matchDetailRow.append('<td width="6%">' + value1.PortalName + '</td>');
                                            }
                                            else {
                                                matchDetailRow.append('<td width="6%">&nbsp;&nbsp;</td>');
                                            }
                                        }
                                        else {
                                            if (isPortalNameHeaderAppend == false) {
                                                conflictMatchesTable.append('<thead><tr><th>Order(Round)</th><th>Event Name</th><th>Match Date</th><th>Start-End Time</th><th>Team VS Team</th><th>Locations &amp; Fields</th></tr></thead>');
                                                isPortalNameHeaderAppend = true;
                                            }
                                        }
                                    } else {
                                        conflictMatchesTable.append('<thead><tr><th>Order(Round)</th><th>Event Name</th><th>Match Date</th><th>Start-End Time</th><th>Team VS Team</th><th>Locations &amp; Fields</th></tr></thead>');
                                    }

                                    matchDetailRow.append('<td width="5%">' + value1.MatchOrderNo + '(' + value1.RoundNumber + ')</td>');
                                    matchDetailRow.append('<td width="20%">' + value1.EventName + '</td>');
                                    matchDetailRow.append('<td width="16%">' + kendo.toString(kendo.parseDate(value1.Date), 'MM/dd/yyyy [ddd]') + '</td>');
                                    matchDetailRow.append('<td width="20%">' + kendo.format('{0:hh:mm tt}', kendo.parseDate(value1.StartTime)) + ' - ' + kendo.format('{0:hh:mm tt}', kendo.parseDate(value1.EndTime)) + '</td>');
                                    var team2 = (value1.EventDetail != null && value1.EventType.toLowerCase() == 'other') ? value1.EventDetail.EventName : value1.Team2;
                                    if (value1.EventType == "Practice") {
                                        matchDetailRow.append('<td width="20%">' + value1.Team1 + '  ' + team2 + '</td>');
                                    } else {
                                        matchDetailRow.append('<td width="20%">' + value1.Team1 + ' <b>VS</b> ' + team2 + '</td>');
                                    }

                                    var locationName = value1.EventType.toLowerCase() != 'other' ? value1.LocationName + ' / ' + value1.FieldName : value1.LocationName;
                                    matchDetailRow.append('<td width="25%">' + locationName + '</td>');
                                    conflictMatchesTable.append(matchDetailRow);
                                });
                                conflictDiv.append(conflictMatchesTable);
                            }
                        });
                        conflictList.append(conflictDiv);
                        return conflictList;
                    },
                    //showOn: "click",
                    position: "right",
                    autoHide: true
                }).data("kendoTooltip");
                conflictRowOrderColumn.append(conflictLink);
                e.detailRow.css("background", "transparent");
                var conflictsHeaderColumn = e.detailRow.find("#conflictsList").parent().parent().find(".k-grid-header");
                conflictsHeaderColumn.css("display", "none");

                var convDiv = e.detailRow.find("#conflictsList").parent().parent().parent().find(".k-grid");
                convDiv.css({ "border-style": "none", "background": "transparent" });
                e.detailRow.remove();


            }

            if (parentDataItem.ValidationErrorsList == null) {
                parentDataItem.set("ValidationErrorsList", []);
            }

            e.detailRow.find("#validationMessagesList").kendoListView({
                dataSource: parentDataItem.ValidationErrorsList,
                template: kendo.template($("#errorItem-template").html())
            });

            $(e.detailRow).css('background-color', $(e.masterRow).css('background-color'));
        },

        actionDataSource: new kendo.data.DataSource({
            data: [
                { ActionStatus: 0, Name: "None" },
                { ActionStatus: 1, Name: "Canceled" },
                { ActionStatus: 2, Name: "Postponed" },
                { ActionStatus: 3, Name: "Rescheduled" }
            ]
        }),

        isGridHomeTeamEditable: true,
        isGridAwayTeamEditable: true,
        isValidationMessageRoundRequired: false,
        isValidationMessageRound: false,
        isValidationMessageStartTime: false,
        isValidationMessageEndTime: false,
        isValidationMessageMatchDate: false,
        isValidationMessageLocation: false,
        isValidationMessageField: false,
        validateMatchTimeCriteria: function (matchItem) {
            verifyScheduleModel.set("isValidationMessageRoundRequired", false);
            verifyScheduleModel.set("isValidationMessageRound", false);
            verifyScheduleModel.set("isValidationMessageStartTime", false);
            verifyScheduleModel.set("isValidationMessageEndTime", false);
            verifyScheduleModel.set("isValidationMessageMatchDate", false);
            verifyScheduleModel.set("isValidationMessageLocation", false);
            verifyScheduleModel.set("isValidationMessageField", false);
            $("#validationMessaageEditMatch").css('display', 'none').html("");
            var matchValidation = true;
            if (matchItem.Team2Type == 2) {
                if (matchItem.RoundNumber == null) {
                    verifyScheduleModel.set("isValidationMessageRoundRequired", true);
                    matchValidation = false;
                }
                if (matchItem.RoundNumber != null && matchItem.RoundNumber <= 0) {
                    verifyScheduleModel.set("isValidationMessageRound", true);
                    matchValidation = false;
                }
                return matchValidation;
            }
            var matchStartTime = common.getTime(matchItem.StartTime);
            var matchEndTime = common.getTime(matchItem.EndTime);


            if (matchItem.RoundNumber == null) {
                verifyScheduleModel.set("isValidationMessageRoundRequired", true);
                matchValidation = false;
            }
            if (matchItem.StartTime == null) {
                $("#validationMessageStartTime").css('display', 'block');
                matchValidation = false;
            }
            if (matchItem.EndTime == null) {
                $("#validationMessageEndTime").css('display', 'block');
                matchValidation = false;
            }
            if (matchItem.Date == null) {
                $("#validationMessageMatchDate").css('display', 'block');
                matchValidation = false;
            }
            if (matchItem.RoundNumber != null && matchItem.RoundNumber <= 0) {
                verifyScheduleModel.set("isValidationMessageRound", true);
                matchValidation = false;
            }
            if (matchStartTime == matchEndTime)//IF START AND END TIME OF MATCH IS SAME
            {
                $("#validationMessaageEditMatch").css('display', 'block').html("<span class='k-icon k-warning'></span> Start time and End time should not be same.").addClass("k-widget k-tooltip k-tooltip-validation k-invalid-msg matchItemValidation");
                matchValidation = false;
            }
            if (matchItem.LocationID == 0) {
                $("#validationMessageLocation").css('display', 'block');
                matchValidation = false;
            }
            if (matchItem.FieldID == 0) {
                $("#validationMessageField").css('display', 'block');
                matchValidation = false;
            }
            return matchValidation;
        },
        editMatch: function (e) {
            verifyScheduleModel.set("isValidationMessageRoundRequired", false);
            verifyScheduleModel.set("isValidationMessageRound", false);
            verifyScheduleModel.set("isValidationMessageStartTime", false);
            verifyScheduleModel.set("isValidationMessageEndTime", false);
            verifyScheduleModel.set("isValidationMessageMatchDate", false);
            verifyScheduleModel.set("isValidationMessageLocation", false);
            verifyScheduleModel.set("isValidationMessageField", false);
            verifyScheduleModel.setMinMatchDate(e);
            $(".k-widget.k-window.bsbSkin").addClass("scom tournament-popup gray-popup edit-match");
            $(".k-widget.k-window.bsbSkin.scom.tournament-popup").css("padding-top", "0");
            $(".k-popup-edit-form").css("padding-top", "0");
            $(".k-popup-edit-form").addClass("bsb-tournament");
            $(".k-button.k-button-icontext.k-primary.k-grid-update").addClass("bsb-btn btn-default btn-tournament btn-tournament-orange btn-blue");
            $(".k-button.k-button-icontext.k-grid-cancel").addClass("bsb-btn btn-default btn-tournament btn-tournament-orange btn-blue");
            $(".k-button.k-button-icontext.k-grid-cancel").addClass(" pull-left");
            $(".k-button.k-button-icontext.k-primary.k-grid-update span").addClass("icn icn-tournament-true");
            $(".k-button.k-button-icontext.k-grid-cancel span").addClass("icn icn-tournament-close");
            if (e.model.Date == null) {
                //e.model.Date = kendo.toString(scheduleDetails.StartDate, 'MM/dd/yyyy');
                e.model.set("Date", null);
            }
            if (e.model.isNew()) {
                var teams = scheduleDetails.get("Teams");
                e.model.set("SrNo", -1);
                e.model.set("RoundNumber", 0);
                e.model.set("MatchOrderNo", 0);
                if (e.model.HomeTeamID <= 0) {
                    e.model.set("HomeTeamID", teams[0].TeamID);
                }
                e.model.set("Team1", teams[0].TeamName);
                if (scheduleDetails.ScheduleType == 2) {
                    e.model.set("AwayTeamID", verifyScheduleModel.practiceTeamId);
                    e.model.set("Team2", "Practice");
                    e.model.set("Team2Type", TeamType.Practice);
                } else {
                    e.model.set("AwayTeamID", teams[0].TeamID);
                    e.model.set("Team2", teams[0].TeamName);
                    e.model.set("Team2Type", teams[0].TeamTypeID);
                }
                e.model.set("Date", null);
                e.model.set("StartTime", "00:00");
                e.model.set("EndTime", "00:00");
                e.model.set("LocationID", 0);
                e.model.set("FieldID", 0);
                e.model.set("ValidationErrorsList", []);
                e.model.set("ConflictsList", []);
                e.model.set("LocationName", 'Select Location');
                e.model.set("FieldName", 'Select Field');
                e.model.set("Team1Type", teams[0].TeamTypeID);
                e.model.set("IsDeleted", false);
                e.model.set("IsEdited", true); //set true to send update schedule email
                e.model.set("FieldStatus", 0);
                e.model.set("MatchID", -1);
                e.model.set("IsHideEditOptions", false);
                setFieldAvailabilityStatus(e);
            }

            var isByeMatch = checkMatchIsBye(e);
            if (isByeMatch) {
                e.container.find("#EditFieldList")[0].required = false;
                e.container.find("#EditLocationList")[0].required = false;
                e.container.find("#StartTime")[0].required = false;
                e.container.find("#MatchEndTime")[0].required = false;
                e.container.find("#MatchDate")[0].required = false;
                jQuery(e.container).find('.editableControl').hide();
            } else {
                //e.container.find("#EditFieldList")[0].required = true;
                //e.container.find("#EditLocationList")[0].required = true;
                //e.container.find("#StartTime")[0].required = true;
                //e.container.find("#MatchEndTime")[0].required = true;
                //e.container.find("#MatchDate")[0].required = true;
                jQuery(e.container).find('.editableControl').show();
            }

            //if (scheduleDetails.get("AutomationLevel") == common.automationTypes.P.name) {
            //    e.container.find("#EditFieldList")[0].required = false;
            //    e.container.find("#EditLocationList")[0].required = false;
            //    e.container.find("#StartTime")[0].required = false;
            //    e.container.find("#MatchEndTime")[0].required = false;
            //    e.container.find("#MatchDate")[0].required = false;
            //}
            var fieldsList;
            //Change title
            e.container.kendoWindow("title", scheduleDetails.ScheduleName);

            // Need to refill dropdown - location
            var locationDropDown = e.container.find("#EditLocationList").data("kendoDropDownList");
            var eventExistForMultiplePortal = verifyScheduleModel.eventExistForMultiplePortal;
            if (eventExistForMultiplePortal == true) {
                locationDropDown.setDataSource(verifyScheduleModel.portalGroupsLocationsDS);
                fieldsList = verifyScheduleModel.portalGroupsFieldsDS.data();
            } else {
                locationDropDown.setDataSource(verifyScheduleModel.allLocationsDS);
                fieldsList = verifyScheduleModel.allFieldsDs.data();
            }
            locationDropDown.value(e.model.LocationID);


            //Change for RoundNumber
            var roundNumber = e.container.find("#Round");
            roundNumber.bind("change", function () {
                var round = $(this).val();
                if (round == "" || round == null) {
                    verifyScheduleModel.set("isValidationMessageRoundRequired", true);
                }
                else {
                    verifyScheduleModel.set("isValidationMessageRoundRequired", false);
                    if (round <= 0) {
                        verifyScheduleModel.set("isValidationMessageRound", true);
                    } else {
                        verifyScheduleModel.set("isValidationMessageRound", false);
                    }
                }
                verifyScheduleModel.resetGridCheckboxColumn();
            });

            // Need to refill dropdown - action
            var actionDropDown = e.container.find("#EditActionList").data("kendoDropDownList");
            actionDropDown.setDataSource(verifyScheduleModel.actionDataSource);
            actionDropDown.value(e.model.ActionStatus);

            // Need to refill dropdown - notes
            var actionNotes = e.container.find("#TextForNotes");
            var lblNotes = e.container.find("#lblNotes");
            if (e.model.ActionStatus > 0) {
                verifyScheduleModel.set("isNotesVisible", true);
                actionNotes.show();
                lblNotes.show();

                if (e.model.ActionStatus == 1) {
                    e.model.set("IsMatchStatusCanceled", true);
                }
                else {
                    e.model.set("IsMatchStatusCanceled", false);
                }
            } else {
                verifyScheduleModel.set("isNotesVisible", false);
                actionNotes.hide();
                lblNotes.hide();
                e.model.set("IsMatchStatusCanceled", false);
            }
            actionNotes.val(e.model.Notes);
            actionNotes.text(e.model.Notes);

            // Need to refill dropdown - field
            var editFieldDropDown = e.container.find("#EditFieldList").data("kendoDropDownList");

            verifyScheduleModel.set("isGridAwayTeamEditable", true);
            verifyScheduleModel.set("isGridHomeTeamEditable", true);

            if (verifyScheduleModel.isTournamentGraphicalView()) {
                var matches = scheduleData.localMatchesDataSource.data();
                var homeScore = 0, awayScore = 0;
                var isScoreAdded = false;
                var eventScore = scheduleDetails.get("eventScore");


                var matchScore = Enumerable.From(eventScore)
                    .Where(function (x) {
                        return x.MatchID == e.model.MatchID;
                    })
                    .Select(function (x) {
                        return x;
                    }).ToArray();

                if (matchScore != null && matchScore.length > 0) {
                    var score = matchScore[0];
                    if (e.model.HomeTeamID == score.HomeTeamID) {
                        homeScore = score.WinScore;
                        awayScore = score.LostScore;
                    } else {
                        homeScore = score.LostScore;
                        awayScore = score.WinScore;
                    }
                    isPosted = score.IsPosted;
                    isScoreAdded = (homeScore != 0 || awayScore != 0) ? true : false;
                }

                if (isScoreAdded || e.model.RoundNumber > 1 || e.model.IsLooserBracketMatch == true || (scheduleDetails.get("IsSingleEliminationOn") == false && e.model.Team2Type == 2)) {
                    verifyScheduleModel.set("isGridAwayTeamEditable", false);
                    verifyScheduleModel.set("isGridHomeTeamEditable", false);
                }
            }
            else {
                if (e.model.Team2Type == 3)
                    verifyScheduleModel.set("isGridAwayTeamEditable", false);
            }

            e.model.set("isGridAwayTeamEditable", verifyScheduleModel.isGridAwayTeamEditable);
            e.model.set("isGridHomeTeamEditable", verifyScheduleModel.isGridHomeTeamEditable);

            var fieldsDataSource = new kendo.data.DataSource({
                data: fieldsList
            });

            fieldsDataSource.filter({
                field: "LocationID",
                operator: "eq",
                value: e.model.LocationID
            });

            verifyScheduleModel.set("editFieldDataSource", fieldsDataSource);

            editFieldDropDown.setDataSource(verifyScheduleModel.editFieldDataSource);
            editFieldDropDown.value(e.model.FieldID);

            locationDropDown.bind("change", function () {

                var locationId = locationDropDown.value();
                e.model.LocationID = locationId;
                e.model.LocationName = locationDropDown.text();
                if (locationId == 0) {
                    $("#validationMessageLocation").css('display', 'block');
                }
                else {
                    $("#validationMessageLocation").css('display', 'none');
                }
                fieldsDataSource.filter([]);
                fieldsDataSource.filter({
                    field: "LocationID",
                    operator: "eq",
                    value: parseInt(locationId)
                });
                verifyScheduleModel.set("editFieldDataSource", fieldsDataSource);
                e.model.FieldID = 0;
                e.model.FieldName = 'Select Field';
                editFieldDropDown.text('Select Field');
                setFieldAvailabilityStatus(e);

                verifyScheduleModel.resetGridCheckboxColumn();
            });


            editFieldDropDown.bind("change", function () {
                var fieldId = editFieldDropDown.value();
                e.model.FieldID = fieldId;
                if (editFieldDropDown.text() == "Select Field") {
                    $("#validationMessageField").css('display', 'block');
                }
                else {
                    $("#validationMessageField").css('display', 'none');
                }
                var fieldDataSource = editFieldDropDown.dataSource.view();
                jQuery.each(fieldDataSource, function (index, value) {
                    if (value.FieldID == fieldId) {
                        e.model.FieldName = value.Name;
                        return false;
                    }
                });                           
                setFieldAvailabilityStatus(e);
                verifyScheduleModel.resetGridCheckboxColumn();
            });


            var matches = scheduleData.localMatchesDataSource.data();
            var byeTeamId = jQuery('.byeTeamIdHidden').val();
            var oldAwayTeamId = e.model.AwayTeamID;
            //#region Home team dataSource
            var homeTeamDropDown = e.container.find("#EditHomeTeamList").data("kendoDropDownList");
            var teamsDataSource = new kendo.data.ObservableArray([]);

            if (verifyScheduleModel.tbdTeamId == 0) {
                verifyScheduleModel.set('tbdTeamId', jQuery('.tbdTeamIdHidden').val());
            }
            for (var i = 0; i < scheduleDetails.Teams.length; i++) {
                teamsDataSource.push({ TeamID: scheduleDetails.Teams[i].TeamID, TeamName: scheduleDetails.Teams[i].TeamName, TeamType: scheduleDetails.Teams[i].TeamTypeID });
            }
            if (scheduleDetails.get("AutomationLevel") != "Tournament") {
                teamsDataSource.push({ TeamID: verifyScheduleModel.tbdTeamId, TeamName: 'TBD', TeamType: 5 });
            }
            homeTeamDropDown.setDataSource(teamsDataSource);
            homeTeamDropDown.value(e.model.HomeTeamID);

            homeTeamDropDown.bind("change", function (eTeam) {

                var homeTeamId = homeTeamDropDown.value();
                var oldHomeTeamId = e.model.HomeTeamID;
                var nextMatches = e.model.NextMatch;
                var matchOrderNo = e.model.MatchOrderNo;
                //console.log(homeTeamId);
                var isTbdMatch;

                if (verifyScheduleModel.tbdTeamId == homeTeamId) {
                    isTbdMatch = true;
                } else {
                    isTbdMatch = false;
                }
                if (isTbdMatch) {
                    e.model.set("Team1", "TBD");
                    e.model.set("Team1Type", 5);
                }
                else {
                    e.model.set("Team1Type", 0);
                }

                e.model.HomeTeamID = homeTeamId;
                e.model.Team1 = homeTeamDropDown.text();
                e.model.Team1Type = homeTeamDropDown.options.dataSource[eTeam.sender.selectedIndex].TeamType;

                if (verifyScheduleModel.isTournamentGraphicalView()) {
                    if (e.model.AwayTeamID == byeTeamId && nextMatches != 0) {
                        nextRoundMatch = Enumerable.From(matches)
                            .Where(function (x) {
                                return (
                                    x.MatchID == nextMatches
                                );
                            })
                            .Select(function (x) {
                                return x;
                            }).ToArray();

                        jQuery.each(nextRoundMatch, function (index, value) {
                            var homeTeamPlaceHolder = value.get("HomeTeamPlaceHolder");
                            var awayTeamPlaceHolder = value.get("AwayTeamPlaceHolder");
                            if (homeTeamPlaceHolder.substring(1, homeTeamPlaceHolder.substring(0, homeTeamPlaceHolder.indexOf(" ")).length) == matchOrderNo) {
                                value.set("HomeTeamID", homeTeamId);
                                value.set("Team1", homeTeamDropDown.text());
                                if (homeTeamDropDown != null)
                                    value.set("Team1Type", homeTeamDropDown.options.dataSource[eTeam.sender.selectedIndex].TeamType);
                                value.set("IsEdited", true);
                            }
                            if (awayTeamPlaceHolder.substring(1, awayTeamPlaceHolder.substring(0, awayTeamPlaceHolder.indexOf(" ")).length) == matchOrderNo) {
                                value.set("AwayTeamID", homeTeamId);
                                value.set("Team2", homeTeamDropDown.text());
                                if (homeTeamDropDown != null)
                                    value.set("Team2Type", homeTeamDropDown.options.dataSource[eTeam.sender.selectedIndex].TeamType);
                                value.set("IsEdited", true);
                            }

                        });
                    }
                }
                verifyScheduleModel.resetGridCheckboxColumn();
            });
            //#endregion Home team dataSource

            //#region Away team datasource

            var awayTeamDropDown = e.container.find("#EditAwayTeamList").data("kendoDropDownList");
            var awayTeamsDataSource = new kendo.data.ObservableArray([]);

            if (scheduleDetails.ScheduleType == 2) //for practice type
            {
                if (verifyScheduleModel.practiceTeamId == 0) {
                    verifyScheduleModel.set('practiceTeamId', jQuery('.practiceTeamIdHidden').val());
                }
                awayTeamsDataSource.push({ TeamID: verifyScheduleModel.practiceTeamId, TeamName: 'Practice' });
            } else {
                if (verifyScheduleModel.tbdTeamId == 0) {
                    verifyScheduleModel.set('tbdTeamId', jQuery('.tbdTeamIdHidden').val());
                }
                for (var i = 0; i < scheduleDetails.Teams.length; i++) {
                    awayTeamsDataSource.push({ TeamID: scheduleDetails.Teams[i].TeamID, TeamName: scheduleDetails.Teams[i].TeamName, TeamType: scheduleDetails.Teams[i].TeamTypeID });
                }
                if (scheduleDetails.get("AutomationLevel") != "Tournament") {
                    awayTeamsDataSource.push({ TeamID: verifyScheduleModel.tbdTeamId, TeamName: 'TBD', TeamType: 5 });
                }

                if (verifyScheduleModel.byeTeamId == 0) {
                    verifyScheduleModel.set('byeTeamId', jQuery('.byeTeamIdHidden').val());
                }
                awayTeamsDataSource.push({ TeamID: verifyScheduleModel.byeTeamId, TeamName: 'Bye', TeamType: 2 });
            }
            if (scheduleDetails.get("AutomationLevel") == "Tournament" && e.model.Team2Type == 2 && verifyScheduleModel.isSingleEliminationOn)
                e.model.AwayTeamID = verifyScheduleModel.byeTeamId;
            awayTeamDropDown.setDataSource(awayTeamsDataSource);
            awayTeamDropDown.value(e.model.AwayTeamID);
            awayTeamDropDown.bind("change", function (eTeam) {
                var awayTeamId = awayTeamDropDown.value();
                var isByeMatch;
                var isTbdMatch;
                var nextMatches = e.model.NextMatch;
                var matchOrderNo = e.model.MatchOrderNo;
                var matchHomeTeamId = e.model.HomeTeamID;

                if (verifyScheduleModel.byeTeamId == 0) {
                    verifyScheduleModel.set('byeTeamId', jQuery('.byeTeamIdHidden').val());
                }
                if (verifyScheduleModel.tbdTeamId == 0) {
                    verifyScheduleModel.set('tbdTeamId', jQuery('.tbdTeamIdHidden').val());
                }
                if (verifyScheduleModel.byeTeamId == awayTeamId) {
                    isByeMatch = true;
                } else {
                    isByeMatch = false;
                }
                if (verifyScheduleModel.tbdTeamId == awayTeamId) {
                    isTbdMatch = true;
                } else {
                    isTbdMatch = false;
                }
                jQuery(e.container).find('.editableControl').show();
                actionDropDown.trigger('change');

                if (isByeMatch) {
                    e.container.find("#EditFieldList")[0].required = false;
                    e.container.find("#EditLocationList")[0].required = false;
                    e.container.find("#StartTime")[0].required = false;
                    e.container.find("#MatchEndTime")[0].required = false;
                    e.container.find("#MatchDate")[0].required = false;
                    e.container.find('.editableControl').hide();
                    e.model.set("LocationID", 0);
                    e.model.set("FieldID", 0);
                    e.model.set("LocationName", 'Select Location');
                    e.model.set("FieldName", 'Select Field');
                    e.model.set("Team2", "Bye");
                    e.model.set("StartTime", "00:00");
                    e.model.set("EndTime", "00:00");
                    e.model.set("Date", null);
                    e.model.set("FieldStatus", 0);
                    e.model.set("ActionStatus", 0);
                    e.model.set("Notes", null);
                    verifyScheduleModel.set("isValidationMessageRoundRequired", false);
                    verifyScheduleModel.set("isValidationMessageRound", false);
                    verifyScheduleModel.set("isValidationMessageStartTime", false);
                    verifyScheduleModel.set("isValidationMessageEndTime", false);
                    verifyScheduleModel.set("isValidationMessageMatchDate", false);
                    verifyScheduleModel.set("isValidationMessageLocation", false);
                    verifyScheduleModel.set("isValidationMessageField", false);
                    //e.model.set("Team2Type", 2); //Set Bye Type Team Id as ByeTeamType
                }
                else if (isTbdMatch) {
                    jQuery(e.container).find('.editableControl').show();
                    e.container.find("#EditFieldList")[0].required = true;
                    e.container.find("#EditLocationList")[0].required = true;
                    //e.container.find("#StartTime")[0].required = true;
                    //e.container.find("#MatchEndTime")[0].required = true;
                    // e.container.find("#MatchDate")[0].required = true;
                    e.model.set("Team2", "TBD");
                    e.model.set("Team2Type", 5);
                }
                else
                    e.model.set("Team2Type", 0);
                e.model.AwayTeamID = awayTeamId;
                e.model.Team2 = awayTeamDropDown.text();
                e.model.Team2Type = awayTeamDropDown.options.dataSource[eTeam.sender.selectedIndex].TeamType;

                if (verifyScheduleModel.isTournamentGraphicalView()) {
                    if((oldAwayTeamId == byeTeamId || awayTeamId == byeTeamId) && awayTeamId!=oldAwayTeamId && nextMatches!=0)
                    {
                        var nextRoundMatch = Enumerable.From(matches)
                            .Where(function (x) {
                                return (
                                    x.MatchID == nextMatches
                                );
                            })
                            .Select(function (x) {
                                return x;
                            }).ToArray();

                        jQuery.each(nextRoundMatch, function (index, value) {
                            var homeTeamPlaceHolder = value.get("HomeTeamPlaceHolder");
                            var awayTeamPlaceHolder = value.get("AwayTeamPlaceHolder");
                            if (homeTeamPlaceHolder != null && homeTeamPlaceHolder.substring(1, homeTeamPlaceHolder.substring(0, homeTeamPlaceHolder.indexOf(" ")).length) == matchOrderNo) {
                                if (oldAwayTeamId == byeTeamId) {
                                    value.set("HomeTeamID", null);
                                    value.set("Team1", homeTeamPlaceHolder);
                                    value.set("Team1Type", "5");
                                    value.set("IsEdited", true);
                                }
                                if (awayTeamId == byeTeamId) {
                                    value.set("Team1Type", "0");
                                    value.set("HomeTeamID", matchHomeTeamId);
                                    value.set("Team1", homeTeamDropDown.text());
                                    value.set("IsEdited", true);
                                }
                            }
                            if (awayTeamPlaceHolder != null && awayTeamPlaceHolder.substring(1, awayTeamPlaceHolder.substring(0, awayTeamPlaceHolder.indexOf(" ")).length) == matchOrderNo) {
                                if (oldAwayTeamId == byeTeamId) {
                                    value.set("Team2", awayTeamPlaceHolder);
                                    value.set("AwayTeamID", null);
                                    value.set("Team2Type", "5");
                                    value.set("IsEdited", true);
                                }
                                if (awayTeamId == byeTeamId) {
                                    value.set("Team2", homeTeamDropDown.text());
                                    value.set("AwayTeamID", matchHomeTeamId);
                                    value.set("Team2Type", "0");
                                    value.set("IsEdited", true);
                                }
                            }

                        });
                    }
                }

                verifyScheduleModel.resetGridCheckboxColumn();
            });

            //#endregion Away team dataSource

            actionDropDown.bind("change", function () {
                var actionStatusId = actionDropDown.value();
                e.model.set("ActionStatus", actionStatusId);
                e.model.set("StatusName", actionDropDown.text());

                if (actionStatusId > 0) {
                    verifyScheduleModel.set("isNotesVisible", true);
                    actionNotes.show();
                    lblNotes.show();

                    if (actionStatusId == 1) {
                        e.model.set("IsMatchStatusCanceled", true);
                    }
                    else {
                        e.model.set("IsMatchStatusCanceled", false);
                    }
                } else {
                    verifyScheduleModel.set("isNotesVisible", false);
                    actionNotes.hide();
                    lblNotes.hide();
                    e.model.set("IsMatchStatusCanceled", false);
                }
                verifyScheduleModel.resetGridCheckboxColumn();
            });
            e.model.set("isNotesVisible", verifyScheduleModel.isNotesVisible);
            actionNotes.bind("change", function () {

                var actionNoteValue = actionNotes.val();
                e.model.Notes = actionNoteValue;
                verifyScheduleModel.set("isEditMatchesChanged", true);
                verifyScheduleModel.set("isNextLinkVisible", false);
                verifyScheduleModel.set("isAcceptScheduleLinkVisible", true);
                e.model.IsEdited = true;
                verifyScheduleModel.resetGridCheckboxColumn();
            });


            $("#StartTime").kendoTimePicker({
                change: function (e3) {
                    var timePicker = e3.sender.element;
                    var startTimePicker = timePicker.data("kendoTimePicker");
                    var startTime = startTimePicker.value();
                    var endTimePicker = $("#MatchEndTime").data("kendoTimePicker");
                    var endTime = endTimePicker.value();
                    if (startTime == null) {
                        $("#validationMessageStartTime").css('display', 'block');
                    }
                    else {
                        $("#validationMessageStartTime").css('display', 'none');
                    }

                    if (kendo.parseDate(startTime) != kendo.parseDate(endTime)) {
                        $("#validationMessaageEditMatch").css('display', 'none').html("");
                    }
                    else {
                        $("#validationMessaageEditMatch").css('display', 'block').html("<span class='k-icon k-warning'></span> Start time and End time should not be same.").addClass("k-widget k-tooltip k-tooltip-validation k-invalid-msg matchItemValidation");
                    }

                    if (!kendo.parseDate(startTime) || !kendo.parseDate(endTime))
                        return;

                    //Check start and end time
                    var checkStartTime = new Date(); //kendo.parseDate($("#dateFromPicker").val());

                    var startTimeArray = common.getTimeSpanFromDate(startTime).split(':');
                    checkStartTime.setHours(startTimeArray[0]);
                    checkStartTime.setMinutes(startTimeArray[1]);

                    var checkEndTime = new Date(); //kendo.parseDate($("#dateToPicker").val());

                    var endTimeArray = common.getTimeSpanFromDate(endTime).split(':');
                    checkEndTime.setHours(endTimeArray[0]);
                    checkEndTime.setMinutes(endTimeArray[1]);

                    if (checkEndTime < checkStartTime) {
                        endTime = startTime;
                        e.model.set("EndTime", endTime);
                    }
                    setFieldAvailabilityStatus(e);
                    verifyScheduleModel.resetGridCheckboxColumn();
                }

            });
            $("#MatchEndTime").kendoTimePicker({

                change: function (e3) {

                    var timePicker = e3.sender.element;
                    var endTimePicker = timePicker.data("kendoTimePicker");
                    var endTime = endTimePicker.value();
                    var startTimePicker = $("#StartTime").data("kendoTimePicker");
                    var startTime = startTimePicker.value();
                    if (endTime == null) {
                        $("#validationMessageEndTime").css('display', 'block');
                    }
                    else {
                        $("#validationMessageEndTime").css('display', 'none');
                    }
                    if (kendo.parseDate(startTime) != kendo.parseDate(endTime)) {
                        $("#validationMessaageEditMatch").css('display', 'none').html("");
                    }
                    else {
                        $("#validationMessaageEditMatch").css('display', 'block').html("<span class='k-icon k-warning'></span> Start time and End time should not be same.").addClass("k-widget k-tooltip k-tooltip-validation k-invalid-msg matchItemValidation");
                    }

                    if (!kendo.parseDate(startTime) || !kendo.parseDate(endTime))
                        return;

                    //Check start and end time
                    var checkStartTime = new Date(); //kendo.parseDate($("#dateFromPicker").val());

                    var startTimeArray = common.getTimeSpanFromDate(startTime).split(':');
                    checkStartTime.setHours(startTimeArray[0]);
                    checkStartTime.setMinutes(startTimeArray[1]);

                    var checkEndTime = new Date(); //kendo.parseDate($("#dateToPicker").val());

                    var endTimeArray = common.getTimeSpanFromDate(endTime).split(':');
                    checkEndTime.setHours(endTimeArray[0]);
                    checkEndTime.setMinutes(endTimeArray[1]);

                    if (checkEndTime < checkStartTime) {
                        startTime = endTime;
                        e.model.set("StartTime", startTime);
                    }
                    setFieldAvailabilityStatus(e);
                    verifyScheduleModel.resetGridCheckboxColumn();
                }
            });
            var matchDates = $("#MatchDate").data("kendoDatePicker");

            matchDates.bind("change", function () {
                var matchdate = kendo.parseDate(kendo.format('{0:d}', this.value()));
                var scheduleDate = kendo.parseDate(kendo.format('{0:d}', scheduleDetails.StartDate));
                if (matchdate != null) {
                    if (scheduleDate > matchdate) {
                        e.model.set("Date", scheduleDate);
                        this.value = kendo.toString(scheduleDetails.StartDate, 'MM/dd/yyyy');
                    }
                    else {
                        e.model.set("Date", matchdate);
                    }
                }
                if (matchdate == null) {
                    $("#validationMessageMatchDate").css('display', 'block');
                }
                else {
                    $("#validationMessageMatchDate").css('display', 'none');
                }
                setFieldAvailabilityStatus(e);
                verifyScheduleModel.resetGridCheckboxColumn();
            });

            setFieldAvailabilityStatus(e);
            verifyScheduleModel.resetGridCheckboxColumn();
        },

        resetAcceptButton: function () {
            verifyScheduleModel.set("isAcceptWithConflict", false);
            verifyScheduleModel.set("acceptText", "Save & Continue"); //Accept
        },
        isAcceptWithConflict: false,
        isAllConflictOverwritable: function (matches) {
            var len = matches.length;
            for (var i = 0; i < len; i++) {
                var match = matches[i];
                var conflicts = match.ConflictsList;
                var conflictsLen = conflicts.length;
                for (var j = 0; j < conflictsLen; j++) {
                    var conflict = conflicts[j];
                    if (conflict.IsOverwritable == false) {
                        return false;
                    }
                }
            }
            return true;
        },

        isTournamentGraphicalView: function () {
            var automationLevel = scheduleDetails.get("AutomationLevel");
            if (automationLevel == common.automationTypes.Tournament.name)
                return true;
            return false;
        },
        expandConflicts: function (grid) {
            //check if the row has conflict then expand.
            var rowData = grid.dataSource.data();
            if (!rowData) return;
            var rowLen = rowData.length;
            var gridAllRows = [];

            for (var i = 0; i < rowLen; i++) {
                var match = rowData[i];
                if (!match.ConflictsList)
                    continue;

                if (match.ConflictsList.length <= 0) continue;

                var uid = match.uid;
                var row = grid.tbody.find("tr[data-uid='" + uid + "']");
                gridAllRows.push(row);
            }

            for (var i = 0; i < gridAllRows.length; i++) {
                grid.expandRow(gridAllRows[i]);
            }
        },
        expandAllConflicts: function () {
            //FIELDS
            var grid = $(verifyScheduleModel.matchesGrid).data("kendoGrid");
            if (!grid)
                return;

            grid.saveChanges();

            var gridAllRows = grid.tbody.find("tr.k-master-row");

            for (var i = 0; i < gridAllRows.length; i++) {

                var dataItem = grid.dataItem(gridAllRows[i]);
                if (dataItem) {
                    if ((dataItem.ConflictsList && dataItem.ConflictsList.length > 0) || (dataItem.ValidationErrorsList && dataItem.ValidationErrorsList.length > 0)) {
                        grid.expandRow(gridAllRows[i]);
                    }
                }
            }
        },
        addNewItem: function () {
            $("#schedulePreviewGrid_six .k-grid-add").click();
            verifyScheduleModel.resetGridCheckboxColumn();
        },
        deleteMatch: function (e) {
            common.showConfirmWindow("Are you sure you want to delete match ?", function () {
                var grid = $(verifyScheduleModel.matchesGrid).data("kendoGrid");
                var dataItem = grid.dataItem($(e.currentTarget).closest("tr"));
                scheduleData.localMatchesDataSource.remove(dataItem);
            });
        },
        isSingleEliminationOn: true,
        isDoubleEliminationOn: false,
        isEditMatchesChanged: false,
        isInEditMode: false,

        onDataBoundForMatches: function () {
            var grid = $(verifyScheduleModel.matchesGrid).data("kendoGrid");
            if (!grid) return;
            $("#schedulePreviewGrid_six table").addClass("table no-border table-striped");
            $("#schedulePreviewGrid_six_doubleElimination table").addClass("table no-border table-striped");
            //var data = grid.dataSource.data();
            //for (var i = 0; i < data.length; i++) {
            //    var dataItem = data[i];
            //    if (dataItem.get("IsDeleted") == true) {
            //        $("#schedulePreviewGrid_six tbody").find("tr[data-uid=" + dataItem.uid + "]").addClass("deletedRow");
            //    }
            //}
            grid.showColumn(0);
            verifyScheduleModel.set("toggleSwap", false);
            verifyScheduleModel.onToggleSwap();
        },

        resetGridCheckboxColumn: function () {

            var grid = $(verifyScheduleModel.matchesGrid).data("kendoGrid");
            var swapColumn = grid.columns[0];


            //IF THE COLUMN STATE IS HIDDEN OR UNDEFINED
            if (swapColumn.hidden == "undefined" || swapColumn.hidden == false) {
                grid.showColumn(0);
                verifyScheduleModel.set("toggleSwap", true);
            } else {
                grid.showColumn(0);
                verifyScheduleModel.set("toggleSwap", false);
            }
            verifyScheduleModel.onToggleSwap();
        },

        //#region-- MATCHES GRID --

        loadMatchesGrid: function () {
            verifyScheduleModel.set("isEditMatchesChanged", false);
            var grid = $(verifyScheduleModel.matchesGrid).data("kendoGrid");
            var matches = scheduleData.localMatchesDataSource.data();
            if (matches.length <= 0) {
                scheduleData.loadLocalMatchesData(scheduleDetails.ScheduledMatches);
            }
            var matchesGridColumns = columnsForAllActivityTypeGrid;
            var rowTemplate = $('#stepseven-doubleeliminationschedulepreviewrow-template').html();
            var altRowTemplate = $('#stepseven-doubleeliminationschedulepreviewaltrow-template').html();

            var dsNew = new kendo.data.DataSource({
                data: []
            });

            if (isStackOfficialsIntegrationEnabled.toLowerCase() === "true" && scheduleDetails.IsPosted && (scheduleDetails.ScheduleType == 1 || scheduleDetails.ScheduleType == 3)) {
                for (i = 0; i < matches.length; i++) {
                    scheduleData.localMatchesDataSource.options.data[i].isGameAndSchedulePosted = true;
                    scheduleData.localMatchesDataSource._data[i].isGameAndSchedulePosted = true;
                }
                $(".schedulePreviewGrid_six .k-grid-header .assignedOfficials").show();
            }
            if (scheduleDetails.get("IsSingleEliminationOn") == false && scheduleDetails.get("AutomationLevel") == common.automationTypes.Tournament.name) {
                $(verifyScheduleModel.commonMatchesGrid).data([]);
                //$(verifyScheduleModel.commonMatchesGrid).data([]);
                verifyScheduleModel.set("matchesGrid", verifyScheduleModel.doubleEliminationmatchesGrid);
                verifyScheduleModel.set("isDoubleEliminationOn", true);

                grid = $(verifyScheduleModel.doubleEliminationmatchesGrid).data("kendoGrid");
                scheduleData.localMatchesDataSource.group({ field: "IsLooserBracketMatch" });
                scheduleData.localMatchesDataSource.sort([{ field: "MatchOrderNo", dir: "asc" }]);
                matchesGridColumns = columnsForDoubleEliminationTournamentGrid;
                rowTemplate = $('#stepseven-doubleeliminationschedulepreviewrow-template').html();
                altRowTemplate = $('#stepseven-doubleeliminationschedulepreviewaltrow-template').html();
                if ($(verifyScheduleModel.commonMatchesGrid).data("kendoGrid")) {
                    $(verifyScheduleModel.commonMatchesGrid).data("kendoGrid").setDataSource(dsNew);
                }
                if ($(verifyScheduleModel.doubleEliminationmatchesGrid).data("kendoGrid")) {
                    $(verifyScheduleModel.doubleEliminationmatchesGrid).data("kendoGrid").setDataSource(scheduleData.localMatchesDataSource);
                }
            } else {
                verifyScheduleModel.set("isDoubleEliminationOn", false);
                //$(verifyScheduleModel.doubleEliminationmatchesGrid).data([]);
                verifyScheduleModel.set("matchesGrid", verifyScheduleModel.commonMatchesGrid);
                grid = $(verifyScheduleModel.matchesGrid).data("kendoGrid");
                scheduleData.localMatchesDataSource.group([]);
                scheduleData.localMatchesDataSource.sort([]);
                matchesGridColumns = columnsForAllActivityTypeGrid;
                var isAwayTeamDisplayFirst = scheduleDetails.get("IsAwayTeamDisplayFirst");
                if (scheduleDetails.ScheduleType == ScheduleType.Practice) {
                    rowTemplate = $('#stepseven-practiceschedulepreviewrow-template').html();
                    altRowTemplate = $('#stepseven-practiceschedulepreviewaltrow-template').html();
                } else {
                    if (isAwayTeamDisplayFirst) {
                        rowTemplate = $('#stepseven-awaydisplayfirstschedulepreviewrow-template').html();
                        altRowTemplate = $('#stepseven-awaydisplayfirstschedulepreviewaltrow-template').html();
                    } else {
                        rowTemplate = $('#stepseven-schedulepreviewrow-template').html();
                        altRowTemplate = $('#stepseven-schedulepreviewaltrow-template').html();
                    }
                }
                if ($(verifyScheduleModel.doubleEliminationmatchesGrid).data("kendoGrid")) {
                    $(verifyScheduleModel.doubleEliminationmatchesGrid).data("kendoGrid").setDataSource(dsNew);
                }
                if ($(verifyScheduleModel.commonMatchesGrid).data("kendoGrid")) {
                    var commonGrid = $(verifyScheduleModel.commonMatchesGrid).data("kendoGrid");
                    commonGrid.options.rowTemplate = kendo.template(rowTemplate);
                    commonGrid.options.altRowTemplate = kendo.template(altRowTemplate);
                    $(verifyScheduleModel.commonMatchesGrid).data("kendoGrid").setDataSource(scheduleData.localMatchesDataSource);
                }
            }
            if (!grid) {
                $(verifyScheduleModel.matchesGrid).kendoGrid({
                    dataSource: scheduleData.localMatchesDataSource,
                    pageable: false,
                    autoSync: false,
                    autoBind: false,
                    scrollable: false,
                    toolbar: ["create"],
                    editable: {
                        mode: "popup",
                        template: kendo.template($("#popup_editor").html())
                    },
                    columns: matchesGridColumns,
                    edit: verifyScheduleModel.editMatch,
                    save: function (saveEvent) {
                        saveEvent.preventDefault();
                        if (isStackOfficialsIntegrationEnabled.toLowerCase() === "true" && scheduleDetails.IsPosted && (scheduleDetails.ScheduleType == 1 || scheduleDetails.ScheduleType == 3)) {
                            saveEvent.model.isGameAndSchedulePosted = true;
                        } else {
                            saveEvent.model.isGameAndSchedulePosted = false;
                        }
                        var matchDs = saveEvent.sender.dataSource;

                        var isValid = verifyScheduleModel.validateMatchTimeCriteria(saveEvent.model);

                        if (isValid == true) {
                            matchDs.sync();
                            $("#validationMessaageEditMatch").css('display', 'none').html("");
                        }
                    },
                    dataBound: function (e) {
                        beautifyToggleButton("input[data-role=\"beautify-toggle-button\"]");
                        var selected = e.sender;
                        var eventType = scheduleDetails.ScheduleType == ScheduleType.Practice ? "Practice" : "";
                        var grid = $(verifyScheduleModel.matchesGrid).data("kendoGrid");
                        if (grid) {
                            $("#schedulePreviewGrid_six table").addClass("table no-border table-striped");
                            $("#schedulePreviewGrid_six_doubleElimination table").addClass("table no-border table-striped");
                            grid.showColumn(0);
                            verifyScheduleModel.set("toggleSwap", false);
                            verifyScheduleModel.onToggleSwap();
                        }

                    },
                    cancel: function (e) {
                        e.preventDefault();
                        var gridToCancel = $(verifyScheduleModel.matchesGrid).data("kendoGrid");

                        // var swapCheckBox = (e.container).find(".swapCheckBox")[0];
                        //var initialStatus = swapCheckBox.checked;

                        gridToCancel.cancelRow();
                        // swapCheckBox.checked = initialStatus;

                        verifyScheduleModel.resetGridCheckboxColumn();
                        //verifyScheduleModel.swapMatchList = [];
                        $('a.swapLink').hide();

                        // beautifyToggleButton("input[data-role=\"beautify-toggle-button\"]");
                        $(".swapMatchesbtn").removeClass("active");
                        verifyScheduleModel.expandAllConflicts();
                    },
                    detailInit: verifyScheduleModel.gridDetailInit,
                    detailTemplate: kendo.template($('#conflictlist-detail-template').html()),
                    rowTemplate: kendo.template(rowTemplate),
                    altRowTemplate: kendo.template(altRowTemplate)

                });



                $(".k-grid-toolbar").css("display", "none");

                //define the delete button click
                $(document).on("click", "#schedulePreviewGrid_six tbody tr .deleteMatch", function (e) {
                    e.preventDefault();
                    var matchGrid = $(verifyScheduleModel.matchesGrid).data("kendoGrid");
                    var item = matchGrid.dataItem($(this).closest("tr"));
                    if (typeof (item) == "undefined" || item == null)
                        return;

                    if (item.get("IsDeleted") == true) {
                        item.set("IsDeleted", false);
                    } else {
                        item.set("IsDeleted", true);
                    }

                    verifyScheduleModel.resetGridCheckboxColumn();
                });


                $(document).on("change", "#schedulePreviewGrid_six_doubleElimination tbody tr .swapCheckBox", function (e) {
                    //e.preventDefault();
                    var gridMatches = $(verifyScheduleModel.matchesGrid).data("kendoGrid");
                    var item = gridMatches.dataItem($(this).closest("tr"));
                    if (typeof (item) == "undefined" || item == null)
                        return;
                    var currentItem = $(this)[0];

                    if (item.Team2Type == TeamType.ByeTeam) {
                        currentItem.checked = false;
                        $(".swapCheckBox").trigger("elementRebind");
                        return;
                    }

                    var sameRoundSwapCheckboxes = $("#schedulePreviewGrid_six_doubleElimination tbody tr [roundnumber=" + item.RoundNumber + "][islooserbracketmatch=" + item.IsLooserBracketMatch + "]");
                    var isOtherRoundsGrayedOut = false;

                    var swapMatchesCnt = 0;
                    for (i = 0; i < sameRoundSwapCheckboxes.length; i++) {
                        var sameRoundSwapCheckbox = sameRoundSwapCheckboxes[i];

                        if (sameRoundSwapCheckbox.checked == true) {
                            isOtherRoundsGrayedOut = true;
                            swapMatchesCnt++;

                            if (swapMatchesCnt > 2)
                                break;
                        }
                    }
                    if (swapMatchesCnt == 2) {
                        $(".swapMatchesbtn").addClass("active");
                    } else {
                        $(".swapMatchesbtn").removeClass("active");
                    }
                    if (isOtherRoundsGrayedOut == true && swapMatchesCnt > 2) {
                        currentItem.checked = false;
                        $(".swapCheckBox").trigger("elementRebind");
                        return;
                    }

                    var otherRoundSwapCheckboxes = $("#schedulePreviewGrid_six_doubleElimination tbody tr .swapCheckBox[roundnumber!=" + item.RoundNumber + "]");

                    for (i = 0; i < otherRoundSwapCheckboxes.length; i++) {
                        var otherRoundSwapCheckbox = otherRoundSwapCheckboxes[i];
                        
                        if (isOtherRoundsGrayedOut == true) {
                            otherRoundSwapCheckbox.disabled = true;
                            otherRoundSwapCheckbox.checked = false;
                        } else {
                            otherRoundSwapCheckbox.disabled = false;
                        }
                    }

                    var sameRoundLooserBracketSwapCheckboxes = $("#schedulePreviewGrid_six_doubleElimination tbody tr .swapCheckBox[roundnumber=" + item.RoundNumber + "][islooserbracketmatch!=" + item.IsLooserBracketMatch + "]");

                    for (i = 0; i < sameRoundLooserBracketSwapCheckboxes.length; i++) {
                        var sameRoundLooserBracketSwapCheckbox = sameRoundLooserBracketSwapCheckboxes[i];

                        if (isOtherRoundsGrayedOut == true) {
                            sameRoundLooserBracketSwapCheckbox.disabled = true;
                            sameRoundLooserBracketSwapCheckbox.checked = false;
                        } else {
                            sameRoundLooserBracketSwapCheckbox.disabled = false;
                        }
                    }
                    $(".swapCheckBox").trigger("elementRebind");
                });

                $(document).on("change", "#schedulePreviewGrid_six tbody tr .swapCheckBox", function (e) {
                    //e.preventDefault();
                    var gridMatches = $(verifyScheduleModel.matchesGrid).data("kendoGrid");

                    var item = gridMatches.dataItem($(this).closest("tr"));
                    if (typeof (item) == "undefined" || item == null)
                        return;
                    var currentItem = $(this)[0];

                    if (item.Team2Type == TeamType.ByeTeam) {
                        currentItem.checked = false;
                        $(".swapCheckBox").trigger("elementRebind");
                        return;
                    }

                    var sameRoundSwapCheckboxes = "";
                    var AutomationLevel = scheduleDetails.get("AutomationLevel");

                    if (AutomationLevel == "Tournament") {
                        sameRoundSwapCheckboxes = $("#schedulePreviewGrid_six tbody tr [roundnumber=" + item.RoundNumber + "]");
                    } else {
                        sameRoundSwapCheckboxes = $("#schedulePreviewGrid_six tbody tr [data-matchorderno=" + item.MatchOrderNo + "] ");
                    }

                    var isOtherRoundsGrayedOut = false;

                    var swapMatchesCnt = 0;
                    for (i = 0; i < sameRoundSwapCheckboxes.length; i++) {
                        var sameRoundSwapCheckbox = sameRoundSwapCheckboxes[i];

                        if (sameRoundSwapCheckbox.checked == true) {

                            if (AutomationLevel == "Tournament") {
                                isOtherRoundsGrayedOut = true;
                            }
                            swapMatchesCnt++;

                            if (swapMatchesCnt > 2)
                                break;
                        }
                    }

                    var checkedCount = $("#schedulePreviewGrid_six tbody tr input.swapCheckBox.converted:checked").length;
                    if (swapMatchesCnt == 2) {
                        $(".swapMatchesbtn").addClass("active");
                    } else {
                        $(".swapMatchesbtn").removeClass("active");
                    }

                    if (AutomationLevel == "Tournament" && isOtherRoundsGrayedOut == true && swapMatchesCnt > 2) {
                        currentItem.checked = false;
                        $(".swapCheckBox").trigger("elementRebind");
                        return;
                    }
                    else if (checkedCount > 2) {
                        currentItem.checked = false;
                        $(".swapCheckBox").trigger("elementRebind");
                        return;
                    }

                    var otherRoundSwapCheckboxes = "";
                    if (AutomationLevel == "Tournament") {
                        otherRoundSwapCheckboxes = $("#schedulePreviewGrid_six tbody tr .swapCheckBox[roundnumber!=" + item.RoundNumber + "]");
                        for (i = 0; i < otherRoundSwapCheckboxes.length; i++) {
                            var otherRoundSwapCheckbox = otherRoundSwapCheckboxes[i];
                            if (isOtherRoundsGrayedOut == true) {
                                otherRoundSwapCheckbox.disabled = true;
                                otherRoundSwapCheckbox.checked = false;
                            } else {
                                otherRoundSwapCheckbox.disabled = false;
                            }
                        }
                    }

                    $(".swapCheckBox").trigger("elementRebind");
                });

                //defineGridColumnEditors(scheduleDetails.IsChildPortalEvent);
                verifyScheduleModel.set("isEditMatchesChanged", false);
                scheduleData.localMatchesDataSource.read();
                verifyScheduleModel.set("isSingleEliminationOn", scheduleDetails.get("IsSingleEliminationOn"));


            } else {

                //defineGridColumnEditors(scheduleDetails.IsChildPortalEvent);

            }
            if (isStackOfficialsIntegrationEnabled.toLowerCase() === "false" || !(scheduleDetails.IsPosted && (scheduleDetails.ScheduleType == 1 || scheduleDetails.ScheduleType == 3))) {
                $(".schedulePreviewGrid_six .k-grid-header .assignedOfficials").hide();

            }
            if (scheduleDetails.ScheduleType == ScheduleType.Practice) {
                $("#schedulePreviewGrid_six thead [data-field=HomeTeamID]").html("Event Name");
            } else {

                if (scheduleDetails.get("IsAwayTeamDisplayFirst")) {
                    $("#schedulePreviewGrid_six thead [data-field=HomeTeamID]").html("Away @ Home Team");
                } else {
                    $("#schedulePreviewGrid_six thead [data-field=HomeTeamID]").html("Home VS Away Team");
                }

            }

            var matchesGrid = $(verifyScheduleModel.matchesGrid).data("kendoGrid");


            if (!matchesGrid) return;

            var gridDs = matchesGrid.dataSource;

            gridDs.bind("change", function (e) {
                if (e.action != "itemchange" || e.field == "IsEdited") {
                    return;
                }

                if (e.field == "MatchOrderNo" || e.field == "RoundNumber" || e.field == "HomeTeamID"
                    || e.field == "AwayTeamID" || e.field == "Date" || e.field == "StartTime"
                    || e.field == "EndTime" || e.field == "LocationID" || e.field == "FieldID"
                    || e.field == "IsDeleted" || e.field == "ActionStatus" || e.field == "Notes") {
                    verifyScheduleModel.set("isEditMatchesChanged", true);
                    verifyScheduleModel.set("isNextLinkVisible", false);
                    verifyScheduleModel.set("isAcceptScheduleLinkVisible", true);

                    e.items[0].set("IsEdited", true);
                }
            });

            gridDs.bind("sync", function (e) {
                verifyScheduleModel.onDataBoundForMatches();
            });
            if (grid) {
                gridDs.sync();
            }
            common.scrollToTop();

            //Here we need to set tournament bracket
            GenerateBracket(scheduleDetails.get("AutomationLevel"), scheduleData.localMatchesDataSource._data,
                'bracketPreviewGrid_six', scheduleData.scheduleDataModel.eventScore,
                true, false, false, scheduleDetails.get("IsSingleEliminationOn"), scheduleDetails.get("Teams"));
            //End
        },
        //#endregion

        editMatches: function () {
            var isInEditMode = verifyScheduleModel.isInEditMode;
            verifyScheduleModel.set("isInEditMode", !isInEditMode);
        },
        byeTeamId: 0,
        practiceTeamId: 0,
        tbdTeamId: 0,

        //#region-- Validations --

        validateInputs: function (model) {

            return true;
        },

        validateData: function (model) {
            var matchNo = kendo.parseInt(model.MatchOrderNo);
            var roundNumber = kendo.parseInt(model.RoundNumber);

            var homeTeamId = kendo.parseInt(model.HomeTeamID);
            var awayTeamId = kendo.parseInt(model.AwayTeamID);

            var matchDate = kendo.parseDate(model.Date);

            var startTime = kendo.parseDate(model.StartTime);
            var endTime = kendo.parseDate(model.EndTime);

            var locationId = kendo.parseInt(model.LocationID);
            var fieldId = kendo.parseInt(model.FieldID);

            var validationErrors = model.ConflictsList;
            validationErrors.splice(0, validationErrors.length);

            if (awayTeamId != verifyScheduleModel.byeTeamId && scheduleDetails.get("AutomationLevel") != common.automationTypes.P.name) {
                if (locationId < 1) {
                    validationErrors.push({ Message: "Location is required" });
                }

                if (fieldId < 1) {
                    validationErrors.push({ Message: "Field is required" });
                }

                if (startTime == endTime) {
                    validationErrors.push({ Message: "Start time and End time should not be same" });
                }

                if (startTime > endTime) {
                    validationErrors.push({ Message: "Start time should be less than End time" });
                }
            }

            if (homeTeamId == awayTeamId) {
                validationErrors.push({ Message: "HomeTeam and AwayTeam should be different" });
            }

            var grid = $(verifyScheduleModel.matchesGrid).data("kendoGrid");

            if (validationErrors.length > 0) {
                return false;
            } else {
                return true;
            }
        },

        //#endregion-- Validations --

        locations: new kendo.data.ObservableArray([]),
        loadAllLocationsAndFields: function () {
            /*Here we need to check if event is edited by master portal and the event is exist for multiple portals then 
             *we need to fetch locations and fields for all portal groups*/

            var eventExistForMultiplePortal = false;
            var masterPortalId = jQuery('.masterPortalIdHidden').val();

            if (scheduleDetails.ScheduleEventId == scheduleDetails.MasterEventId) {
                for (var i = 0; i < scheduleDetails.Teams.length; i++) {
                    var team = scheduleDetails.Teams[i];
                    if (team.PortalID > 0 && team.PortalID != masterPortalId) {
                        eventExistForMultiplePortal = true;
                        break;
                    }
                }
            }
            verifyScheduleModel.set("eventExistForMultiplePortal", eventExistForMultiplePortal);

            if (eventExistForMultiplePortal) {
                portalGroupsLocationsDS.read();
                portalGroupsFieldsDS.read();
            } else {
                allLocationsDS.read();
                allFieldsDs.read();
            }
        },
        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: "350px",
                    title: "Check Field Availability",
                    modal: true,
                    actions: [
                        "Close"
                    ],
                    close: function () {
                        common.scrollToTop();
                    }
                });
                kendo.bind(fieldAvailabilityWindow, fieldAvailabilityModel);
            }
            $dialog = fieldAvailabilityWindow.data("kendoWindow");
            $dialog.wrapper.addClass("scom tournament-popup");
            fieldAvailabilityWindow.data("kendoWindow").center().open();

            /*style for field availability treeview node to make link*/
            jQuery('.k-in').css('text-decoration', 'underline');
        },
        allFieldsDataSource: null,
        editLocationDataSource: allLocationsDS,
        //#region---SWAP MATCHES-----

        onSwap: function (e) {
            e.preventDefault();
            var match1 = null;
            var match2 = null;
            var checkedMatchesRows = $("#schedulePreviewGrid_six tbody tr .swapCheckBox:checked").closest("tr");

            var gridMatches = $(verifyScheduleModel.matchesGrid).data("kendoGrid");
            if (checkedMatchesRows.length == 2) {
                match1 = gridMatches.dataItem(checkedMatchesRows[0]);
                match2 = gridMatches.dataItem(checkedMatchesRows[1]);
            } else {
                if (scheduleDetails.get("AutomationLevel") == common.automationTypes.Tournament.name) {
                    var checkedTounamentMatchesRows = $("#schedulePreviewGrid_six_doubleElimination tbody tr .swapCheckBox:checked").closest("tr");
                    if (verifyScheduleModel.swapMatchList.length == 2) {
                        match1 = verifyScheduleModel.swapMatchList[0][0];
                        match2 = verifyScheduleModel.swapMatchList[1][0];
                    } else if (checkedTounamentMatchesRows.length == 2) {
                        match1 = gridMatches.dataItem(checkedTounamentMatchesRows[0]);
                        match2 = gridMatches.dataItem(checkedTounamentMatchesRows[1]);
                    } else {
                        common.showMessage('Please select exactly 2 matches to swap.');
                        return;
                    }
                }
                else {
                    common.showMessage('Please select exactly 2 matches to swap.');
                    return;
                }
            }
            var tempMatch = JSON.parse(JSON.stringify(match1));
            tempMatch.Date = kendo.parseDate(kendo.toString(match1.Date, "F"));
            tempMatch.StartTime = kendo.parseDate(kendo.toString(match1.StartTime, "F"));
            tempMatch.EndTime = kendo.parseDate(kendo.toString(match1.EndTime, "F"));

            verifyScheduleModel.updateTheMatchesDetails(match1, match2);
            verifyScheduleModel.updateTheMatchesDetails(match2, tempMatch);

            gridMatches.dataSource.sync();

            GenerateBracket(scheduleDetails.get("AutomationLevel"), scheduleData.localMatchesDataSource._data,
                'bracketPreviewGrid_six', scheduleData.scheduleDataModel.eventScore,
                true, false, false, scheduleDetails.get("IsSingleEliminationOn"), scheduleDetails.get("Teams"));

            verifyScheduleModel.set("isEditMatchesChanged", true);
            verifyScheduleModel.set("isNextLinkVisible", false);
            verifyScheduleModel.set("isAcceptScheduleLinkVisible", true);
            verifyScheduleModel.set("swapMatchList", []);
        },
        toggleSwap: false,
        onToggleSwapText: "Swap",
        onToggleSwap: function (e) {
            var grid = $(verifyScheduleModel.matchesGrid).data("kendoGrid");
            var tournament = $('a.swapLink');
            if (verifyScheduleModel.get("toggleSwap") == true) {
                verifyScheduleModel.set("onToggleSwapText", "Cancel");
                verifyScheduleModel.set("toggleSwap", false);
                grid.showColumn(0);
                tournament.show();
            } else {
                verifyScheduleModel.set("onToggleSwapText", "Swap");
                verifyScheduleModel.set("toggleSwap", true);
                grid.hideColumn(0);
                tournament.removeClass("swapLinkActive");
                tournament.hide();
                verifyScheduleModel.set("swapMatchList", []);
            }
            $(".btn-tournament").blur();
            $(".swapMatchesbtn").removeClass("active");
        },

        updateTheMatchesDetails: function (match1, match2) {

            match1.Date = match2.Date;

            match1.FieldID = match2.FieldID;
            match1.FieldName = match2.FieldName;
            match1.LocationID = match2.LocationID;
            match1.LocationName = match2.LocationName;
            match1.StartTime = match2.StartTime;

            var match2Hour = match2.EndTime.getHours() - match2.StartTime.getHours();
            var match2Min = match2.EndTime.getMinutes() - match2.StartTime.getMinutes();

            var endDate = new Date(match1.StartTime);
            endDate.setHours(match1.StartTime.getHours() + match2Hour);
            endDate.setMinutes(match1.StartTime.getMinutes() + match2Min);

            match1.EndTime = endDate;
            match1.actionStatus = match2.actionStatus;
            match1.IsEdited = true;
        },
        expandThisMenu: function (e) {
            //var visibleContactDetails = jQuery('#teamInfoList_listbox').find('ul:visible');
            //if (visibleContactDetails.length > 1) {
            //    jQuery(visibleContactDetails).hide();
            //    return;
            //}
            var teamId = e.data.TeamId;
            if (e.data.CoachList.length < 1) {
                return;
            }
            if (e.handleObj.type == "mouseover") {
                var teamObject = null;
                //setTimeout(function () {
                jQuery.each(jQuery('#teamInfoList_listbox').find('li.k-item'), function (index, item) {
                    var divNode = jQuery(item).find('#teamRow');
                    var teamIdToMatch = jQuery(divNode).attr('teamId');
                    teamObject = jQuery('#teamInfoList_listbox').find('li.k-item:nth-child(' + (index + 1) + ')');
                    jQuery(teamObject).find('ul').offset({ top: teamObject.offset().top });

                    if (teamId == teamIdToMatch) {
                        e.data.set("isExpanded", true);
                        //return false;
                        if (jQuery(teamObject).find('ul').offset().top == 0) {
                            jQuery('#teamInfoList_listbox li.k-item:nth-child(' + (index + 1) + ') ul').offset({ top: teamObject.offset().top });
                        }
                    } else {
                        jQuery(teamObject).find('ul').hide();
                    }
                });
                //}, 50);
            } else {
                e.data.set("isExpanded", false);
            }
        },
        mailtoLink: function (e) {
            return "mailto:" + e.Email;
        },
        TeamInfoSelected: function (e) {
            $('#teamInfoListDiv').data("kendoDropDownList").click();
        },
        //#endregion---SWAP MATCHES-----

        isShowFireAlgorithmAlert: false,
        isNeedToGetScore: function () {
            return scheduleData.scheduleDataModel.isNeedToGetScore;
        },
        isUmbrellaScheduleEnabledAndIsNotTournament: function () {
            if (($('.hdn_isUmbrellaScheduleEnabled').val() == "True") && (scheduleDetails.get("AutomationLevel") != common.automationTypes.Tournament.name))
                return true;
            return false;
        },

        localMatchesDataSource: scheduleData.localMatchesDataSource

    });

    //#endregion ------------- Model --------------------------


    //#region ------------------ View Declaration ------------------------

    var verifyScheduleView = new kendo.View("stepseven-verifyschedule-template");
    verifyScheduleView.model = verifyScheduleModel;

    var actionView = new kendo.View("scheduleaction-template");
    actionView.model = verifyScheduleModel;

    //#endregion ------------------ View Declaration ------------------------

    //#region ------------------- Router Definition --------------------------------

    var verifyScheduleRouter = new kendo.Router({});

    function loadView() {
        scheduleLayout.showIn(("#content"), verifyScheduleView);
        loadTeams();
        if (scheduleLayout && actionView) {
            scheduleLayout.showIn(("#footerContent"), actionView);
        }
    }

    function loadData(eventId) {
        if (verifyScheduleModel.Team == null) {

            loadTeams();
        }
        if (scheduleDetails.get("AutomationLevel") != common.automationTypes.IMPORT.name) {
            var isScheduleDetailsChanged = scheduleData.scheduleDataModel.get("isScheduleDetailsChanged");
            verifyScheduleModel.getBlackoutDates();
            if (isScheduleDetailsChanged == false) {
                scheduleData.scheduleDataModel.set("isScheduleDetailsChanged", false);
            }

            verifyScheduleModel.set("isShowFireAlgorithmAlert", false);

            if (scheduleData.scheduleDataModel.get("isFireScheduleAlgorithm") == true) {
                if (scheduleData.scheduleDataModel.isAllocatedTeamsChange == true) {
                    loadTeams();
                }

                verifyScheduleModel.showSchedulePreview();
            } else {
                if (isScheduleDetailsChanged == true) {
                    verifyScheduleModel.set("isShowFireAlgorithmAlert", true);
                }
                verifyScheduleModel.showProgress();
                var grid = $(verifyScheduleModel.matchesGrid).data("kendoGrid");

                if (scheduleDetails.get("AutomationLevel") != common.automationTypes.Tournament.name) {
                    verifyScheduleModel.loadMatchesGrid();
                } else {
                    loadTournamentData();
                }

                if (scheduleData.scheduleDataModel.isAllocatedTeamsChange == true) {
                    loadTeams();
                }
                verifyScheduleModel.hideProgress();
                if (!grid) return;

            }

            if (eventId && eventId > 0) {
                if (scheduleData.isRequiredScheduleDetailsExists() == false) {
                    return;
                }
            }
        } else {
            if (scheduleDetails.ScheduleEventId < 0) {
                verifyScheduleModel.set("isAddNewVisible", false);
            }
            scheduleData.getUniqueLocations();
            verifyScheduleModel.loadMatchesGrid();
            var grid = $(verifyScheduleModel.matchesGrid).data("kendoGrid");
            if (!grid) return;
            // grid.dataSource.sync();
        }
    }

    function loadTournamentData() {
        if (verifyScheduleModel.isNeedToGetScore() == true && scheduleDetails.ScheduleEventId > 0) {
            loadEventScore();
        } else {
            verifyScheduleModel.loadMatchesGrid();
        }
    }

    function loadTeams() {
        verifyScheduleModel.set("TeamCoach", new kendo.data.ObservableArray([]));
        var lst = verifyScheduleModel.get("TeamCoach");
        var teamsList = scheduleDetails.get("Teams");
        var teams = "";
        var teamsLength = teamsList.length;
        for (var i = 0; i < teamsLength; i++) {
            var col = teamsList[i];
            lst.push({ TeamId: col.TeamID, TeamName: col.TeamName });

            if (teams === "") {
                teams = col.TeamID;
            } else {
                teams = teams + "," + col.TeamID;
            }
        }
        verifyScheduleModel.set("Teams", lst);

        verifyScheduleModel.set("TeamCoachDS", []);
        var serviceRootUrl = common.getServiceRootUrl();
        serviceRootUrl += "SchedulingTeams/GetHeadAndAssistantDetailByTeam";
        var teamList = teams.toString().split(',');
        $.ajax({
            type: "GET",
            data: { teamList: teamList },
            url: serviceRootUrl,
            contentType: "application/json",
            success: function (data) {
                scheduleData.scheduleDataModel.set("isAllocatedTeamsChange", false);
                $.map(verifyScheduleModel.get("TeamCoach"), function (val, index) {
                    var coachList = data.filter(function (dataValue, dataIndex) {
                        return dataValue.TeamID == val.TeamId;
                    });
                    if (coachList.length > 0) {
                        coachList.unshift({ FirstName: "" });
                    } else if (val.TeamId > 0) {
                        coachList.push({
                            CoachID: 0,
                            TeamID: 0,
                            UserId: 0,
                            FirstName: 'No allocated volunteers',
                            CellPhone: 'No contact number provided',
                            Email: 'No email provided'
                        });
                    }
                    val.CoachList = coachList;
                    if (index == verifyScheduleModel.get("TeamCoach").length - 1) {
                        verifyScheduleModel.set("TeamCoachDS", verifyScheduleModel.get("TeamCoach"));
                    }
                    $(".k-list-optionlabel").hide();
                });
            }
        });
    }

    function loadEventScore() {
        var serviceRootUrl = common.getServiceRootUrl();
        serviceRootUrl += "Score/GetEventScore";

        $.ajax({
            type: "GET",
            data: { eventId: scheduleDetails.ScheduleEventId },
            url: serviceRootUrl,
            contentType: "application/json",
            success: function (data) {
                scheduleData.scheduleDataModel.set("eventScore", data);
                scheduleDetails.set("eventScore", data);
                scheduleData.scheduleDataModel.set("isNeedToGetScore", false);
                verifyScheduleModel.loadMatchesGrid();
            }
        });
    }

    verifyScheduleRouter.route("/verifyschedule", function () {
        common.scrollToTop();

        scheduleLayout.showIn(("#content"), verifyScheduleView);
        if (scheduleLayout && actionView) {
            scheduleLayout.showIn(("#footerContent"), actionView);
        }
        verifyScheduleModel.set("isAddNewVisible", true);

        scheduleLayout.render($("#app"));

        verifyScheduleModel.set("byeTeamId", jQuery('.byeTeamIdHidden').val());
        verifyScheduleModel.set("practiceTeamId", jQuery('.practiceTeamIdHidden').val());

        //Here first check if It's edit event mode.
        var params = arguments[0];
        //here Check for gridview have any data so swapMatches Button hide 
        verifyScheduleModel.toggleSwapMatchesVisisbility();

        //here check if the scheduleDetails is alredy loaded then don't call the API
        var isScheduleSelectionChange = false;
        if (params) {
            var eventId = params.eventId;
            var existingEventId = scheduleDetails.get("ScheduleEventId");
            if (eventId && eventId != existingEventId) {
                isScheduleSelectionChange = true;
            }
        }
        loadView();

        if (scheduleData.isRequiredScheduleDetailsExists() && isScheduleSelectionChange == false) {
            var eventId = scheduleDetails.get("ScheduleEventId");
            loadData(eventId);
            verifyScheduleModel.loadAllLocationsAndFields();
            verifyScheduleModel.expandAllConflicts();
        } else {
            if (params) {
                var level = params.automationLevel;
                var eventId = params.eventId;
                if (eventId) {
                    scheduleDetails.set("ScheduleEventId", eventId);
                    scheduleDetails.set("AutomationLevel", level);
                    //If eventId then load data
                    verifyScheduleModel.showProgress();
                    scheduleData.loadDataForEditEvent(eventId, level, function () {

                        loadData(eventId);
                        verifyScheduleModel.loadAllLocationsAndFields();
                        //here Check for gridview have any data so swapMatches Button hide 
                        verifyScheduleModel.toggleSwapMatchesVisisbility();

                        if (scheduleDetails.IsChildPortalEvent && scheduleDetails.IsChildPortalEvent == true) {
                            verifyScheduleModel.set("isAddNewVisible", false);
                            verifyScheduleModel.set("isSwapVisible", false);
                        }
                        if (level != common.automationTypes.P.name) {
                            var saveAndNextButton = document.getElementById("nextNavigationLink");
                            common.disableSaveAndNextButton(saveAndNextButton);
                        }
                        verifyScheduleModel.hideProgress();
                    });
                }
            }
        }
        verifyScheduleModel.set("EventName", scheduleDetails.get("ScheduleName"));
        if (scheduleDetails.AutomationLevel == common.automationTypes.IMPORT.name) {
            // var eventId = scheduleDetails.get("ScheduleEventId");
            // if (eventId < 1) {
            verifyScheduleModel.resetAcceptButton();
            verifyScheduleModel.set("isNextLinkVisible", false);
            verifyScheduleModel.set("isAcceptScheduleLinkVisible", true);
            //  }
        }
        scheduleEventId = scheduleDetails.get("ScheduleEventId");

        setTimeout(function () {
            if (params.automationLevel != common.automationTypes.P.name) {
                var saveAndNextButton = document.getElementById("nextNavigationLink");
                common.disableSaveAndNextButton(saveAndNextButton);
                var acceptScheduleButton = document.getElementById("acceptScheduleLink");
                common.disableSaveAndNextButton(acceptScheduleButton);
            }
        }, 200);

        if (($('.hdn_isUmbrellaScheduleEnabled').val() == "True") && (scheduleDetails.get("AutomationLevel") != common.automationTypes.Tournament.name)) {
            verifyScheduleModel.createChildPortalCombo();
            verifyScheduleModel.loadAssociatedPortals();
        }

        if (scheduleDetails.IsChildPortalEvent && scheduleDetails.IsChildPortalEvent == true) {
            verifyScheduleModel.set("isAddNewVisible", false);
            verifyScheduleModel.set("isSwapVisible", false);
        }
        if (scheduleDetails.AutomationLevel == common.automationTypes.Tournament.name) {
            verifyScheduleModel.set("isAddNewVisible", false);
        }
        common.applyStopScrollToDropDown();
        $(".scheduleEventId").val(scheduleEventId);
    });

    verifyScheduleRouter.start();

    //#endregion ------------------- Router Definition --------------------------------

    function checkMatchIsBye(options) {
        if (options.model.AwayTeamID == verifyScheduleModel.byeTeamId || options.model.AwayTeamID == -1) //check match is bye
        {
            return true;
        } else {
            return false;
        }
    }

    function setFieldAvailabilityStatus(e) {
        if (!e.model)
            return;
        verifyScheduleModel.resetGridCheckboxColumn();
        var fieldDropDown = e.container.find('#EditFieldList').data("kendoDropDownList");
        var fieldDataSource = fieldDropDown.dataSource.view();
        var fieldIds = [];
        fieldIds.splice(0, fieldIds.length - 1);

        jQuery.each(fieldDataSource, function (index, value) {
            fieldIds.push(value.FieldID);
        });

        if (!e.model.Date || e.model.Date == "01/01/0001" || !e.model.StartTime || !e.model.EndTime || fieldIds.length < 1)
            return;

        var serviceRootUrl = common.getServiceRootUrl();
        var serviceUrl = serviceRootUrl + "Fields/CheckFieldAvailabilityStatus";

        var date = kendo.toString(e.model.Date, "MM/dd/yyyy");
        var startTime = common.getTimeSpanFromDate(e.model.StartTime);
        var endTime = common.getTimeSpanFromDate(e.model.EndTime);
        var eventId = scheduleDetails.get("ScheduleEventId");
        $.ajax({
            url: serviceUrl,
            type: "POST",
            contentType: 'application/json; charset=utf-8',
            data: JSON.stringify({ eventId: eventId, matchId: e.model.MatchID, fieldIds: fieldIds, date: date, startTime: startTime, endTime: endTime}),
            success: function (d) {
                if (!d)
                    return;

                jQuery.each(d, function (index, value) {
                    jQuery.each(fieldDataSource, function (index1, value1) {
                        if (value.FieldID == value1.FieldID) {
                            value1.set("FieldStatus", value.FieldStatus);
                        }
                    });
                });
            }
        });
    }

    scheduleData.scheduleEvent.bind("validationCheckForStep6", function (e) {
        e.preventDefault();
        var newIndex = e.newIndex;
        var eventId = scheduleDetails.get("ScheduleEventId");
        if (scheduleData.localScheduledMatches.length < 1) { //scheduleDetails.ScheduledMatches
            if (scheduleDetails.AutomationLevel == common.automationTypes.IMPORT.name) {
                common.showMessage("Import atleast one match.");
                return;
            } else {
                common.showMessage('Generate matches first.');
                return;
            }
        }
        else {
            if (scheduleDetails.AutomationLevel == common.automationTypes.IMPORT.name && eventId < 1) {
                common.showMessage('Generate matches first.');
                return;
            }
            if (newIndex == 7) {
                scheduleData.scheduleEvent.trigger("validationCheckForStep7", { newIndex: 7 });
            }
            else
                scheduleData.scheduleEvent.trigger("validationChecked", { isValid: true, nextStepIndex: e.newIndex });
        }
    });

    return {
        verifyScheduleModel: verifyScheduleModel
    };
}

/*Bracket view -> edit match using Kendo Window*/
var roundnumber = null;
function SwapCheck(e, matchOrderNo) {
    var matchDetail = null;
    var verifyScheduleModel = $(".checkFieldAvailability").get(0).kendoBindingTarget.source;
    var matchesList = verifyScheduleModel.localMatchesDataSource._data;
    matchDetail = Enumerable.From(matchesList)
        .Where(function (x) {
            return x.MatchOrderNo == matchOrderNo;
        })
        .Select(function (x) {
            return x;
        }).ToArray();

    var detail = matchDetail;
    var swapList = verifyScheduleModel.swapMatchList;
    if (swapList.length == 0) {
        roundnumber = detail[0].RoundNumber;
        $('a.swapLink').hide();
        $('a.swapLink.' + roundnumber + '').show();
    }
    if (detail[0].RoundNumber == roundnumber) {
        if ($(e).hasClass('swapLinkActive')) {
            swapList = jQuery.grep(swapList, function (value) {
                return value[0].MatchOrderNo != detail[0].MatchOrderNo;
            });
            verifyScheduleModel.set("swapMatchList", swapList);
        } else {
            swapList.push(detail);
        }
        $(e).toggleClass('swapLinkActive');
    }
    if ($(".swapLinkActive").length > 1) {
        $(".swapMatchesbtn").addClass("active");
    } else {
        $(".swapMatchesbtn").removeClass("active");
    }
}
function editLinkClicked(link, matchId, matchOrderNo, isTeamEditable) {
    var verifyScheduleModel = $(".checkFieldAvailability").get(0).kendoBindingTarget.source;
    var scheduleDetails = verifyScheduleModel.scheduleDetails;
    var matchesList = verifyScheduleModel.localMatchesDataSource._data;
    var matchToEdit = null;
    $(".scom.tournament-popup.gray-popup").removeClass("edit-match");
    if (matchId > 0) {
        matchToEdit = Enumerable.From(matchesList)
            .Where(function (x) {
                return x.MatchID == matchId;
            })
            .Select(function (x) {
                return x;
            }).ToArray();
    } else {
        matchToEdit = Enumerable.From(matchesList)
            .Where(function (x) {
                return x.MatchOrderNo == matchOrderNo;
            })
            .Select(function (x) {
                return x;
            }).ToArray();
    }
    //matchToEdit[0].set("IsEdited", true);
    var teamsDataSource = new kendo.data.ObservableArray([]);

    if (verifyScheduleModel.tbdTeamId == 0) {
        verifyScheduleModel.set('tbdTeamId', jQuery('.tbdTeamIdHidden').val());
    }
    for (var i = 0; i < scheduleDetails.Teams.length; i++) {
        teamsDataSource.push({ TeamID: scheduleDetails.Teams[i].TeamID, TeamName: scheduleDetails.Teams[i].TeamName, TeamType: scheduleDetails.Teams[i].TeamTypeID });
    }
    if (scheduleDetails.get("AutomationLevel") != "Tournament") {
        teamsDataSource.push({ TeamID: verifyScheduleModel.tbdTeamId, TeamName: 'TBD', TeamType: 5 });
    }
    var locationDataSource = verifyScheduleModel.allLocationsDS;

    var fieldsList = verifyScheduleModel.allFieldsDs.data();
    //fieldsList.push({ LocationID: 0, LocationName: 'Select Location', FieldID: 0, Name: 'Select Field', FieldStatus: 0 });

    var fieldsDataSource = new kendo.data.DataSource({
        data: fieldsList
    });

    fieldsDataSource.filter({
        field: "LocationID",
        operator: "eq",
        value: matchToEdit[0].LocationID
    });

    var awayTeamList = new kendo.data.ObservableArray([]);

    if (verifyScheduleModel.byeTeamId == 0) {
        verifyScheduleModel.set('byeTeamId', jQuery('.byeTeamIdHidden').val());
    }
    if (verifyScheduleModel.tbdTeamId == 0) {
        verifyScheduleModel.set('tbdTeamId', jQuery('.tbdTeamIdHidden').val());
    }
    for (var i = 0; i < scheduleDetails.Teams.length; i++) {
        awayTeamList.push({ TeamID: scheduleDetails.Teams[i].TeamID, TeamName: scheduleDetails.Teams[i].TeamName });
    }
    awayTeamList.push({ TeamID: verifyScheduleModel.byeTeamId, TeamName: 'Bye' });
    if (scheduleDetails.get("AutomationLevel") != "Tournament") {
        awayTeamList.push({ TeamID: verifyScheduleModel.tbdTeamId, TeamName: 'TBD' });
    }

    //Here if match is from round > 1 then we don't need to give team editable

    if (matchToEdit[0].Team2Type == 2 && verifyScheduleModel.isSingleEliminationOn) {
        matchToEdit[0].AwayTeamID = verifyScheduleModel.byeTeamId;
    }
    if (matchToEdit[0].RoundNumber > 1 || matchToEdit[0].IsLooserBracketMatch == true) {
        isTeamEditable = false;
    }

    var editMatchViewModel = kendo.observable({
        isTeamEditable: isTeamEditable,
        matchToEdit: matchToEdit[0],
        teams: teamsDataSource,
        awayTeams: awayTeamList,
        locations: locationDataSource,
        fieldsDataSource: fieldsDataSource,
        homeTeamId: matchToEdit[0].HomeTeamID,
        awayTeamId: matchToEdit[0].AwayTeamID,
        matchDate1: matchToEdit[0].Date,
        matchStartTime: matchToEdit[0].StartTime,
        matchEndTime: matchToEdit[0].EndTime,
        locationId: matchToEdit[0].LocationID,
        fieldId: matchToEdit[0].FieldID,
        homeTeamName: matchToEdit[0].Team1,
        awayTeamName: matchToEdit[0].Team2,
        actionStatus: matchToEdit[0].ActionStatus,
        note: matchToEdit[0].Notes,
        IsMatchStatusCanceled: matchToEdit[0].IsMatchStatusCanceled,
        statusName: matchToEdit[0].StatusName,
        isNoteVisible: matchToEdit[0].ActionStatus > 0,
        locationChanged: function (e) {
            var locationId = this.locationId;
            fieldsDataSource.filter([]);
            fieldsDataSource.filter({
                field: "LocationID",
                operator: "eq",
                value: parseInt(locationId)
            });
            this.set("fieldId", 0);
            if (e.sender._oldIndex == 0) {
                $("#locationListValidation").parent().css("display", "block");
                $("#locationListValidation").parent().parent().css("display", "block");
                $("#locationListValidation").html("Location is required");
            } else {
                $("#locationListValidation").parent().parent().css("display", "none");
                $("#locationListValidation").html("");
            }
            setFieldAvailabilityStatus(editMatchViewModel);
        },
        fieldChanged: function () {
            var fieldValidate = $("#fieldList").kendoValidator().data("kendoValidator");
            fieldValidate.validate();
            if (this.fieldId < 0) {
                return false;
            }
            setFieldAvailabilityStatus(editMatchViewModel);
        },
        awayTeamChanged: function (e) {
            if (e.data.awayTeamId == jQuery('.byeTeamIdHidden').val()) {
                e.data.set("matchStartTime", "00:00");
                e.data.set("matchEndTime", "00:00");
                e.data.set("matchDate1", null);
                e.data.set("locationId", 0);
                e.data.set("fieldId", 0);
                e.data.set("LocationName", "Select Location");
                e.data.set("FieldName", "Select Field");
                e.data.set("actionStatus", 0);
                e.data.set("note", null);
                $('.editableControl').hide();
            }
            else {
                $('.editableControl').show();
                this.actionChanged();
            }
        },
        matchdateChanged: function () {
            setFieldAvailabilityStatus(editMatchViewModel);
        },
        starttimeChanged: function () {
            setFieldAvailabilityStatus(editMatchViewModel);
        },
        endtimeChanged: function () {
            setFieldAvailabilityStatus(editMatchViewModel);
        },
        closeWindow: function () {
            var editMatchWindow = $("#bracketViewEditMatchWindow");
            editMatchWindow.data("kendoWindow").close();
        },
        cancelChangeClicked: function () {
            this.closeWindow();
        },
        saveMatchClicked: function (e) {
            var isAnyWrong = false;
            if (e.data.awayTeamId != jQuery('.byeTeamIdHidden').val()) {
                var validator = $("#bracketViewEditMatchWindow").kendoValidator().data("kendoValidator");
                if (validator.validate() == false) {
                    isAnyWrong = true;
                }
                if (isAnyWrong == false) {
                    var startDate = kendo.parseDate(kendo.format('{0:d}', scheduleDetails.StartDate));
                    var endDate = this.matchDate1;
                    if (startDate > endDate) {
                        isAnyWrong = true;
                        $("#matchDateValidation").parent().css("display", "block");
                        $("#matchDateValidation").parent().parent().css("display", "block");
                        $("#matchDateValidation").html("Match date should be less or equal event start date.");
                        return false;
                    } else {
                        $("#matchDateValidation").parent().parent().css("display", "none");
                        $("#matchDateValidation").html("");
                    }
                    var startTime = kendo.toString(this.matchStartTime, "HH:mm");
                    var endTime = kendo.toString(this.matchEndTime, "HH:mm");
                    if (startTime > endTime) {
                        isAnyWrong = true;
                        $("#endDateValidation").parent().css("display", "block");
                        $("#endDateValidation").parent().parent().css("display", "block");
                        $("#endDateValidation").html("End time should be greater than or equal to the start time.");
                        return false;
                    } else {
                        $("#endDateValidation").parent().parent().css("display", "none");
                        $("#endDateValidation").html("");
                    }
                    if (startTime == endTime) {
                        isAnyWrong = true;
                        $("#endDateValidation").parent().css("display", "block");
                        $("#endDateValidation").parent().parent().css("display", "block");
                        $("#endDateValidation").html("Start time and end time should not be same.");
                        return false;
                    } else {
                        $("#endDateValidation").parent().css("display", "none");
                        $("#endDateValidation").parent().parent().css("display", "none");
                        $("#endDateValidation").html("");
                    }
                    if (this.locationId == 0) {
                        isAnyWrong = true;
                        $("#locationListValidation").parent().css("display", "block");
                        $("#locationListValidation").parent().parent().css("display", "block");
                        $("#locationListValidation").html("Location is required");
                        return false;
                    } else {
                        $("#locationListValidation").parent().css("display", "none");
                        $("#locationListValidation").parent().parent().css("display", "none");
                        $("#locationListValidation").html("");
                    }
                    if (this.fieldId == 0) {
                        isAnyWrong = true;
                        $("#fieldValidation").parent().css("display", "block");
                        $("#fieldValidation").parent().parent().css("display", "block");
                        $("#fieldValidation").html("Field is required");
                        return false;
                    } else {
                        $("#fieldValidation").parent().css("display", "none");
                        $("#fieldValidation").parent().parent().css("display", "none");
                        $("#fieldValidation").html("");
                    }
                }
            }
            if (isAnyWrong == false) {
                if (this.homeTeamId == this.awayTeamId && this.homeTeamId > 0) {
                    isAnyWrong = true;
                    $("#TeamIdValidation").parent().css("display", "block");
                    $("#TeamIdValidation").parent().parent().css("display", "block");
                    $("#TeamIdValidation").html("Home team and away team should not be same.");
                } else {
                    $("#TeamIdValidation").parent().parent().css("display", "none");
                }
                var characterReg = /^[A-Za-z0-9;:+=?!@$%\*\s#&/\\_''‘’)(.,\-\\[\]]*$/;
                if (!characterReg.test($("#textForNotes").val())) {
                    isAnyWrong = true;
                    $("#notesValidation").parent().css("display", "block");
                    $("#notesValidation").parent().parent().css("display", "block");
                    $("#notesValidation").html("Input can contain letters, numbers, spaces, and the characters ! @ $ % * [ ] + = _ ; \ ? : , ( ) # & / ' . -");
                } else {
                    $("#notesValidation").parent().css("display", "none");
                    $("#notesValidation").parent().parent().css("display", "none");
                    $("#notesValidation").html("");
                }
            }

            if (isAnyWrong) {
                return false;
            } else {
                this.matchToEdit.set("Date", this.matchDate1);
                this.matchToEdit.set("StartTime", this.matchStartTime);
                this.matchToEdit.set("EndTime", this.matchEndTime);
                this.matchToEdit.set("LocationID", this.locationId);
                this.matchToEdit.set("FieldID", this.fieldId);
                this.matchToEdit.set("LocationName", $("#locationList").data("kendoDropDownList").text());
                var fieldDropDown = $("#fieldList").data("kendoDropDownList");
                var fieldDataSource = fieldDropDown.dataSource.view();
                var selectedFieldId = this.fieldId;
                var selectedFieldName = "";
                jQuery.each(fieldDataSource, function (index, value) {
                    if (value.FieldID == selectedFieldId) {
                        selectedFieldName = value.Name;
                        return false;
                    }
                });
                this.matchToEdit.set("FieldName", selectedFieldName);
                this.matchToEdit.set("ActionStatus", this.actionStatus);
                this.matchToEdit.set("StatusName", $("#actionList").data("kendoDropDownList").text());
                this.matchToEdit.set("Notes", this.note);
                var currentMatchRoundNo = this.matchToEdit.RoundNumber;
                var matchId = this.matchToEdit.MatchID;
                var matches = null;

                //here if the team details get changed then we need to replace the new team in the current as well as next round matches too
                if (this.matchToEdit.HomeTeamID != this.homeTeamId) {
                    var oldHomeTeamId = this.matchToEdit.HomeTeamID;
                    var newHomeTeamId = this.homeTeamId;
                    var matchOrderNo = this.matchToEdit.MatchOrderNo;
                    var nextMatches = this.matchToEdit.NextMatch;
                    var roundNumber = this.matchToEdit.RoundNumber;
                    var nextMatchLooserBracket = this.matchToEdit.NextMatchLooserBracket;
                    var byeTeamId = jQuery('.byeTeamIdHidden').val()
                    matches = Enumerable.From(matchesList)
                        .Where(function (x) {
                            return (x.HomeTeamID == oldHomeTeamId && x.RoundNumber == currentMatchRoundNo && x.MatchID == matchId && x.MatchOrderNo == matchOrderNo)
                                || (x.HomeTeamID == oldHomeTeamId && x.RoundNumber > currentMatchRoundNo && x.NextMatch == nextMatches)
                                || (x.HomeTeamID == oldHomeTeamId && x.RoundNumber >= currentMatchRoundNo && x.NextMatchLooserBracket == nextMatchLooserBracket && nextMatchLooserBracket > 0);


                        })
                        .Select(function (x) {
                            return x;
                        }).ToArray();
                    var newHomeTeamName = $("#HomeTeamList").data("kendoDropDownList").text();
                    var homeTeamDetail = Enumerable.From(teamsDataSource)
                        .Where(function (x) {
                            return (x.TeamID == newHomeTeamId);
                        })
                        .Select(function (x) {
                            return x;
                        }).FirstOrDefault(null);
                    jQuery.each(matches, function (index, value) {
                        value.set("HomeTeamID", newHomeTeamId);
                        value.set("Team1", newHomeTeamName);
                        if (homeTeamDetail != null)
                            value.set("Team1Type", homeTeamDetail.TeamType);
                    });
                    if (this.matchToEdit.AwayTeamID == byeTeamId && nextMatches != 0) {
                        nextRoundMatch = Enumerable.From(matchesList)
                            .Where(function (x) {
                                return (
                                    x.MatchID == nextMatches
                                );
                            })
                            .Select(function (x) {
                                return x;
                            }).ToArray();

                        jQuery.each(nextRoundMatch, function (index, value) {
                            var homeTeamPlaceHolder = value.get("HomeTeamPlaceHolder");
                            var awayTeamPlaceHolder = value.get("AwayTeamPlaceHolder");
                            if (homeTeamPlaceHolder.substring(1, homeTeamPlaceHolder.substring(0, homeTeamPlaceHolder.indexOf(" ")).length) == matchOrderNo) {
                                value.set("HomeTeamID", newHomeTeamId);
                                value.set("Team1", newHomeTeamName);
                                if (homeTeamDetail != null)
                                    value.set("Team1Type", homeTeamDetail.TeamType);
                                value.set("IsEdited", true);
                            }
                            if (awayTeamPlaceHolder.substring(1, awayTeamPlaceHolder.substring(0, awayTeamPlaceHolder.indexOf(" ")).length) == matchOrderNo) {
                                value.set("AwayTeamID", newHomeTeamId);
                                value.set("Team2", newHomeTeamName);
                                if (homeTeamDetail != null)
                                    value.set("Team2Type", homeTeamDetail.TeamType);
                                value.set("IsEdited", true);
                            }

                        });
                    }
                }

                if (this.matchToEdit.AwayTeamID != this.awayTeamId) {
                    var oldAwayTeamId = this.matchToEdit.AwayTeamID;
                    var newAwayTeamId = this.awayTeamId;
                    var nextMatches = this.matchToEdit.NextMatch;
                    var matchOrderNo = this.matchToEdit.MatchOrderNo;
                    var roundNumber = this.matchToEdit.RoundNumber;
                    var nextMatchLooserBracket = this.matchToEdit.NextMatchLooserBracket;
                    var matchHomeTeamId = this.homeTeamId;
                    var byeTeamId = jQuery('.byeTeamIdHidden').val()
                    matches = Enumerable.From(matchesList)
                        .Where(function (x) {

                            return (x.AwayTeamID == oldAwayTeamId && x.RoundNumber == currentMatchRoundNo && x.MatchID == matchId && x.MatchOrderNo == matchOrderNo)
                                || (x.AwayTeamID == oldAwayTeamId && x.RoundNumber > currentMatchRoundNo && x.NextMatch == nextMatches)
                                || (x.AwayTeamID == oldAwayTeamId && x.RoundNumber >= currentMatchRoundNo && x.NextMatchLooserBracket == nextMatchLooserBracket && nextMatchLooserBracket > 0);


                        })
                        .Select(function (x) {
                            return x;
                        }).ToArray();

                    var newAwayTeamName = $("#AwayTeamList").data("kendoDropDownList").text();
                    var newHomeTeamName = $("#HomeTeamList").data("kendoDropDownList").text();
                    var awayTeamDetail = Enumerable.From(teamsDataSource)
                        .Where(function (x) {
                            return (x.TeamID == newAwayTeamId);
                        })
                        .Select(function (x) {
                            return x;
                        }).FirstOrDefault(null);
                    jQuery.each(matches, function (index, value) {
                        if (newAwayTeamId == byeTeamId)
                            value.set("Team2Type", "2");
                        value.set("AwayTeamID", newAwayTeamId);
                        value.set("Team2", newAwayTeamName);
                        if (awayTeamDetail != null)
                            value.set("Team2Type", awayTeamDetail.TeamType);
                    });

                    if ((oldAwayTeamId == byeTeamId || newAwayTeamId == byeTeamId) && nextMatches != 0) {
                        nextRoundMatch = Enumerable.From(matchesList)
                            .Where(function (x) {
                                return (
                                    x.MatchID == nextMatches
                                );
                            })
                            .Select(function (x) {
                                return x;
                            }).ToArray();

                        jQuery.each(nextRoundMatch, function (index, value) {
                            var homeTeamPlaceHolder = value.get("HomeTeamPlaceHolder");
                            var awayTeamPlaceHolder = value.get("AwayTeamPlaceHolder");
                            if (homeTeamPlaceHolder != null && homeTeamPlaceHolder.substring(1, homeTeamPlaceHolder.substring(0, homeTeamPlaceHolder.indexOf(" ")).length) == matchOrderNo) {
                                if (oldAwayTeamId == byeTeamId) {
                                    value.set("HomeTeamID", null);
                                    value.set("Team1", homeTeamPlaceHolder);
                                    value.set("Team1Type", "5");
                                    value.set("IsEdited", true);
                                }
                                if (newAwayTeamId == byeTeamId) {
                                    value.set("Team1Type", "0");
                                    value.set("HomeTeamID", matchHomeTeamId);
                                    value.set("Team1", $("#HomeTeamList").data("kendoDropDownList").text());
                                    value.set("IsEdited", true);
                                }
                            }
                            if (awayTeamPlaceHolder != null && awayTeamPlaceHolder.substring(1, awayTeamPlaceHolder.substring(0, awayTeamPlaceHolder.indexOf(" ")).length) == matchOrderNo) {
                                if (oldAwayTeamId == byeTeamId) {
                                    value.set("Team2", awayTeamPlaceHolder);
                                    value.set("AwayTeamID", null);
                                    value.set("Team2Type", "5");
                                    value.set("IsEdited", true);
                                }
                                if (newAwayTeamId == byeTeamId) {
                                    value.set("Team2", $("#HomeTeamList").data("kendoDropDownList").text());
                                    value.set("AwayTeamID", matchHomeTeamId);
                                    value.set("Team2Type", "0");
                                    value.set("IsEdited", true);
                                }
                            }

                        });
                    }
                }
                this.matchToEdit.set("IsEdited", true);

                var grid = $(verifyScheduleModel.matchesGrid).data("kendoGrid");
                if (grid) {
                    var gridDs = grid.dataSource;
                    gridDs.sync();
                }
                verifyScheduleModel.resetGridCheckboxColumn();

                this.closeWindow();
                GenerateBracket(scheduleDetails.get("AutomationLevel"), matchesList, 'bracketPreviewGrid_six',
                    scheduleDetails.get("eventScore"), true, false, false, scheduleDetails.get("IsSingleEliminationOn"), scheduleDetails.get("Teams"));
            }
        },
        setMinMatchDate: function () {
            var startDatePicker = $("#matchDate").kendoDatePicker().data("kendoDatePicker");
            if (startDatePicker == null) return;
            startDatePicker.min(scheduleDetails.StartDate);

            startDatePicker.readonly(false);
            startDatePicker.enable(true);
            if (this.IsMatchStatusCanceled) {
                startDatePicker.enable(false);
            }
        },
        setTimePickerScroll: function () {
            var common = new Sschedule_commonFunctions();
            var widget = jQuery('#matchStartTime_timeview');
            if (widget) {
                common.stopScroll(widget);
            }

            widget = jQuery('#matchEndTime_timeview');
            if (widget) {
                common.stopScroll(widget);
            }
        },
        actionChanged: function () {
            var actionStatus = this.actionStatus;
            if (actionStatus > 0) {
                this.set("isNoteVisible", true);
                verifyScheduleModel.set("isNotesVisible", true);
                if (actionStatus == 1) {
                    this.set("IsMatchStatusCanceled", true);
                }
                else {
                    this.set("IsMatchStatusCanceled", false);
                }
            } else {
                this.set("IsMatchStatusCanceled", false);
                this.set("isNoteVisible", false);
                verifyScheduleModel.set("isNotesVisible", false);
            }
        }
    });
    //var bracketViewEditMatchTeamplate = new kendo.View("bracketViewEditMatch-template");
    //bracketViewEditMatchTeamplate.model = bracketViewEditMatchTeamplate;
    //bracketViewEditMatchTeamplate.render(jQuery("#editMatchDiv"));
    var objPossition = $(link).offset();

    if (matchToEdit[0].ActionStatus == 1) {
        editMatchViewModel.set("IsMatchStatusCanceled", true);
    }

    var editMatchWindow = $("#bracketViewEditMatchWindow");
    if (!editMatchWindow.data("kendoWindow")) {
        editMatchWindow.kendoWindow({
            width: "300px",
            title: "Edit Match",
            modal: true,
            actions: [
                "Close"
            ]
        });
    }
    var dialog = $("#bracketViewEditMatchWindow").data("kendoWindow");
    dialog.bind("open", function () {
        editMatchViewModel.setMinMatchDate();
        $("#matchDateValidation").html("");
        $("#endDateValidation").html("");
        $("#locationListValidation").html("");

        $("#fieldValidation").html("");
        $("#fieldValidation").parent().parent().css("display", "none");
        $("#matchDateValidation").parent().parent().css("display", "none");
        $("#endDateValidation").parent().parent().css("display", "none");
        $("#locationListValidation").parent().parent().css("display", "none");
        $("#TeamIdValidation").parent().parent().css("display", "none");
        $("#notesValidation").parent().parent().css("display", "none");
        if (matchToEdit[0].MatchID > 0) {
            $(".k-datepicker").removeClass('k-invalid');
            $("#matchDate").removeClass('k-invalid');
            $("#matchStartTime").removeClass('k-invalid');
            $("#matchEndTime").removeClass('k-invalid');
            $("#fieldList").removeClass('k-invalid');
            $("#notesValidation").removeClass('k-invalid');
        }
        editMatchViewModel.setTimePickerScroll();

        if (matchToEdit[0].Team2Type == 2) {
            $('.editableControl').hide();
        }
        else {
            $('.editableControl').show();
        }
    });
    kendo.bind(editMatchWindow, editMatchViewModel);
    var validatorHideMessge = $("#bracketViewEditMatchWindow").kendoValidator().data("kendoValidator");
    validatorHideMessge.hideMessages();
    validatorHideMessge.validate();
    $("#bracketViewEditMatchWindow").closest(".k-window").css({
        top: (objPossition.top) - 50,
        left: (objPossition.left) + 50,
    });
    editMatchWindow.data("kendoWindow").open();
    setFieldAvailabilityStatus(editMatchViewModel);
}
function setFieldAvailabilityStatus(data) {
    if (!data)
        return;

    var fieldDropDown = $("#fieldList").data("kendoDropDownList");
    var fieldDataSource = fieldDropDown.dataSource.view();
    var fieldIds = [];
    fieldIds.splice(0, fieldIds.length - 1);

    jQuery.each(fieldDataSource, function (index, value) {
        fieldIds.push(value.FieldID);
    });

    if (!data.matchDate1 || data.matchDate1 == "01/01/0001" || !data.matchStartTime || !data.matchEndTime || fieldIds.length < 1)
        return;

    var serviceRootUrl = common.getServiceRootUrl();
    var serviceUrl = serviceRootUrl + "Fields/CheckFieldAvailabilityStatus";
    var date = kendo.toString(data.matchDate1, "MM/dd/yyyy");
    var startTime = common.getTimeSpanFromDate(data.matchStartTime);
    var endTime = common.getTimeSpanFromDate(data.matchEndTime);
    var eventId = scheduleEventId;
    $.ajax({
        url: serviceUrl,
        type: "POST",
        contentType: 'application/json; charset=utf-8',
        data: JSON.stringify({ eventId: eventId, matchId: data.matchToEdit.MatchID, fieldIds: fieldIds, date: date, startTime: startTime, endTime: endTime }),
        success: function (d) {
            if (!d)
                return;

            jQuery.each(d, function (index, value) {
                jQuery.each(fieldDataSource, function (index1, value1) {
                    if (value.FieldID == value1.FieldID) {
                        value1.set("FieldStatus", value.FieldStatus);
                    }
                });
            });
        }
    });
}
function IsChildPortalEvent(eventId, successcallBack) {
    var common = new Sschedule_commonFunctions();
    var serviceRootUrl = common.getServiceRootUrl();
    var apiName = "SchedulingDetails/IsChildPortalEvent";
    serviceRootUrl += apiName + "/";
    $.ajax({
        url: serviceRootUrl,
        type: "GET",
        data: { eventId: eventId, selectedPortalId: localStorage[`selectedPortalId_${getPortalID}`] },
        success: function (result) {
                if (successcallBack) {
                    successcallBack(result);
                }
                return result;
        }
    });
}