(function (window, document, $) {
    'use strict';

    if (!$) { return; }

    var timers = {};
    var observerStarted = false;
    var radioCounter = 0;

    function intValue(value, fallback) {
        var n = parseInt(value, 10);
        if (isNaN(n)) { return typeof fallback === 'number' ? fallback : 0; }
        return Math.max(0, n);
    }

    function pageText($page, key) {
        var value = $page.attr('data-text-' + key);
        return typeof value === 'string' ? value : '';
    }

    function parseModel($page) {
        var $script = $page.find('#awardsPlannerModel');
        if (!$script.length) { return {}; }
        try {
            return JSON.parse($script.text() || '{}');
        } catch (e) {
            return {};
        }
    }

    function overrideKey(categoryId, levelId, danceId) {
        return [intValue(categoryId), intValue(levelId), intValue(danceId)].join(':');
    }

    function ageOverrideKey(categoryId, levelId, danceId, ageGroupId) {
        return [intValue(categoryId), intValue(levelId), intValue(danceId), intValue(ageGroupId)].join(':');
    }

    function getState($page) {
        var state = $page.data('awardsPlannerState');
        if (state) { return state; }

        var model = parseModel($page);
        state = {
            model: model,
            leaves: model.leaves || [],
            selectors: model.selectors || [],
            categoryLabels: model.category_labels || {},
            overrides: $.extend(true, {}, model.overrides || {}),
            leafIndex: {},
            selectorIndex: {}
        };

        $.each(state.leaves, function (_, leaf) {
            state.leafIndex[overrideKey(leaf.category_id, leaf.level_id, leaf.dance_id)] = leaf;
        });
        $.each(state.selectors, function (_, category) {
            state.selectorIndex[String(category.id)] = category;
        });

        $page.data('awardsPlannerState', state);
        return state;
    }

    function emptyResult() {
        return { gold:0, silver:0, bronze:0, participation:0, cup_1:0, cup_2:0, cup_3:0 };
    }

    function addResult(target, source) {
        $.each(['gold','silver','bronze','participation','cup_1','cup_2','cup_3'], function (_, key) {
            target[key] += intValue(source[key]);
        });
        return target;
    }

    function emptyStats() {
        return { competitions:0, entries:0, teams:0, planned_dancers:0 };
    }

    function statsForCompetitions(competitions) {
        var stats = emptyStats();
        $.each(competitions || [], function (_, competition) {
            var entries = intValue(competition.entries);
            if (!entries) { return; }
            stats.competitions += 1;
            stats.entries += entries;
            if (competition.type === 'team') {
                var teamSize = Math.max(1, intValue(competition.team_size, 1));
                stats.teams += entries;
                stats.planned_dancers += entries * teamSize;
            }
        });
        return stats;
    }

    function cloneSettings(settings) {
        settings = settings || {};
        return {
            cup_mode: settings.cup_mode || 'none',
            team_medal_mode: settings.team_medal_mode || 'placements',
            award_all: !!settings.award_all,
            depth_mode: settings.depth_mode === 'threshold' ? 'threshold' : 'fixed',
            fixed_places: Math.max(1, intValue(settings.fixed_places, 6)),
            threshold_entries: Math.max(1, intValue(settings.threshold_entries, 5)),
            threshold_low_places: Math.max(1, intValue(settings.threshold_low_places, 5)),
            threshold_high_places: Math.max(1, intValue(settings.threshold_high_places, 6)),
            override_enabled: intValue(settings.override_enabled) === 1 ? 1 : 0
        };
    }

    function readSettings($scope) {
        return {
            cup_mode: $scope.find('.awards-cup-mode').val() || 'none',
            team_medal_mode: $scope.find('.awards-team-medal-mode').val() || 'placements',
            award_all: $scope.find('.awards-award-all').is(':checked'),
            depth_mode: $scope.find('.awards-depth-mode:checked').val() || 'fixed',
            fixed_places: Math.max(1, intValue($scope.find('.awards-fixed-places').val(), 1)),
            threshold_entries: Math.max(1, intValue($scope.find('.awards-threshold-entries').val(), 1)),
            threshold_low_places: Math.max(1, intValue($scope.find('.awards-threshold-low').val(), 1)),
            threshold_high_places: Math.max(1, intValue($scope.find('.awards-threshold-high').val(), 1))
        };
    }

    function writeSettings($scope, settings) {
        settings = cloneSettings(settings);
        $scope.find('.awards-cup-mode').val(settings.cup_mode);
        $scope.find('.awards-team-medal-mode').val(settings.team_medal_mode);
        $scope.find('.awards-award-all').prop('checked', !!settings.award_all);
        $scope.find('.awards-depth-mode[value="' + settings.depth_mode + '"]').prop('checked', true);
        $scope.find('.awards-fixed-places').val(settings.fixed_places);
        $scope.find('.awards-threshold-entries').val(settings.threshold_entries);
        $scope.find('.awards-threshold-low').val(settings.threshold_low_places);
        $scope.find('.awards-threshold-high').val(settings.threshold_high_places);
    }

    function updateQuantityUI($scope, active) {
        var awardAll = $scope.find('.awards-award-all').is(':checked');
        var mode = $scope.find('.awards-depth-mode:checked').val() || 'fixed';
        var quantityDisabled = !active || awardAll;

        $scope.toggleClass('is-settings-disabled', !active);
        $scope.find('.awards-cup-mode').prop('disabled', !active);

        var isTeam = $scope.attr('data-is-team') === '1';
        $scope.find('.awards-team-medal-mode').prop('disabled', !active || !isTeam);
        $scope.find('.awards-team-setting-block').toggleClass('is-not-applicable', !isTeam);

        $scope.find('.awards-award-all').prop('disabled', !active);
        $scope.find('.awards-all-toggle')
            .toggleClass('is-active', awardAll)
            .toggleClass('is-control-disabled', !active);

        $scope.find('.awards-depth-settings').toggleClass('is-disabled', quantityDisabled);
        $scope.find('.awards-depth-mode').prop('disabled', quantityDisabled);

        $scope.find('.awards-fixed-panel').toggleClass('is-hidden', mode !== 'fixed');
        $scope.find('.awards-threshold-panel').toggleClass('is-hidden', mode !== 'threshold');

        $scope.find('.awards-fixed-places').prop('disabled', quantityDisabled || mode !== 'fixed');
        $scope.find('.awards-threshold-entries, .awards-threshold-low, .awards-threshold-high')
            .prop('disabled', quantityDisabled || mode !== 'threshold');
    }

    function normalizeNumericInput($input) {
        if ($input.val() === '') { return; }
        $input.val(Math.max(1, intValue($input.val(), 1)));
    }

    function awardedPlaces(entries, settings) {
        entries = intValue(entries);
        if (!entries) { return 0; }
        if (settings.award_all) { return entries; }

        var places = settings.depth_mode === 'threshold'
            ? (entries <= settings.threshold_entries ? settings.threshold_low_places : settings.threshold_high_places)
            : settings.fixed_places;

        return Math.min(entries, Math.max(1, intValue(places, 1)));
    }

    function calculateCompetitions(competitions, settings) {
        var result = emptyResult();
        settings = cloneSettings(settings);

        $.each(competitions || [], function (_, comp) {
            var entries = intValue(comp.entries);
            if (!entries) { return; }

            var awarded = awardedPlaces(entries, settings);
            if (!awarded) { return; }

            if (comp.type === 'team') {
                var teamSize = Math.max(1, intValue(comp.team_size, 1));

                if (settings.team_medal_mode === 'participation') {
                    result.participation += awarded * teamSize;
                } else {
                    if (awarded >= 1) { result.gold += teamSize; }
                    if (awarded >= 2) { result.silver += teamSize; }
                    if (awarded >= 3) { result.bronze += teamSize; }
                    if (awarded > 3) { result.participation += (awarded - 3) * teamSize; }
                }

                if ((settings.cup_mode === 'first' || settings.cup_mode === 'top3') && awarded >= 1) { result.cup_1 += 1; }
                if (settings.cup_mode === 'top3' && awarded >= 2) { result.cup_2 += 1; }
                if (settings.cup_mode === 'top3' && awarded >= 3) { result.cup_3 += 1; }
                return;
            }

            if (awarded >= 1) {
                if (settings.cup_mode === 'first' || settings.cup_mode === 'top3') { result.cup_1 += 1; }
                else { result.gold += 1; }
            }
            if (awarded >= 2) {
                if (settings.cup_mode === 'top3') { result.cup_2 += 1; }
                else { result.silver += 1; }
            }
            if (awarded >= 3) {
                if (settings.cup_mode === 'top3') { result.cup_3 += 1; }
                else { result.bronze += 1; }
            }
            if (awarded > 3) { result.participation += awarded - 3; }
        });

        return result;
    }

    function mainRowForLeaf($page, leaf) {
        return $page.find('.awards-main-row[data-main-key="' + String(leaf.main_key).replace(/"/g, '\\"') + '"]').first();
    }

    function baseSettingsForLeaf($page, leaf) {
        var $row = mainRowForLeaf($page, leaf);
        if (!$row.length) { return cloneSettings({}); }
        return cloneSettings(readSettings($row));
    }

    function leafSettingsForLeaf($page, state, leaf) {
        var key = overrideKey(leaf.category_id, leaf.level_id, leaf.dance_id);
        var override = state.overrides[key];
        if (override && intValue(override.override_enabled) === 1) {
            return cloneSettings(override);
        }
        return baseSettingsForLeaf($page, leaf);
    }

    function effectiveSettingsForCompetition($page, state, leaf, competition) {
        var settings = leafSettingsForLeaf($page, state, leaf);
        var ageGroupId = intValue(competition && competition.age_group_id);
        if (ageGroupId > 0) {
            var key = ageOverrideKey(leaf.category_id, leaf.level_id, leaf.dance_id, ageGroupId);
            var override = state.overrides[key];
            if (override && intValue(override.override_enabled) === 1) {
                return cloneSettings(override);
            }
        }
        return settings;
    }

    function writeResult($row, result) {
        $row.find('.awards-gold').text(intValue(result.gold));
        $row.find('.awards-silver').text(intValue(result.silver));
        $row.find('.awards-bronze').text(intValue(result.bronze));
        $row.find('.awards-participation').text(intValue(result.participation));
        $row.find('.awards-cup-1').text(intValue(result.cup_1));
        $row.find('.awards-cup-2').text(intValue(result.cup_2));
        $row.find('.awards-cup-3').text(intValue(result.cup_3));
    }

    function writeStats($page, $row, stats, isTeam) {
        var html = '<div class="awards-stat-main">' + intValue(stats.competitions) + ' <span>' + escapeHtml(pageText($page,'competitions')) + '</span></div>';
        if (isTeam) {
            html += '<div class="awards-stat-sub">' + intValue(stats.teams) + ' ' + escapeHtml(pageText($page,'teams')) + '</div>';
            html += '<div class="awards-stat-sub">' + intValue(stats.planned_dancers) + ' ' + escapeHtml(pageText($page,'planned-dancers')) + '</div>';
        } else {
            html += '<div class="awards-stat-sub">' + intValue(stats.entries) + ' ' + escapeHtml(pageText($page,'total-entries')) + '</div>';
        }
        $row.find('.awards-stats-cell').html(html);
    }

    function escapeHtml(value) {
        return $('<div>').text(value == null ? '' : value).html();
    }

    function breakdownHtml($page, items) {
        if (!items.length) {
            return '<div class="awards-summary-empty">' + escapeHtml(pageText($page,'no-cups')) + '</div>';
        }
        var html = '';
        $.each(items, function (_, item) {
            html += '<div class="awards-summary-line"><span>' + escapeHtml(item.label) + '</span><strong>' + intValue(item.value) + '</strong></div>';
        });
        return html;
    }

    function competitionsForOverrideRow(state, $row) {
        var categoryId = intValue($row.attr('data-category-id'));
        var levelId = intValue($row.attr('data-level-id'));
        var danceId = intValue($row.attr('data-dance-id'));
        var ageGroupId = intValue($row.attr('data-age-group-id'));
        var leaf = state.leafIndex[overrideKey(categoryId, levelId, danceId)];
        if (!leaf) { return []; }

        if (!ageGroupId) { return leaf.competitions || []; }

        return $.grep(leaf.competitions || [], function (competition) {
            return intValue(competition.age_group_id) === ageGroupId;
        });
    }

    function recalculateAll($page) {
        if (!$page || !$page.length) { return; }
        var state = getState($page);
        var mainResults = {};
        var categoryResults = {};
        var summaryResults = {};
        var totals = emptyResult();

        $page.find('.awards-main-row').each(function () {
            mainResults[$(this).attr('data-main-key')] = emptyResult();
        });

        $.each(state.leaves, function (_, leaf) {
            var mainKey = String(leaf.main_key);
            var categoryKey = String(leaf.category_id);
            var categoryId = intValue(leaf.category_id);
            var summaryKey;
            var summaryLabel;

            /*
             * In the final cup breakdown Championship and Other dances are
             * shown per dance. Every other category remains grouped only by
             * category.
             */
            if (categoryId === 4 || categoryId === 7) {
                summaryKey = 'dance:' + categoryId + ':' + intValue(leaf.dance_id);
                summaryLabel = leaf.dance_label
                    || state.categoryLabels[categoryKey]
                    || state.categoryLabels[categoryId]
                    || categoryKey;
            } else {
                summaryKey = 'category:' + categoryId;
                summaryLabel = state.categoryLabels[categoryKey]
                    || state.categoryLabels[categoryId]
                    || categoryKey;
            }

            if (!mainResults[mainKey]) { mainResults[mainKey] = emptyResult(); }
            if (!categoryResults[categoryKey]) { categoryResults[categoryKey] = emptyResult(); }
            if (!summaryResults[summaryKey]) {
                summaryResults[summaryKey] = {
                    label: summaryLabel,
                    result: emptyResult()
                };
            }

            $.each(leaf.competitions || [], function (_, competition) {
                var settings = effectiveSettingsForCompetition($page, state, leaf, competition);
                var calc = calculateCompetitions([competition], settings);
                addResult(mainResults[mainKey], calc);
                addResult(categoryResults[categoryKey], calc);
                addResult(summaryResults[summaryKey].result, calc);
                addResult(totals, calc);
            });
        });

        $page.find('.awards-main-row').each(function () {
            var $row = $(this);
            var key = $row.attr('data-main-key');
            writeResult($row, mainResults[key] || emptyResult());
        });

        $page.find('.awards-override-row').each(function () {
            var $row = $(this);
            var competitions = competitionsForOverrideRow(state, $row);
            var settings = readSettings($row);
            writeResult($row, calculateCompetitions(competitions, settings));
        });

        var totalMedals = totals.gold + totals.silver + totals.bronze + totals.participation;
        $page.find('#awardsSummaryGold').text(totals.gold);
        $page.find('#awardsSummarySilver').text(totals.silver);
        $page.find('#awardsSummaryBronze').text(totals.bronze);
        $page.find('#awardsSummaryParticipation').text(totals.participation);
        $page.find('#awardsSummaryMedals').text(totalMedals);

        $.each([1,2,3], function (_, place) {
            var items = [];
            var cupTotal = 0;
            $.each(summaryResults, function (_, group) {
                var value = intValue(group.result['cup_' + place]);
                if (!value) { return; }
                items.push({
                    label: group.label,
                    value: value
                });
                cupTotal += value;
            });
            $page.find('#awardsCup' + place + 'Breakdown').html(breakdownHtml($page, items));
            $page.find('#awardsSummaryCup' + place).text(cupTotal);
        });
    }

    function setStatus($scope, state, text) {
        var $status = $scope.find('.awards-save-status').first();
        $status.removeClass('is-saving is-saved is-error');
        if (state) { $status.addClass('is-' + state); }
        $status.text(text || '');
    }

    function ajaxSave($page, payload, $statusScope) {
        if ($statusScope && $statusScope.length) {
            setStatus($statusScope,'saving',pageText($page,'saving'));
        }

        return $.ajax({
            url: $page.attr('data-actions-url') || 'actions.php',
            type: 'POST',
            dataType: 'json',
            data: $.extend({action:'save_award_scope_settings'}, payload)
        }).done(function (response) {
            if (!$statusScope || !$statusScope.length) { return; }
            if (response && response.ok) {
                setStatus($statusScope,'saved',pageText($page,'saved'));
            } else {
                setStatus($statusScope,'error',(response && response.error) || pageText($page,'save-failed'));
            }
        }).fail(function (xhr) {
            if (!$statusScope || !$statusScope.length) { return; }
            var error = pageText($page,'save-failed');
            if (xhr.responseJSON && xhr.responseJSON.error) { error = xhr.responseJSON.error; }
            setStatus($statusScope,'error',error);
        });
    }

    function payloadFromScope($scope, overrideEnabled) {
        var settings = readSettings($scope);
        return {
            scope_type: $scope.attr('data-scope-type') || 'category',
            category_id: intValue($scope.attr('data-category-id')),
            level_id: intValue($scope.attr('data-level-id')),
            dance_id: intValue($scope.attr('data-dance-id')),
            age_group_id: intValue($scope.attr('data-age-group-id')),
            override_enabled: overrideEnabled ? 1 : 0,
            cup_mode: settings.cup_mode,
            team_medal_mode: settings.team_medal_mode,
            award_all: settings.award_all ? 1 : 0,
            depth_mode: settings.depth_mode,
            fixed_places: settings.fixed_places,
            threshold_entries: settings.threshold_entries,
            threshold_low_places: settings.threshold_low_places,
            threshold_high_places: settings.threshold_high_places
        };
    }

    function saveMainRow($page, $row) {
        return ajaxSave($page, payloadFromScope($row,true), $row);
    }

    function keyForOverrideRow($row) {
        return String($row.attr('data-override-key') || '');
    }

    function saveOverrideRow($page, $row) {
        var state = getState($page);
        var key = keyForOverrideRow($row);
        if (!key) { return $.Deferred().resolve().promise(); }

        var settings = cloneSettings(readSettings($row));
        settings.override_enabled = 1;
        state.overrides[key] = settings;
        return ajaxSave($page, payloadFromScope($row,true), $row);
    }

    function scheduleMainSave($page, $row) {
        var key = 'main:' + ($row.attr('data-main-key') || '');
        clearTimeout(timers[key]);
        setStatus($row,'saving',pageText($page,'changed'));
        timers[key] = setTimeout(function () { saveMainRow($page,$row); },450);
    }

    function scheduleOverrideSave($page, $row) {
        var key = keyForOverrideRow($row);
        var timerKey = 'override:' + key;
        clearTimeout(timers[timerKey]);
        setStatus($row,'saving',pageText($page,'changed'));
        timers[timerKey] = setTimeout(function () { saveOverrideRow($page,$row); },450);
    }

    function findLevel(category, levelId) {
        var found = null;
        $.each((category && category.levels) || [], function (_, level) {
            if (String(level.id) === String(levelId)) { found = level; return false; }
        });
        return found;
    }

    function findDance(level, danceId) {
        var found = null;
        $.each((level && level.dances) || [], function (_, dance) {
            if (String(dance.id) === String(danceId)) { found = dance; return false; }
        });
        return found;
    }

    function findAgeGroup(leaf, ageGroupId) {
        var found = null;
        $.each((leaf && leaf.age_groups) || [], function (_, ageGroup) {
            if (String(ageGroup.id) === String(ageGroupId)) { found = ageGroup; return false; }
        });
        return found;
    }

    function fillCategorySelect($page) {
        var state = getState($page);
        var $select = $page.find('#awardsOverrideCategory');
        var selected = $select.val();
        $select.empty().append($('<option>').val('').text(pageText($page,'select')));
        $.each(state.selectors, function (_, category) {
            $select.append($('<option>').val(category.id).text(category.label));
        });
        if (selected && state.selectorIndex[String(selected)]) { $select.val(selected); }
    }

    function resetAgeSelect($page) {
        $page.find('#awardsOverrideAge')
            .empty()
            .append($('<option>').val('').text(pageText($page,'select')))
            .prop('disabled',true);
        updateAddButtonState($page);
    }

    function populateLevels($page, categoryId) {
        var state = getState($page);
        var category = state.selectorIndex[String(categoryId)];
        var $level = $page.find('#awardsOverrideLevel');
        var $dance = $page.find('#awardsOverrideDance');

        $level.empty().append($('<option>').val('').text(pageText($page,'select'))).prop('disabled',!category);
        $dance.empty().append($('<option>').val('').text(pageText($page,'select'))).prop('disabled',true);
        resetAgeSelect($page);
        $page.find('#awardsOverrideDanceField').removeClass('is-hidden');

        if (!category) { updateAddButtonState($page); return; }
        $.each(category.levels || [], function (_, item) {
            $level.append($('<option>').val(item.id).text(item.label));
        });
        updateAddButtonState($page);
    }

    function populateDancesOrPrepareAge($page, categoryId, levelId) {
        var state = getState($page);
        var category = state.selectorIndex[String(categoryId)];
        var level = findLevel(category,levelId);
        var $dance = $page.find('#awardsOverrideDance');

        $dance.empty().append($('<option>').val('').text(pageText($page,'select')));
        resetAgeSelect($page);
        if (!category || !level) {
            $dance.prop('disabled',true);
            updateAddButtonState($page);
            return;
        }

        if (intValue(category.level_only) === 1) {
            $page.find('#awardsOverrideDanceField').addClass('is-hidden');
            populateAgeGroups($page,category,level,{id:0,label:''});
            return;
        }

        $page.find('#awardsOverrideDanceField').removeClass('is-hidden');
        $.each(level.dances || [], function (_, dance) {
            $dance.append($('<option>').val(dance.id).text(dance.label));
        });
        $dance.prop('disabled',false);
        updateAddButtonState($page);
    }

    function populateAgeGroups($page, category, level, dance) {
        var state = getState($page);
        var key = overrideKey(category.id,level.id,dance.id);
        var leaf = state.leafIndex[key];
        var $age = $page.find('#awardsOverrideAge');

        $age.empty().append($('<option>').val('').text(pageText($page,'select')));
        if (!leaf) {
            $age.prop('disabled',true);
            updateAddButtonState($page);
            return;
        }

        $age.append($('<option>').val('0').text(pageText($page,'all-age-groups')));
        $.each(leaf.age_groups || [], function (_, ageGroup) {
            $age.append($('<option>').val(ageGroup.id).text(ageGroup.label));
        });
        $age.prop('disabled',false);
        updateAddButtonState($page);
    }

    function selectedOverrideMeta($page) {
        var state = getState($page);
        var categoryId = $page.find('#awardsOverrideCategory').val();
        var levelId = $page.find('#awardsOverrideLevel').val();
        var ageValue = $page.find('#awardsOverrideAge').val();
        if (categoryId === '' || levelId === '' || ageValue === '' || ageValue === null) { return null; }

        var category = state.selectorIndex[String(categoryId)];
        var level = findLevel(category,levelId);
        if (!category || !level) { return null; }

        var dance;
        if (intValue(category.level_only) === 1) {
            dance = {id:0,label:''};
        } else {
            var danceValue = $page.find('#awardsOverrideDance').val();
            if (danceValue === '' || danceValue === null) { return null; }
            dance = findDance(level,danceValue);
            if (!dance) { return null; }
        }

        var leafKey = overrideKey(category.id,level.id,dance.id);
        var leaf = state.leafIndex[leafKey];
        if (!leaf) { return null; }

        var ageGroupId = intValue(ageValue);
        var ageGroup = ageGroupId > 0 ? findAgeGroup(leaf,ageGroupId) : null;
        if (ageGroupId > 0 && !ageGroup) { return null; }

        return {
            category: category,
            level: level,
            dance: dance,
            leaf: leaf,
            age_group_id: ageGroupId,
            age_group: ageGroup,
            scope_type: ageGroupId > 0 ? 'age_group' : 'override',
            key: ageGroupId > 0 ? ageOverrideKey(category.id,level.id,dance.id,ageGroupId) : leafKey
        };
    }

    function updateAddButtonState($page) {
        $page.find('#awardsAddOverride').prop('disabled', !selectedOverrideMeta($page));
    }

    function inheritedSettingsForMeta($page, state, meta) {
        if (!meta || !meta.leaf) { return cloneSettings({}); }
        if (meta.scope_type === 'age_group') {
            return leafSettingsForLeaf($page,state,meta.leaf);
        }
        return baseSettingsForLeaf($page,meta.leaf);
    }

    function pathForMeta($page, meta) {
        var parts = [meta.leaf.category_label, meta.leaf.level_label];
        if (!intValue(meta.leaf.level_only)) { parts.push(meta.leaf.dance_label); }
        parts.push(meta.age_group_id > 0 ? meta.age_group.label : pageText($page,'all-age-groups'));
        return parts.join(' / ');
    }

    function uniqueRadioNames($row) {
        radioCounter += 1;
        var name = 'awards_override_depth_' + radioCounter;
        $row.find('.awards-depth-mode').attr('name',name);
    }

    function existingOverrideRow($page, key) {
        var $found = $();
        $page.find('.awards-override-row').each(function () {
            if (String($(this).attr('data-override-key')) === String(key)) {
                $found = $(this);
                return false;
            }
        });
        return $found;
    }

    function flashOverrideRow($row) {
        if (!$row.length) { return; }
        $row.addClass('is-highlighted');
        if ($row[0] && $row[0].scrollIntoView) {
            $row[0].scrollIntoView({behavior:'smooth',block:'center'});
        }
        setTimeout(function () { $row.removeClass('is-highlighted'); },1200);
    }

    function addOverrideRow($page) {
        var state = getState($page);
        var meta = selectedOverrideMeta($page);
        if (!meta) { return; }

        var $existing = existingOverrideRow($page,meta.key);
        if ($existing.length) {
            flashOverrideRow($existing);
            return;
        }

        var previous = state.overrides[meta.key];
        var settings = previous && intValue(previous.override_enabled) === 1
            ? cloneSettings(previous)
            : inheritedSettingsForMeta($page,state,meta);
        settings.override_enabled = 1;
        state.overrides[meta.key] = settings;

        var $template = $page.find('#awardsOverrideRowTemplate');
        var $row = $template.clone(false,false)
            .removeAttr('id')
            .removeAttr('style')
            .removeClass('awards-override-row-template')
            .addClass('awards-override-row');

        $row.attr('data-override-key',meta.key)
            .attr('data-scope-type',meta.scope_type)
            .attr('data-category-id',meta.leaf.category_id)
            .attr('data-level-id',meta.leaf.level_id)
            .attr('data-dance-id',meta.leaf.dance_id)
            .attr('data-age-group-id',meta.age_group_id)
            .attr('data-is-team',intValue(meta.leaf.is_team) === 1 ? '1' : '0');

        uniqueRadioNames($row);
        $row.find('.awards-override-row-path').text(pathForMeta($page,meta));
        writeSettings($row,settings);
        updateQuantityUI($row,true);

        var competitions = meta.age_group_id > 0
            ? $.grep(meta.leaf.competitions || [], function (competition) {
                return intValue(competition.age_group_id) === meta.age_group_id;
            })
            : (meta.leaf.competitions || []);

        writeStats($page,$row,statsForCompetitions(competitions),intValue(meta.leaf.is_team) === 1);
        writeResult($row,calculateCompetitions(competitions,settings));

        $template.before($row);
        recalculateAll($page);
        saveOverrideRow($page,$row);
        flashOverrideRow($row);
    }

    function deleteOverrideRow($page, $row) {
        var state = getState($page);
        var key = keyForOverrideRow($row);
        if (!key) { return; }

        var $button = $row.find('.awards-delete-override');
        $button.prop('disabled',true);
        setStatus($row,'saving',pageText($page,'saving'));

        $.ajax({
            url: $page.attr('data-actions-url') || 'actions.php',
            type: 'POST',
            dataType: 'json',
            data: {
                action: 'delete_award_scope_settings',
                scope_type: $row.attr('data-scope-type') || 'override',
                category_id: intValue($row.attr('data-category-id')),
                level_id: intValue($row.attr('data-level-id')),
                dance_id: intValue($row.attr('data-dance-id')),
                age_group_id: intValue($row.attr('data-age-group-id'))
            }
        }).done(function (response) {
            if (response && response.ok) {
                delete state.overrides[key];
                $row.remove();
                recalculateAll($page);
            } else {
                setStatus($row,'error',(response && response.error) || pageText($page,'save-failed'));
                $button.prop('disabled',false);
            }
        }).fail(function (xhr) {
            var error = pageText($page,'save-failed');
            if (xhr.responseJSON && xhr.responseJSON.error) { error = xhr.responseJSON.error; }
            setStatus($row,'error',error);
            $button.prop('disabled',false);
        });
    }

    function bindEvents() {
        $(document)
            .off('.awardsPlanner')
            .on('input.awardsPlanner change.awardsPlanner', '#awardsPage .awards-main-row .awards-setting-input', function () {
                var $input = $(this);
                var $row = $input.closest('.awards-main-row');
                var $page = $row.closest('#awardsPage');
                if ($input.is('[type="number"]')) { normalizeNumericInput($input); }
                updateQuantityUI($row,true);
                recalculateAll($page);
                scheduleMainSave($page,$row);
            })
            .on('input.awardsPlanner change.awardsPlanner', '#awardsPage .awards-override-row .awards-setting-input', function () {
                var $input = $(this);
                var $row = $input.closest('.awards-override-row');
                var $page = $row.closest('#awardsPage');
                if ($input.is('[type="number"]')) { normalizeNumericInput($input); }
                updateQuantityUI($row,true);

                var state = getState($page);
                var key = keyForOverrideRow($row);
                var settings = cloneSettings(readSettings($row));
                settings.override_enabled = 1;
                state.overrides[key] = settings;

                recalculateAll($page);
                scheduleOverrideSave($page,$row);
            })
            .on('change.awardsPlanner', '#awardsPage #awardsOverrideCategory', function () {
                var $page = $(this).closest('#awardsPage');
                populateLevels($page,$(this).val());
            })
            .on('change.awardsPlanner', '#awardsPage #awardsOverrideLevel', function () {
                var $page = $(this).closest('#awardsPage');
                populateDancesOrPrepareAge($page,$page.find('#awardsOverrideCategory').val(),$(this).val());
            })
            .on('change.awardsPlanner', '#awardsPage #awardsOverrideDance', function () {
                var $page = $(this).closest('#awardsPage');
                var state = getState($page);
                var category = state.selectorIndex[String($page.find('#awardsOverrideCategory').val())];
                var level = findLevel(category,$page.find('#awardsOverrideLevel').val());
                var dance = findDance(level,$(this).val());
                if (category && level && dance) { populateAgeGroups($page,category,level,dance); }
                else { resetAgeSelect($page); }
            })
            .on('change.awardsPlanner', '#awardsPage #awardsOverrideAge', function () {
                updateAddButtonState($(this).closest('#awardsPage'));
            })
            .on('click.awardsPlanner', '#awardsPage #awardsAddOverride', function () {
                addOverrideRow($(this).closest('#awardsPage'));
            })
            .on('click.awardsPlanner', '#awardsPage .awards-delete-override', function () {
                var $row = $(this).closest('.awards-override-row');
                if (!$row.length) { return; }
                deleteOverrideRow($row.closest('#awardsPage'),$row);
            })
            .on('click.awardsPlanner', '#awardsPage #awardsSaveAll', function () {
                var $button = $(this);
                var $page = $button.closest('#awardsPage');
                var originalText = $button.text();
                var requests = [];

                recalculateAll($page);
                $button.prop('disabled',true).text(pageText($page,'saving'));

                $page.find('.awards-main-row').each(function () {
                    requests.push(saveMainRow($page,$(this)));
                });
                $page.find('.awards-override-row').each(function () {
                    requests.push(saveOverrideRow($page,$(this)));
                });

                $.when.apply($,requests).always(function () {
                    $button.prop('disabled',false).text(originalText);
                });
            });
    }

    function initPage($page) {
        if (!$page || !$page.length) { return; }
        getState($page);
        $page.find('.awards-main-row, .awards-override-row').each(function () {
            updateQuantityUI($(this),true);
        });
        fillCategorySelect($page);
        updateAddButtonState($page);
        recalculateAll($page);
    }

    function initAll() {
        $('#awardsPage').each(function () { initPage($(this)); });
    }

    function startObserver() {
        if (observerStarted || !window.MutationObserver || !document.body) { return; }
        observerStarted = true;
        new MutationObserver(function (mutations) {
            var found = false;
            $.each(mutations,function (_,mutation) {
                $.each(mutation.addedNodes || [],function (_,node) {
                    if (node.nodeType !== 1) { return; }
                    if ($(node).is('#awardsPage') || $(node).find('#awardsPage').length) { found = true; }
                });
            });
            if (found) { initAll(); }
        }).observe(document.body,{childList:true,subtree:true});
    }

    bindEvents();
    $(function () { initAll(); startObserver(); });

    window.AwardsPlanner = {
        init: initAll,
        recalculateAll: function () {
            $('#awardsPage').each(function () { recalculateAll($(this)); });
        }
    };

})(window, document, window.jQuery);