// This file is part of Moodle - http://moodle.org/
//
// Moodle is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Moodle is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.

import ajax from 'core/ajax';
import {getString} from "core/str";
import log from 'core/log';
import SRLogger from "core/local/reactive/srlogger";

/**
 * Flag to determine whether the screen reader-only logger has already been set, so we only need to set it once.
 *
 * @type {boolean}
 */
let isLoggerSet = false;

/**
 * Default mutation manager
 *
 * @module     core_courseformat/local/courseeditor/mutations
 * @class     core_courseformat/local/courseeditor/mutations
 * @copyright  2021 Ferran Recio <ferran@moodle.com>
 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */
export default class {

    // All course editor mutations for Moodle 4.0 will be located in this file.

    /**
     * Private method to call core_courseformat_update_course webservice.
     *
     * @method _callEditWebservice
     * @param {string} action
     * @param {number} courseId
     * @param {array} ids
     * @param {number} targetSectionId optional target section id (for moving actions)
     * @param {number} targetCmId optional target cm id (for moving actions)
     */
    async _callEditWebservice(action, courseId, ids, targetSectionId, targetCmId) {
        const args = {
            action,
            courseid: courseId,
            ids,
        };
        if (targetSectionId) {
            args.targetsectionid = targetSectionId;
        }
        if (targetCmId) {
            args.targetcmid = targetCmId;
        }
        let ajaxresult = await ajax.call([{
            methodname: 'core_courseformat_update_course',
            args,
        }])[0];
        return JSON.parse(ajaxresult);
    }

    /**
     * Private method to call core_courseformat_create_module webservice.
     *
     * @deprecated since Moodle 5.0 MDL-83469.
     * @todo MDL-83851 This will be deleted in Moodle 6.0.
     * @method _callEditWebservice
     * @param {number} courseId
     * @param {string} modName module name
     * @param {number} targetSectionNum target section number
     * @param {number} targetCmId optional target cm id
     */
    async _callAddModuleWebservice(courseId, modName, targetSectionNum, targetCmId) {
        log.debug('_callAddModuleWebservice() is deprecated. Use _callNewModuleWebservice() instead');
        const args = {
            courseid: courseId,
            modname: modName,
            targetsectionnum: targetSectionNum,
        };
        if (targetCmId) {
            args.targetcmid = targetCmId;
        }
        let ajaxresult = await ajax.call([{
            methodname: 'core_courseformat_create_module',
            args,
        }])[0];
        return JSON.parse(ajaxresult);
    }

    /**
     * Private method to call core_courseformat_new_module webservice.
     *
     * @method _callEditWebservice
     * @param {number} courseId
     * @param {string} modName module name
     * @param {number} targetSectionId target section number
     * @param {number} targetCmId optional target cm id
     */
    async _callNewModuleWebservice(courseId, modName, targetSectionId, targetCmId) {
        const args = {
            courseid: courseId,
            modname: modName,
            targetsectionid: targetSectionId,
        };
        if (targetCmId) {
            args.targetcmid = targetCmId;
        }
        let ajaxresult = await ajax.call([{
            methodname: 'core_courseformat_new_module',
            args,
        }])[0];
        return JSON.parse(ajaxresult);
    }

    /**
     * Execute a basic section state action.
     * @param {StateManager} stateManager the current state manager
     * @param {string} action the action name
     * @param {array} sectionIds the section ids
     * @param {number} targetSectionId optional target section id (for moving actions)
     * @param {number} targetCmId optional target cm id (for moving actions)
     */
    async _sectionBasicAction(stateManager, action, sectionIds, targetSectionId, targetCmId) {
        const logEntry = this._getLoggerEntry(stateManager, action, sectionIds, {
            targetSectionId,
            targetCmId,
            itemType: 'section',
        });
        const course = stateManager.get('course');
        this.sectionLock(stateManager, sectionIds, true);
        const updates = await this._callEditWebservice(
            action,
            course.id,
            sectionIds,
            targetSectionId,
            targetCmId
        );
        this.bulkReset(stateManager);
        stateManager.processUpdates(updates);
        this.sectionLock(stateManager, sectionIds, false);
        stateManager.addLoggerEntry(await logEntry);
    }

    /**
     * Execute a basic course module state action.
     * @param {StateManager} stateManager the current state manager
     * @param {string} action the action name
     * @param {array} cmIds the cm ids
     * @param {number} targetSectionId optional target section id (for moving actions)
     * @param {number} targetCmId optional target cm id (for moving actions)
     */
    async _cmBasicAction(stateManager, action, cmIds, targetSectionId, targetCmId) {
        const logEntry = this._getLoggerEntry(stateManager, action, cmIds, {
            targetSectionId,
            targetCmId,
            itemType: 'cm',
        });
        const course = stateManager.get('course');
        this.cmLock(stateManager, cmIds, true);
        const updates = await this._callEditWebservice(
            action,
            course.id,
            cmIds,
            targetSectionId,
            targetCmId
        );
        this.bulkReset(stateManager);
        stateManager.processUpdates(updates);
        this.cmLock(stateManager, cmIds, false);
        stateManager.addLoggerEntry(await logEntry);
    }

    /**
     * Get log entry for the current action.
     * @param {StateManager} stateManager the current state manager
     * @param {string} action the action name
     * @param {int[]|null} itemIds the element ids
     * @param {Object|undefined} data extra params for the log entry
     * @param {string|undefined} data.itemType the element type (will be taken from action if none)
     * @param {int|null|undefined} data.targetSectionId the target section id
     * @param {int|null|undefined} data.targetCmId the target cm id
     * @param {String|null|undefined} data.component optional component (for format plugins)
     * @param {Object|undefined} [data.feedbackParams] the params to build the feedback message
     * @return {Object} the log entry
     */
    async _getLoggerEntry(stateManager, action, itemIds, data = {}) {
        if (!isLoggerSet) {
            // In case the logger has not been set from init(), ensure we set the logger.
            stateManager.setLogger(new SRLogger());
            isLoggerSet = true;
        }
        let feedbackParams = {
            action,
            itemType: data.itemType ?? action.split('_')[0],
        };
        let batch = '';
        if (itemIds.length > 1) {
            feedbackParams.count = itemIds.length;
            batch = '_batch';
        } else if (itemIds.length === 1) {
            const itemInfo = stateManager.get(feedbackParams.itemType, itemIds[0]);
            feedbackParams.name = itemInfo.title ?? itemInfo.name;
            // Apply shortener for modules like label.
        }
        if (data.targetSectionId) {
            feedbackParams.targetSectionName = stateManager.get('section', data.targetSectionId).title;
        }
        if (data.targetCmId) {
            feedbackParams.targetCmName = stateManager.get('cm', data.targetCmId).name;
        }
        if (data.feedbackParams) {
            feedbackParams = {...feedbackParams, ...data.feedbackParams};
        }

        const message = await getString(
            `${action.toLowerCase()}_feedback${batch}`,
            data.component ?? 'core_courseformat',
            feedbackParams
        );

        return {
            feedbackMessage: message,
        };
    }

    /**
     * Mutation module initialize.
     *
     * The reactive instance will execute this method when addMutations or setMutation is invoked.
     *
     * @param {StateManager} stateManager the state manager
     */
    init(stateManager) {
        // Add a method to prepare the fields when some update is coming from the server.
        stateManager.addUpdateTypes({
            prepareFields: this._prepareFields,
        });
        // Use the screen reader-only logger (SRLogger) to handle the feedback messages from the mutations.
        stateManager.setLogger(new SRLogger());
        isLoggerSet = true;
    }

    /**
     * Add default values to state elements.
     *
     * This method is called every time a webservice returns a update state message.
     *
     * @param {Object} stateManager the state manager
     * @param {String} updateName the state element to update
     * @param {Object} fields the new data
     * @returns {Object} final fields data
     */
    _prepareFields(stateManager, updateName, fields) {
        // Any update should unlock the element.
        fields.locked = false;
        return fields;
    }

    /**
     * Hides sections.
     * @param {StateManager} stateManager the current state manager
     * @param {array} sectionIds the list of section ids
     */
    async sectionHide(stateManager, sectionIds) {
        await this._sectionBasicAction(stateManager, 'section_hide', sectionIds);
    }

    /**
     * Show sections.
     * @param {StateManager} stateManager the current state manager
     * @param {array} sectionIds the list of section ids
     */
    async sectionShow(stateManager, sectionIds) {
        await this._sectionBasicAction(stateManager, 'section_show', sectionIds);
    }

    /**
     * Show cms.
     * @param {StateManager} stateManager the current state manager
     * @param {array} cmIds the list of cm ids
     */
    async cmShow(stateManager, cmIds) {
        await this._cmBasicAction(stateManager, 'cm_show', cmIds);
    }

    /**
     * Hide cms.
     * @param {StateManager} stateManager the current state manager
     * @param {array} cmIds the list of cm ids
     */
    async cmHide(stateManager, cmIds) {
        await this._cmBasicAction(stateManager, 'cm_hide', cmIds);
    }

    /**
     * Stealth cms.
     * @param {StateManager} stateManager the current state manager
     * @param {array} cmIds the list of cm ids
     */
    async cmStealth(stateManager, cmIds) {
        await this._cmBasicAction(stateManager, 'cm_stealth', cmIds);
    }

    /**
     * Duplicate course modules
     * @param {StateManager} stateManager the current state manager
     * @param {array} cmIds the list of course modules ids
     * @param {number|undefined} targetSectionId the optional target sectionId
     * @param {number|undefined} targetCmId the target course module id
     */
    async cmDuplicate(stateManager, cmIds, targetSectionId, targetCmId) {
        const logEntry = this._getLoggerEntry(stateManager, 'cm_duplicate', cmIds);
        const course = stateManager.get('course');
        // Lock all target sections.
        const sectionIds = new Set();
        if (targetSectionId) {
            sectionIds.add(targetSectionId);
        } else {
            cmIds.forEach((cmId) => {
                const cm = stateManager.get('cm', cmId);
                sectionIds.add(cm.sectionid);
            });
        }
        this.sectionLock(stateManager, Array.from(sectionIds), true);

        const updates = await this._callEditWebservice('cm_duplicate', course.id, cmIds, targetSectionId, targetCmId);
        this.bulkReset(stateManager);
        stateManager.processUpdates(updates);

        this.sectionLock(stateManager, Array.from(sectionIds), false);
        stateManager.addLoggerEntry(await logEntry);
    }

    /**
     * Move course modules to specific course location.
     *
     * Note that one of targetSectionId or targetCmId should be provided in order to identify the
     * new location:
     *  - targetCmId: the activities will be located avobe the target cm. The targetSectionId
     *                value will be ignored in this case.
     *  - targetSectionId: the activities will be appended to the section. In this case
     *                     targetSectionId should not be present.
     *
     * @param {StateManager} stateManager the current state manager
     * @param {array} cmids the list of cm ids to move
     * @param {number} targetSectionId the target section id
     * @param {number} targetCmId the target course module id
     */
    async cmMove(stateManager, cmids, targetSectionId, targetCmId) {
        if (!targetSectionId && !targetCmId) {
            throw new Error(`Mutation cmMove requires targetSectionId or targetCmId`);
        }
        const course = stateManager.get('course');
        this.cmLock(stateManager, cmids, true);
        const updates = await this._callEditWebservice('cm_move', course.id, cmids, targetSectionId, targetCmId);
        this.bulkReset(stateManager);
        stateManager.processUpdates(updates);
        this.cmLock(stateManager, cmids, false);
    }

    /**
     * Move course modules after a specific course location.
     *
     * @param {StateManager} stateManager the current state manager
     * @param {array} sectionIds the list of section ids to move
     * @param {number} targetSectionId the target section id
     */
    async sectionMoveAfter(stateManager, sectionIds, targetSectionId) {
        if (!targetSectionId) {
            throw new Error(`Mutation sectionMoveAfter requires targetSectionId`);
        }
        const course = stateManager.get('course');
        this.sectionLock(stateManager, sectionIds, true);
        const updates = await this._callEditWebservice('section_move_after', course.id, sectionIds, targetSectionId);
        this.bulkReset(stateManager);
        stateManager.processUpdates(updates);
        this.sectionLock(stateManager, sectionIds, false);
    }

    /**
     * Add a new section to a specific course location.
     *
     * @param {StateManager} stateManager the current state manager
     * @param {number} targetSectionId optional the target section id
     */
    async addSection(stateManager, targetSectionId) {
        if (!targetSectionId) {
            targetSectionId = 0;
        }
        const course = stateManager.get('course');
        const updates = await this._callEditWebservice('section_add', course.id, [], targetSectionId);
        stateManager.processUpdates(updates);
        const logEntry = this._getLoggerEntry(stateManager, 'section_add', []);
        stateManager.addLoggerEntry(await logEntry);
    }

    /**
     * Delete sections.
     *
     * @param {StateManager} stateManager the current state manager
     * @param {array} sectionIds the list of course modules ids
     */
    async sectionDelete(stateManager, sectionIds) {
        const course = stateManager.get('course');
        const logEntry = this._getLoggerEntry(stateManager, 'section_delete', sectionIds);
        const updates = await this._callEditWebservice('section_delete', course.id, sectionIds);
        this.bulkReset(stateManager);
        stateManager.processUpdates(updates);
        stateManager.addLoggerEntry(await logEntry);
    }

    /**
     * Delete cms.
     * @param {StateManager} stateManager the current state manager
     * @param {array} cmIds the list of section ids
     */
    async cmDelete(stateManager, cmIds) {
        const course = stateManager.get('course');
        const logEntry = this._getLoggerEntry(stateManager, 'cm_delete', cmIds);
        this.cmLock(stateManager, cmIds, true);
        const updates = await this._callEditWebservice('cm_delete', course.id, cmIds);
        this.bulkReset(stateManager);
        this.cmLock(stateManager, cmIds, false);
        stateManager.processUpdates(updates);
        stateManager.addLoggerEntry(await logEntry);
    }

    /**
     * Add a new module to a specific course section.
     *
     * @deprecated since Moodle 5.0 MDL-83469.
     * @todo MDL-83851 This will be deleted in Moodle 6.0.
     * @param {StateManager} stateManager the current state manager
     * @param {string} modName the modulename to add
     * @param {number} targetSectionNum the target section number
     * @param {number} targetCmId optional the target cm id
     */
    async addModule(stateManager, modName, targetSectionNum, targetCmId) {
        log.debug('addModule() is deprecated. Use newModule() instead');
        if (!modName) {
            throw new Error(`Mutation addModule requires moduleName`);
        }
        if (!targetSectionNum) {
            throw new Error(`Mutation addModule requires targetSectionNum`);
        }
        if (!targetCmId) {
            targetCmId = 0;
        }
        const course = stateManager.get('course');
        const updates = await this._callAddModuleWebservice(course.id, modName, targetSectionNum, targetCmId);
        stateManager.processUpdates(updates);
    }

    /**
     * Add a new module to a specific course section.
     *
     * @param {StateManager} stateManager the current state manager
     * @param {string} modName the modulename to add
     * @param {number} targetSectionId the target section id
     * @param {number} targetCmId optional the target cm id
     */
    async newModule(stateManager, modName, targetSectionId, targetCmId) {
        if (!modName) {
            throw new Error(`Mutation newModule requires moduleName`);
        }
        if (!targetSectionId) {
            throw new Error(`Mutation newModule requires targetSectionId`);
        }
        if (!targetCmId) {
            targetCmId = 0;
        }
        const course = stateManager.get('course');
        const pluginname = await getString(
            'pluginname',
            `${modName.toLowerCase()}`,
        );
        const logEntry = this._getLoggerEntry(stateManager, 'cm_add', [], {
            feedbackParams: {
                'modname': pluginname,
            },
        });
        const updates = await this._callNewModuleWebservice(course.id, modName, targetSectionId, targetCmId);
        stateManager.processUpdates(updates);
        stateManager.addLoggerEntry(await logEntry);
    }

    /**
     * Mark or unmark course modules as dragging.
     *
     * @param {StateManager} stateManager the current state manager
     * @param {array} cmIds the list of course modules ids
     * @param {bool} dragValue the new dragging value
     */
    cmDrag(stateManager, cmIds, dragValue) {
        this.setPageItem(stateManager);
        this._setElementsValue(stateManager, 'cm', cmIds, 'dragging', dragValue);
    }

    /**
     * Mark or unmark course sections as dragging.
     *
     * @param {StateManager} stateManager the current state manager
     * @param {array} sectionIds the list of section ids
     * @param {bool} dragValue the new dragging value
     */
    sectionDrag(stateManager, sectionIds, dragValue) {
        this.setPageItem(stateManager);
        this._setElementsValue(stateManager, 'section', sectionIds, 'dragging', dragValue);
    }

    /**
     * Mark or unmark course modules as complete.
     *
     * @param {StateManager} stateManager the current state manager
     * @param {array} cmIds the list of course modules ids
     * @param {bool} complete the new completion value
     */
    async cmCompletion(stateManager, cmIds, complete) {
        const newState = (complete) ? 1 : 0;
        const action = (newState == 1) ? 'cm_complete' : 'cm_uncomplete';
        const logEntry = this._getLoggerEntry(stateManager, action, cmIds);
        stateManager.setReadOnly(false);
        cmIds.forEach((id) => {
            const element = stateManager.get('cm', id);
            if (element) {
                element.isoverallcomplete = complete;
                element.completionstate = newState;
            }
        });
        stateManager.setReadOnly(true);
        stateManager.addLoggerEntry(await logEntry);
    }

    /**
     * Move cms to the right: indent = 1.
     * @param {StateManager} stateManager the current state manager
     * @param {array} cmIds the list of cm ids
     */
    async cmMoveRight(stateManager, cmIds) {
        await this._cmBasicAction(stateManager, 'cm_moveright', cmIds);
    }

    /**
     * Move cms to the left: indent = 0.
     * @param {StateManager} stateManager the current state manager
     * @param {array} cmIds the list of cm ids
     */
    async cmMoveLeft(stateManager, cmIds) {
        await this._cmBasicAction(stateManager, 'cm_moveleft', cmIds);
    }

    /**
     * Set cms group mode to NOGROUPS.
     * @param {StateManager} stateManager the current state manager
     * @param {array} cmIds the list of cm ids
     */
    async cmNoGroups(stateManager, cmIds) {
        await this._cmBasicAction(stateManager, 'cm_nogroups', cmIds);
    }

    /**
     * Set cms group mode to VISIBLEGROUPS.
     * @param {StateManager} stateManager the current state manager
     * @param {array} cmIds the list of cm ids
     */
    async cmVisibleGroups(stateManager, cmIds) {
        await this._cmBasicAction(stateManager, 'cm_visiblegroups', cmIds);
    }

    /**
     * Set cms group mode to SEPARATEGROUPS.
     * @param {StateManager} stateManager the current state manager
     * @param {array} cmIds the list of cm ids
     */
    async cmSeparateGroups(stateManager, cmIds) {
        await this._cmBasicAction(stateManager, 'cm_separategroups', cmIds);
    }

    /**
     * Lock or unlock course modules.
     *
     * @param {StateManager} stateManager the current state manager
     * @param {array} cmIds the list of course modules ids
     * @param {bool} lockValue the new locked value
     */
    cmLock(stateManager, cmIds, lockValue) {
        this._setElementsValue(stateManager, 'cm', cmIds, 'locked', lockValue);
    }

    /**
     * Lock or unlock course sections.
     *
     * @param {StateManager} stateManager the current state manager
     * @param {array} sectionIds the list of section ids
     * @param {bool} lockValue the new locked value
     */
    sectionLock(stateManager, sectionIds, lockValue) {
        this._setElementsValue(stateManager, 'section', sectionIds, 'locked', lockValue);
    }

    _setElementsValue(stateManager, name, ids, fieldName, newValue) {
        stateManager.setReadOnly(false);
        ids.forEach((id) => {
            const element = stateManager.get(name, id);
            if (element) {
                element[fieldName] = newValue;
            }
        });
        stateManager.setReadOnly(true);
    }

    /**
     * Set the page current item.
     *
     * Only one element of the course state can be the page item at a time.
     *
     * There are several actions that can alter the page current item. For example, when the user is in an activity
     * page, the page item is always the activity one. However, in a course page, when the user scrolls to an element,
     * this element get the page item.
     *
     * If the page item is static means that it is not meant to change. This is important because
     * static page items has some special logic. For example, if a cm is the static page item
     * and it is inside a collapsed section, the course index will expand the section to make it visible.
     *
     * @param {StateManager} stateManager the current state manager
     * @param {String|undefined} type the element type (section or cm). Undefined will remove the current page item.
     * @param {Number|undefined} id the element id
     * @param {boolean|undefined} isStatic if the page item is static
     */
    setPageItem(stateManager, type, id, isStatic) {
        let newPageItem;
        if (type !== undefined) {
            newPageItem = stateManager.get(type, id);
            if (!newPageItem) {
                return;
            }
        }
        const course = stateManager.get('course');
        if (course.pageItem && course.pageItem.type === type && course.pageItem.id === id) {
            return;
        }
        stateManager.setReadOnly(false);
        // Remove the current page item.
        course.pageItem = null;
        // Save the new page item.
        if (newPageItem) {
            course.pageItem = {
                id,
                type,
                sectionId: (type == 'section') ? newPageItem.id : newPageItem.sectionid,
                isStatic,
            };
        }
        stateManager.setReadOnly(true);
    }

    /**
     * Unlock all course elements.
     *
     * @param {StateManager} stateManager the current state manager
     */
    unlockAll(stateManager) {
        const state = stateManager.state;
        stateManager.setReadOnly(false);
        state.section.forEach((section) => {
            section.locked = false;
        });
        state.cm.forEach((cm) => {
            cm.locked = false;
        });
        stateManager.setReadOnly(true);
    }

    /**
     * Update the course index collapsed attribute of some sections.
     *
     * @param {StateManager} stateManager the current state manager
     * @param {array} sectionIds the affected section ids
     * @param {boolean} collapsed the new collapsed value
     */
    async sectionIndexCollapsed(stateManager, sectionIds, collapsed) {
        const affectedSections = this._updateStateSectionPreference(stateManager, 'indexcollapsed', sectionIds, collapsed);
        if (!affectedSections) {
            return;
        }
        const course = stateManager.get('course');
        let actionName = 'section_index_collapsed';
        if (!collapsed) {
            actionName = 'section_index_expanded';
        }
        await this._callEditWebservice(actionName, course.id, affectedSections);
    }

    /**
     * Update the course index collapsed attribute of all sections.
     *
     * @param {StateManager} stateManager the current state manager
     * @param {boolean} collapsed the new collapsed value
     */
    async allSectionsIndexCollapsed(stateManager, collapsed) {
        const sectionIds = stateManager.getIds('section');
        this.sectionIndexCollapsed(stateManager, sectionIds, collapsed);
    }

    /**
     * Update the course content collapsed attribute of some sections.
     *
     * @param {StateManager} stateManager the current state manager
     * @param {array} sectionIds the affected section ids
     * @param {boolean} collapsed the new collapsed value
     */
    async sectionContentCollapsed(stateManager, sectionIds, collapsed) {
        const affectedSections = this._updateStateSectionPreference(stateManager, 'contentcollapsed', sectionIds, collapsed);
        if (!affectedSections) {
            return;
        }
        const course = stateManager.get('course');
        let actionName = 'section_content_collapsed';
        if (!collapsed) {
            actionName = 'section_content_expanded';
        }
        await this._callEditWebservice(actionName, course.id, affectedSections);
    }

    /**
     * Private batch update for a section preference attribute.
     *
     * @param {StateManager} stateManager the current state manager
     * @param {string} preferenceName the preference name
     * @param {array} sectionIds the affected section ids
     * @param {boolean} preferenceValue the new preferenceValue value
     * @return {Number[]|null} sections ids with the preference value true or null if no update is required
     */
    _updateStateSectionPreference(stateManager, preferenceName, sectionIds, preferenceValue) {
        stateManager.setReadOnly(false);
        const affectedSections = [];
        // Check if we need to update preferences.
        sectionIds.forEach(sectionId => {
            const section = stateManager.get('section', sectionId);
            if (section === undefined) {
                stateManager.setReadOnly(true);
                return null;
            }
            const newValue = preferenceValue ?? section[preferenceName];
            if (section[preferenceName] != newValue) {
                section[preferenceName] = newValue;
                affectedSections.push(section.id);
            }
        });
        stateManager.setReadOnly(true);
        return affectedSections;
    }

    /**
     * Enable/disable bulk editing.
     *
     * Note: reenabling the bulk will clean the current selection.
     *
     * @param {StateManager} stateManager the current state manager
     * @param {Boolean} enabled the new bulk state.
     */
    bulkEnable(stateManager, enabled) {
        const state = stateManager.state;
        stateManager.setReadOnly(false);
        state.bulk.enabled = enabled;
        state.bulk.selectedType = '';
        state.bulk.selection = [];
        stateManager.setReadOnly(true);
    }

    /**
     * Reset the current selection.
     * @param {StateManager} stateManager the current state manager
     */
    bulkReset(stateManager) {
        const state = stateManager.state;
        stateManager.setReadOnly(false);
        state.bulk.selectedType = '';
        state.bulk.selection = [];
        stateManager.setReadOnly(true);
    }

    /**
     * Select a list of cms.
     * @param {StateManager} stateManager the current state manager
     * @param {array} cmIds the list of cm ids
     */
    cmSelect(stateManager, cmIds) {
        this._addIdsToSelection(stateManager, 'cm', cmIds);
    }

    /**
     * Unselect a list of cms.
     * @param {StateManager} stateManager the current state manager
     * @param {array} cmIds the list of cm ids
     */
    cmUnselect(stateManager, cmIds) {
        this._removeIdsFromSelection(stateManager, 'cm', cmIds);
    }

    /**
     * Select a list of sections.
     * @param {StateManager} stateManager the current state manager
     * @param {array} sectionIds the list of cm ids
     */
    sectionSelect(stateManager, sectionIds) {
        this._addIdsToSelection(stateManager, 'section', sectionIds);
    }

    /**
     * Unselect a list of sections.
     * @param {StateManager} stateManager the current state manager
     * @param {array} sectionIds the list of cm ids
     */
    sectionUnselect(stateManager, sectionIds) {
        this._removeIdsFromSelection(stateManager, 'section', sectionIds);
    }

    /**
     * Add some ids to the current bulk selection.
     * @param {StateManager} stateManager the current state manager
     * @param {String} typeName the type name (section/cm)
     * @param {array} ids the list of ids
     */
    _addIdsToSelection(stateManager, typeName, ids) {
        const bulk = stateManager.state.bulk;
        if (!bulk?.enabled) {
            throw new Error(`Bulk is not enabled`);
        }
        if (bulk?.selectedType !== "" && bulk?.selectedType !== typeName) {
            throw new Error(`Cannot add ${typeName} to the current selection`);
        }

        // Stored ids are strings for compatability with HTML data attributes.
        ids = ids.map(value => value.toString());

        stateManager.setReadOnly(false);
        bulk.selectedType = typeName;
        const newSelection = new Set([...bulk.selection, ...ids]);
        bulk.selection = [...newSelection];
        stateManager.setReadOnly(true);
    }

    /**
     * Remove some ids to the current bulk selection.
     *
     * The method resets the selection type if the current selection is empty.
     *
     * @param {StateManager} stateManager the current state manager
     * @param {String} typeName the type name (section/cm)
     * @param {array} ids the list of ids
     */
    _removeIdsFromSelection(stateManager, typeName, ids) {
        const bulk = stateManager.state.bulk;
        if (!bulk?.enabled) {
            throw new Error(`Bulk is not enabled`);
        }
        if (bulk?.selectedType !== "" && bulk?.selectedType !== typeName) {
            throw new Error(`Cannot remove ${typeName} from the current selection`);
        }

        // Stored ids are strings for compatability with HTML data attributes.
        ids = ids.map(value => value.toString());

        stateManager.setReadOnly(false);
        const IdsToFilter = new Set(ids);
        bulk.selection = bulk.selection.filter(current => !IdsToFilter.has(current));
        if (bulk.selection.length === 0) {
            bulk.selectedType = '';
        }
        stateManager.setReadOnly(true);
    }

    /**
     * Get updated state data related to some cm ids.
     *
     * @method cmState
     * @param {StateManager} stateManager the current state
     * @param {array} cmids the list of cm ids to update
     */
    async cmState(stateManager, cmids) {
        this.cmLock(stateManager, cmids, true);
        const course = stateManager.get('course');
        const updates = await this._callEditWebservice('cm_state', course.id, cmids);
        stateManager.processUpdates(updates);
        this.cmLock(stateManager, cmids, false);
    }

    /**
     * Get updated state data related to some section ids.
     *
     * @method sectionState
     * @param {StateManager} stateManager the current state
     * @param {array} sectionIds the list of section ids to update
     */
    async sectionState(stateManager, sectionIds) {
        this.sectionLock(stateManager, sectionIds, true);
        const course = stateManager.get('course');
        const updates = await this._callEditWebservice('section_state', course.id, sectionIds);
        stateManager.processUpdates(updates);
        this.sectionLock(stateManager, sectionIds, false);
    }

    /**
     * Get the full updated state data of the course.
     *
     * @param {StateManager} stateManager the current state
     */
    async courseState(stateManager) {
        const course = stateManager.get('course');
        const updates = await this._callEditWebservice('course_state', course.id);
        stateManager.processUpdates(updates);
    }

}
