<?php
// 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/>.

/**
 * mod_lesson data generator.
 *
 * @package    mod_lesson
 * @category   test
 * @copyright  2013 Marina Glancy
 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */

defined('MOODLE_INTERNAL') || die();


> require_once($CFG->dirroot.'/mod/lesson/locallib.php');
/**
> 


 * mod_lesson data generator class.
 *
 * @package    mod_lesson
 * @category   test
 * @copyright  2013 Marina Glancy
 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */
class mod_lesson_generator extends testing_module_generator {

    /**
     * @var int keep track of how many pages have been created.
     */
    protected $pagecount = 0;

    /**

>      * @var array list of candidate pages to be created when all answers have been added.
     * To be called from data reset code only,
>      */
     * do not use in tests.
>     protected $candidatepages = [];
     * @return void
> 
     */
>     /**
    public function reset() {
>      * @var array map of readable jumpto to integer value.
        $this->pagecount = 0;
>      */
        parent::reset();
>     protected $jumptomap = [
    }
>         'This page' => LESSON_THISPAGE,

>         'Next page' => LESSON_NEXTPAGE,
    public function create_instance($record = null, array $options = null) {
>         'Previous page' => LESSON_PREVIOUSPAGE,
        global $CFG;
>         'End of lesson' => LESSON_EOL,

>         'Unseen question within a content page' => LESSON_UNSEENBRANCHPAGE,
        // Add default values for lesson.
>         'Random question within a content page' => LESSON_RANDOMPAGE,
        $lessonconfig = get_config('mod_lesson');
>         'Random content page' => LESSON_RANDOMBRANCH,
        $record = (array)$record + array(
>         'Unseen question within a cluster' => LESSON_CLUSTERJUMP,
            'progressbar' => $lessonconfig->progressbar,
>     ];
            'ongoing' => $lessonconfig->ongoing,
> 
            'displayleft' => $lessonconfig->displayleftmenu,
>     /**


            'displayleftif' => $lessonconfig->displayleftif,

>         $this->candidatepages = [];


            'slideshow' => $lessonconfig->slideshow,

>     /**
            'maxanswers' => $lessonconfig->maxanswers,
>      * Creates a lesson instance for testing purposes.
            'feedback' => $lessonconfig->defaultfeedback,
>      *
            'activitylink' => 0,
>      * @param null|array|stdClass $record data for module being generated.
            'available' => 0,
>      * @param null|array $options general options for course module.
            'deadline' => 0,
>      * @return stdClass record from module-defined table with additional field cmid (corresponding id in course_modules table)
            'usepassword' => 0,
>      */


            'password' => '',
            'dependency' => 0,
            'timespent' => 0,
            'completed' => 0,
            'gradebetterthan' => 0,
            'modattempts' => $lessonconfig->modattempts,
            'review' => $lessonconfig->displayreview,
            'maxattempts' => $lessonconfig->maximumnumberofattempts,
            'nextpagedefault' => $lessonconfig->defaultnextpage,
            'maxpages' => $lessonconfig->numberofpagestoshow,
            'practice' => $lessonconfig->practice,
            'custom' => $lessonconfig->customscoring,
            'retake' => $lessonconfig->retakesallowed,
            'usemaxgrade' => $lessonconfig->handlingofretakes,
            'minquestions' => $lessonconfig->minimumnumberofquestions,
            'grade' => 100,
        );
        if (!isset($record['mediafile'])) {
            require_once($CFG->libdir.'/filelib.php');
            $record['mediafile'] = file_get_unused_draft_itemid();
        }

        return parent::create_instance($record, (array)$options);
    }


>     /**
    public function create_content($lesson, $record = array()) {
>      * Creates a page for testing purposes. The page will be created when answers are added.
        global $DB, $CFG;
>      *
        require_once($CFG->dirroot.'/mod/lesson/locallib.php');
>      * @param null|array|stdClass $record data for page being generated.
        $now = time();
>      * @param null|array $options general options.
        $this->pagecount++;
>      */
        $record = (array)$record + array(
>     public function create_page($record = null, array $options = null) {
            'lessonid' => $lesson->id,
>         $record = (array) $record;
            'title' => 'Lesson page '.$this->pagecount,
> 
            'timecreated' => $now,
>         // Pages require answers to work. Add it as a candidate page to be created once answers have been added.
            'qtype' => 20, // LESSON_PAGE_BRANCHTABLE
>         $record['answer_editor'] = [];
            'pageid' => 0, // By default insert in the beginning.
>         $record['response_editor'] = [];
        );
>         $record['jumpto'] = [];
        if (!isset($record['contents_editor'])) {
>         $record['score'] = [];
            $record['contents_editor'] = array(
> 
                'text' => 'Contents of lesson page '.$this->pagecount,
>         if (!isset($record['previouspage']) || $record['previouspage'] === '') {
                'format' => FORMAT_MOODLE,
>             // Previous page not set, set it to the last candidate page (if any).
                'itemid' => 0,
>             $record['previouspage'] = empty($this->candidatepages) ? '0' : end($this->candidatepages)['title'];
            );
>         }
        }
> 
        $context = context_module::instance($lesson->cmid);
>         $this->candidatepages[] = $record;
        $page = lesson_page::create((object)$record, new lesson($lesson), $context, $CFG->maxbytes);
>     }
        return $DB->get_record('lesson_pages', array('id' => $page->id), '*', MUST_EXIST);
> 
    }
>     /**

>      * Creates a page and its answers for testing purposes.
    /**
>      *
     * Create True/false question pages.
>      * @param array $record data for page being generated.
     * @param object $lesson
>      * @return stdClass created page, null if couldn't be created because it has a jump to a page that doesn't exist.
     * @param array $record
>      * @throws coding_exception
     * @return int
>      */
     */
>     private function perform_create_page(array $record): ?stdClass {
    public function create_question_truefalse($lesson, $record = array()) {
>         global $DB;
        global $DB, $CFG;
> 
        require_once($CFG->dirroot.'/mod/lesson/locallib.php');
>         $lesson = $DB->get_record('lesson', ['id' => $record['lessonid']], '*', MUST_EXIST);
        $now = time();
>         $cm = get_coursemodule_from_instance('lesson', $lesson->id);
        $this->pagecount++;
>         $lesson->cmid = $cm->id;
        $record = (array)$record + array(
>         $qtype = $record['qtype'];
            'lessonid' => $lesson->id,
> 
            'title' => 'Lesson TF question '.$this->pagecount,
>         unset($record['qtype']);
            'timecreated' => $now,
>         unset($record['lessonid']);
            'qtype' => 2,  // LESSON_PAGE_TRUEFALSE.
> 
            'pageid' => 0, // By default insert in the beginning.
>         if (isset($record['content'])) {
        );
>             $record['contents_editor'] = [
        if (!isset($record['contents_editor'])) {
>                 'text' => $record['content'],
            $record['contents_editor'] = array(
>                 'format' => FORMAT_MOODLE,
                'text' => 'The answer is TRUE '.$this->pagecount,
>                 'itemid' => 0,
                'format' => FORMAT_HTML,
>             ];
                'itemid' => 0
>             unset($record['content']);
            );
>         }
        }
> 

>         $record['pageid'] = $this->get_previouspage_id($lesson->id, $record['previouspage']);
        // First Answer (TRUE).
>         unset($record['previouspage']);
        if (!isset($record['answer_editor'][0])) {
> 
            $record['answer_editor'][0] = array(
>         try {
                'text' => 'TRUE answer for '.$this->pagecount,
>             $record['jumpto'] = $this->convert_page_jumpto($lesson->id, $record['jumpto']);
                'format' => FORMAT_HTML
>         } catch (coding_exception $e) {
            );
>             // This page has a jump to a page that hasn't been created yet.
        }
>             return null;
        if (!isset($record['jumpto'][0])) {
>         }
            $record['jumpto'][0] = LESSON_NEXTPAGE;
> 
        }
>         switch ($qtype) {

>             case 'content':
        // Second Answer (FALSE).
>             case 'cluster':
        if (!isset($record['answer_editor'][1])) {
>             case 'endofcluster':
            $record['answer_editor'][1] = array(
>             case 'endofbranch':
                'text' => 'FALSE answer for '.$this->pagecount,
>                 $funcname = "create_{$qtype}";
                'format' => FORMAT_HTML
>                 break;
            );
>             default:
        }
>                 $funcname = "create_question_{$qtype}";
        if (!isset($record['jumpto'][1])) {
>         }
            $record['jumpto'][1] = LESSON_THISPAGE;
> 
        }
>         if (!method_exists($this, $funcname)) {

>             throw new coding_exception('The page '.$record['title']." has an invalid qtype: $qtype");
        $context = context_module::instance($lesson->cmid);
>         }
        $page = lesson_page::create((object)$record, new lesson($lesson), $context, $CFG->maxbytes);
> 
        return $DB->get_record('lesson_pages', array('id' => $page->id), '*', MUST_EXIST);
>         return $this->{$funcname}($lesson, $record);
    }
>     }

> 
    /**
>     /**
     * Create multichoice question pages.
>      * Creates a content page for testing purposes.
     * @param object $lesson
>      *
     * @param array $record
>      * @param stdClass $lesson instance where to create the page.
     * @return int
>      * @param array|stdClass $record data for page being generated.
     */
>      * @return stdClass page record.
    public function create_question_multichoice($lesson, $record = array()) {
>      */



<         require_once($CFG->dirroot.'/mod/lesson/locallib.php');



<      * @return int



>      * @return stdClass page record.



<         require_once($CFG->dirroot.'/mod/lesson/locallib.php');



<      * @return int



>      * @return stdClass page record.



<         require_once($CFG->dirroot.'/mod/lesson/locallib.php');


            'lessonid' => $lesson->id,
            'title' => 'Lesson multichoice question '.$this->pagecount,
            'timecreated' => $now,
            'qtype' => 3,  // LESSON_PAGE_MULTICHOICE.
            'pageid' => 0, // By default insert in the beginning.
        );
        if (!isset($record['contents_editor'])) {
            $record['contents_editor'] = array(
                'text' => 'Pick the correct answer '.$this->pagecount,
                'format' => FORMAT_HTML,
                'itemid' => 0
            );
        }

        // First Answer (correct).
        if (!isset($record['answer_editor'][0])) {
            $record['answer_editor'][0] = array(
                'text' => 'correct answer for '.$this->pagecount,
                'format' => FORMAT_HTML
            );
        }
        if (!isset($record['jumpto'][0])) {
            $record['jumpto'][0] = LESSON_NEXTPAGE;
        }

        // Second Answer (incorrect).
        if (!isset($record['answer_editor'][1])) {
            $record['answer_editor'][1] = array(
                'text' => 'correct answer for '.$this->pagecount,
                'format' => FORMAT_HTML
            );
        }
        if (!isset($record['jumpto'][1])) {
            $record['jumpto'][1] = LESSON_THISPAGE;
        }

        $context = context_module::instance($lesson->cmid);
        $page = lesson_page::create((object)$record, new lesson($lesson), $context, $CFG->maxbytes);
        return $DB->get_record('lesson_pages', array('id' => $page->id), '*', MUST_EXIST);
    }

    /**
     * Create essay question pages.
     * @param object $lesson
     * @param array $record

<      * @return int



>      * @return stdClass page record.


     */
    public function create_question_essay($lesson, $record = array()) {
        global $DB, $CFG;

<         require_once($CFG->dirroot.'/mod/lesson/locallib.php');


        $now = time();
        $this->pagecount++;
        $record = (array)$record + array(
            'lessonid' => $lesson->id,
            'title' => 'Lesson Essay question '.$this->pagecount,
            'timecreated' => $now,
            'qtype' => 10, // LESSON_PAGE_ESSAY.
            'pageid' => 0, // By default insert in the beginning.
        );
        if (!isset($record['contents_editor'])) {
            $record['contents_editor'] = array(
                'text' => 'Write an Essay '.$this->pagecount,
                'format' => FORMAT_HTML,
                'itemid' => 0
            );
        }

        // Essays have an answer of NULL.
        if (!isset($record['answer_editor'][0])) {
            $record['answer_editor'][0] = array(
                'text' => null,
                'format' => FORMAT_MOODLE
            );
        }
        if (!isset($record['jumpto'][0])) {
            $record['jumpto'][0] = LESSON_NEXTPAGE;
        }

        $context = context_module::instance($lesson->cmid);
        $page = lesson_page::create((object)$record, new lesson($lesson), $context, $CFG->maxbytes);
        return $DB->get_record('lesson_pages', array('id' => $page->id), '*', MUST_EXIST);
    }

    /**
     * Create matching question pages.
     * @param object $lesson
     * @param array $record

<      * @return int



>      * @return stdClass page record.


     */
    public function create_question_matching($lesson, $record = array()) {
        global $DB, $CFG;

<         require_once($CFG->dirroot.'/mod/lesson/locallib.php');


        $now = time();
        $this->pagecount++;
        $record = (array)$record + array(
            'lessonid' => $lesson->id,
            'title' => 'Lesson Matching question '.$this->pagecount,
            'timecreated' => $now,
            'qtype' => 5,  // LESSON_PAGE_MATCHING.
            'pageid' => 0, // By default insert in the beginning.
        );
        if (!isset($record['contents_editor'])) {
            $record['contents_editor'] = array(
                'text' => 'Match the values '.$this->pagecount,
                'format' => FORMAT_HTML,
                'itemid' => 0
            );
        }
        // Feedback for correct result.
        if (!isset($record['answer_editor'][0])) {
            $record['answer_editor'][0] = array(
                'text' => '',
                'format' => FORMAT_HTML
            );
        }
        // Feedback for wrong result.
        if (!isset($record['answer_editor'][1])) {
            $record['answer_editor'][1] = array(
                'text' => '',
                'format' => FORMAT_HTML
            );
        }
        // First answer value.
        if (!isset($record['answer_editor'][2])) {
            $record['answer_editor'][2] = array(
                'text' => 'Match value 1',
                'format' => FORMAT_HTML
            );
        }
        // First response value.
        if (!isset($record['response_editor'][2])) {
            $record['response_editor'][2] = 'Match answer 1';
        }
        // Second Matching value.
        if (!isset($record['answer_editor'][3])) {
            $record['answer_editor'][3] = array(
                'text' => 'Match value 2',
                'format' => FORMAT_HTML
            );
        }
        // Second Matching answer.
        if (!isset($record['response_editor'][3])) {
            $record['response_editor'][3] = 'Match answer 2';
        }

        // Jump Values.
        if (!isset($record['jumpto'][0])) {
            $record['jumpto'][0] = LESSON_NEXTPAGE;
        }
        if (!isset($record['jumpto'][1])) {
            $record['jumpto'][1] = LESSON_THISPAGE;
        }

        // Mark the correct values.
        if (!isset($record['score'][0])) {
            $record['score'][0] = 1;
        }
        $context = context_module::instance($lesson->cmid);
        $page = lesson_page::create((object)$record, new lesson($lesson), $context, $CFG->maxbytes);
        return $DB->get_record('lesson_pages', array('id' => $page->id), '*', MUST_EXIST);
    }

    /**
     * Create shortanswer question pages.
     * @param object $lesson
     * @param array $record

<      * @return int



>      * @return stdClass page record.


     */
    public function create_question_shortanswer($lesson, $record = array()) {
        global $DB, $CFG;

<         require_once($CFG->dirroot.'/mod/lesson/locallib.php');


        $now = time();
        $this->pagecount++;
        $record = (array)$record + array(
            'lessonid' => $lesson->id,
            'title' => 'Lesson Shortanswer question '.$this->pagecount,
            'timecreated' => $now,
            'qtype' => 1,  // LESSON_PAGE_SHORTANSWER.
            'pageid' => 0, // By default insert in the beginning.
        );
        if (!isset($record['contents_editor'])) {
            $record['contents_editor'] = array(
                'text' => 'Fill in the blank '.$this->pagecount,
                'format' => FORMAT_HTML,
                'itemid' => 0
            );
        }

        // First Answer (correct).
        if (!isset($record['answer_editor'][0])) {
            $record['answer_editor'][0] = array(
                'text' => 'answer'.$this->pagecount,
                'format' => FORMAT_MOODLE
            );
        }
        if (!isset($record['jumpto'][0])) {
            $record['jumpto'][0] = LESSON_NEXTPAGE;
        }

        $context = context_module::instance($lesson->cmid);
        $page = lesson_page::create((object)$record, new lesson($lesson), $context, $CFG->maxbytes);
        return $DB->get_record('lesson_pages', array('id' => $page->id), '*', MUST_EXIST);
    }

    /**
     * Create shortanswer question pages.
     * @param object $lesson
     * @param array $record

<      * @return int



>      * @return stdClass page record.


     */
    public function create_question_numeric($lesson, $record = array()) {
        global $DB, $CFG;

<         require_once($CFG->dirroot.'/mod/lesson/locallib.php');


        $now = time();
        $this->pagecount++;
        $record = (array)$record + array(
            'lessonid' => $lesson->id,
            'title' => 'Lesson numerical question '.$this->pagecount,
            'timecreated' => $now,
            'qtype' => 8,  // LESSON_PAGE_NUMERICAL.
            'pageid' => 0, // By default insert in the beginning.
        );
        if (!isset($record['contents_editor'])) {
            $record['contents_editor'] = array(
                'text' => 'Numerical question '.$this->pagecount,
                'format' => FORMAT_HTML,
                'itemid' => 0
            );
        }

        // First Answer (correct).
        if (!isset($record['answer_editor'][0])) {
            $record['answer_editor'][0] = array(
                'text' => $this->pagecount,
                'format' => FORMAT_MOODLE
            );
        }
        if (!isset($record['jumpto'][0])) {
            $record['jumpto'][0] = LESSON_NEXTPAGE;
        }

        $context = context_module::instance($lesson->cmid);
        $page = lesson_page::create((object)$record, new lesson($lesson), $context, $CFG->maxbytes);
        return $DB->get_record('lesson_pages', array('id' => $page->id), '*', MUST_EXIST);
    }

    /**

>      * Creates a cluster page for testing purposes.
     * Create a lesson override (either user or group).
>      *
     *
>      * @param stdClass $lesson instance where to create the page.
     * @param array $data must specify lessonid, and one of userid or groupid.
>      * @param array $record data for page being generated.
     */
>      * @return stdClass page record.
    public function create_override(array $data): void {
>      */
        global $DB;
>     public function create_cluster(stdClass $lesson, array $record = []): stdClass {

>         global $DB, $CFG;
        if (!isset($data['lessonid'])) {
>         $now = time();
            throw new coding_exception('Must specify lessonid when creating a lesson override.');
>         $this->pagecount++;
        }
>         $record = $record + [

>             'lessonid' => $lesson->id,
        if (!isset($data['userid']) && !isset($data['groupid'])) {
>             'title' => 'Cluster '.$this->pagecount,
            throw new coding_exception('Must specify one of userid or groupid when creating a lesson override.');
>             'timecreated' => $now,
        }
>             'qtype' => 30, // LESSON_PAGE_CLUSTER.

>             'pageid' => 0, // By default insert in the beginning.
        if (isset($data['userid']) && isset($data['groupid'])) {
>         ];
            throw new coding_exception('Cannot specify both userid and groupid when creating a lesson override.');
>         if (!isset($record['contents_editor'])) {
        }
>             $record['contents_editor'] = [

>                 'text' => 'Cluster '.$this->pagecount,
        $DB->insert_record('lesson_overrides', (object) $data);
>                 'format' => FORMAT_MOODLE,
    }
>                 'itemid' => 0,
}
>             ];
>         }
>         $context = context_module::instance($lesson->cmid);
>         $page = lesson_page::create((object)$record, new lesson($lesson), $context, $CFG->maxbytes);
>         return $DB->get_record('lesson_pages', ['id' => $page->id], '*', MUST_EXIST);
>     }
> 
>     /**
>      * Creates a end of cluster page for testing purposes.
>      *
>      * @param stdClass $lesson instance where to create the page.
>      * @param array $record data for page being generated.
>      * @return stdClass page record.
>      */
>     public function create_endofcluster(stdClass $lesson, array $record = []): stdClass {
>         global $DB, $CFG;
>         $now = time();
>         $this->pagecount++;
>         $record = $record + [
>             'lessonid' => $lesson->id,
>             'title' => 'End of cluster '.$this->pagecount,
>             'timecreated' => $now,
>             'qtype' => 31, // LESSON_PAGE_ENDOFCLUSTER.
>             'pageid' => 0, // By default insert in the beginning.
>         ];
>         if (!isset($record['contents_editor'])) {
>             $record['contents_editor'] = [
>                 'text' => 'End of cluster '.$this->pagecount,
>                 'format' => FORMAT_MOODLE,
>                 'itemid' => 0,
>             ];
>         }
>         $context = context_module::instance($lesson->cmid);
>         $page = lesson_page::create((object)$record, new lesson($lesson), $context, $CFG->maxbytes);
>         return $DB->get_record('lesson_pages', ['id' => $page->id], '*', MUST_EXIST);
>     }
> 
>     /**
>      * Creates a end of branch page for testing purposes.
>      *
>      * @param stdClass $lesson instance where to create the page.
>      * @param array $record data for page being generated.
>      * @return stdClass page record.
>      */
>     public function create_endofbranch(stdClass $lesson, array $record = []): stdClass {
>         global $DB, $CFG;
>         $now = time();
>         $this->pagecount++;
>         $record = $record + [
>             'lessonid' => $lesson->id,
>             'title' => 'End of branch '.$this->pagecount,
>             'timecreated' => $now,
>             'qtype' => 21, // LESSON_PAGE_ENDOFBRANCH.
>             'pageid' => 0, // By default insert in the beginning.
>         ];
>         if (!isset($record['contents_editor'])) {
>             $record['contents_editor'] = [
>                 'text' => 'End of branch '.$this->pagecount,
>                 'format' => FORMAT_MOODLE,
>                 'itemid' => 0,
>             ];
>         }
>         $context = context_module::instance($lesson->cmid);
>         $page = lesson_page::create((object)$record, new lesson($lesson), $context, $CFG->maxbytes);
>         return $DB->get_record('lesson_pages', ['id' => $page->id], '*', MUST_EXIST);
>     }
> 
>     /**



>      * @throws coding_exception



>     }
> 
>     /**
>      * Creates an answer in a page for testing purposes.
>      *
>      * @param null|array|stdClass $record data for module being generated.
>      * @param null|array $options general options.
>      * @throws coding_exception
>      */
>     public function create_answer($record = null, array $options = null) {
>         $record = (array) $record;
> 
>         $candidatepage = null;
>         $pagetitle = $record['page'];
>         $found = false;
>         foreach ($this->candidatepages as &$candidatepage) {
>             if ($candidatepage['title'] === $pagetitle) {
>                 $found = true;
>                 break;
>             }
>         }
> 
>         if (!$found) {
>             throw new coding_exception("Page '$pagetitle' not found in candidate pages. Please make sure the page exists "
>                 . 'and all answers are in the same table.');
>         }
> 
>         if (isset($record['answer'])) {
>             $candidatepage['answer_editor'][] = [
>                 'text' => $record['answer'],
>                 'format' => FORMAT_HTML,
>             ];
>         } else {
>             $candidatepage['answer_editor'][] = null;
>         }
> 
>         if (isset($record['response'])) {
>             $candidatepage['response_editor'][] = [
>                 'text' => $record['response'],
>                 'format' => FORMAT_HTML,
>             ];
>         } else {
>             $candidatepage['response_editor'][] = null;
>         }
> 
>         $candidatepage['jumpto'][] = $record['jumpto'] ?? LESSON_THISPAGE;
>         $candidatepage['score'][] = $record['score'] ?? 0;
>     }
> 
>     /**
>      * All answers in a table have been generated, create the pages.
>      */
>     public function finish_generate_answer() {
>         $this->create_candidate_pages();
>     }
> 
>     /**
>      * Create candidate pages.
>      *
>      * @throws coding_exception
>      */
>     protected function create_candidate_pages(): void {
>         // For performance reasons it would be better to use a topological sort algorithm. But since test cases shouldn't have
>         // a lot of paged and complex jumps it was implemented using a simpler approach.
>         $consecutiveblocked = 0;
> 
>         while (count($this->candidatepages) > 0) {
>             $page = array_shift($this->candidatepages);
>             $id = $this->perform_create_page($page);
> 
>             if ($id === null) {
>                 // Page cannot be created yet because of jumpto. Move it to the end of list.
>                 $consecutiveblocked++;
>                 $this->candidatepages[] = $page;
> 
>                 if ($consecutiveblocked === count($this->candidatepages)) {
>                     throw new coding_exception('There is a circular dependency in pages jumps.');
>                 }
>             } else {
>                 $consecutiveblocked = 0;
>             }
>         }
>     }
> 
>     /**
>      * Calculate the previous page id.
>      * If no page title is supplied, use the last page created in the lesson (0 if no pages).
>      * If page title is supplied, search it in DB and the list of candidate pages.
>      *
>      * @param int $lessonid the lesson id.
>      * @param string $pagetitle the page title, for example 'Test page'. '0' if no previous page.
>      * @return int corresponding id. 0 if no previous page.
>      * @throws coding_exception
>      */
>     protected function get_previouspage_id(int $lessonid, string $pagetitle): int {
>         global $DB;
> 
>         if (is_numeric($pagetitle) && intval($pagetitle) === 0) {
>             return 0;
>         }
> 
>         $pages = $DB->get_records('lesson_pages', ['lessonid' => $lessonid, 'title' => $pagetitle], 'id ASC', 'id, title');
> 
>         if (count($pages) > 1) {
>             throw new coding_exception("More than one page with '$pagetitle' found");
>         } else if (!empty($pages)) {
>             return current($pages)->id;
>         }
> 
>         // Page doesn't exist, search if it's a candidate page. If it is, use its previous page instead.
>         foreach ($this->candidatepages as $candidatepage) {
>             if ($candidatepage['title'] === $pagetitle) {
>                 return $this->get_previouspage_id($lessonid, $candidatepage['previouspage']);
>             }
>         }
> 
>         throw new coding_exception("Page '$pagetitle' not found");
>     }
> 
>     /**
>      * Convert the jumpto using a string to an integer value.
>      * The jumpto can contain a page name or one of our predefined values.
>      *
>      * @param int $lessonid the lesson id.
>      * @param array|null $jumptolist list of jumpto to treat.
>      * @return array|null list of jumpto already treated.
>      * @throws coding_exception
>      */
>     protected function convert_page_jumpto(int $lessonid, ?array $jumptolist): ?array {
>         global $DB;
> 
>         if (empty($jumptolist)) {
>             return $jumptolist;
>         }
> 
>         foreach ($jumptolist as $i => $jumpto) {
>             if (empty($jumpto) || is_numeric($jumpto)) {
>                 continue;
>             }
> 
>             if (isset($this->jumptomap[$jumpto])) {
>                 $jumptolist[$i] = $this->jumptomap[$jumpto];
> 
>                 continue;
>             }
> 
>             $page = $DB->get_record('lesson_pages', ['lessonid' => $lessonid, 'title' => $jumpto], 'id');
>             if ($page === false) {
>                 throw new coding_exception("Jump '$jumpto' not found in pages.");
>             }
> 
>             $jumptolist[$i] = $page->id;
>         }
> 
>         return $jumptolist;