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

/**
 * @package moodlecore
 * @subpackage backup-helper
 * @copyright 2010 onwards Eloy Lafuente (stronk7) {@link http://stronk7.com}
 * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */

require_once($CFG->dirroot.'/backup/util/xml/parser/processors/grouped_parser_processor.class.php');

/**
 * helper implementation of grouped_parser_processor that will
 * load all the categories and questions (header info only) from the questions.xml file
 * to the backup_ids table storing the whole structure there for later processing.
 * Note: only "needed" categories are loaded (must have question_categoryref record in backup_ids)
 * Note: parentitemid will contain the category->contextid for categories
 * Note: parentitemid will contain the category->id for questions
 *
 * TODO: Complete phpdocs
 */
class restore_questions_parser_processor extends grouped_parser_processor {
    /** @var string XML path in the questions.xml backup file to question categories. */
    protected const CATEGORY_PATH = '/question_categories/question_category';

    /** @var string XML path in the questions.xml to question elements within question_category (Moodle 4.0+). */
    protected const QUESTION_SUBPATH =
        '/question_bank_entries/question_bank_entry/question_version/question_versions/questions/question';

    /** @var string XML path in the questions.xml to question elements within question_category (before Moodle 4.0). */
    protected const LEGACY_QUESTION_SUBPATH = '/questions/question';

    /** @var string String for concatenating data into a string for hashing.*/
    protected const HASHDATA_SEPARATOR = '|HASHDATA|';

    /** @var string identifies the current restore. */
    protected string $restoreid;

    /** @var int during the restore, this tracks the last category we saw. Any questions we see will be in here. */
    protected int $lastcatid;

    public function __construct($restoreid) {
        global $CFG;
        $this->restoreid = $restoreid;
        $this->lastcatid = 0;
        parent::__construct();
        // Set the paths we are interested on
        $this->add_path(self::CATEGORY_PATH);
        $this->add_path(self::CATEGORY_PATH . self::QUESTION_SUBPATH, true);
        $this->add_path(self::CATEGORY_PATH . self::LEGACY_QUESTION_SUBPATH, true);

        // Add all sub-elements, including those from plugins, as grouped paths with the question tag so that
        // we can create a hash of all question data for comparison with questions in the database.
        $this->add_path(self::CATEGORY_PATH . self::QUESTION_SUBPATH . '/question_hints');
        $this->add_path(self::CATEGORY_PATH . self::LEGACY_QUESTION_SUBPATH . '/question_hints');
        $this->add_path(self::CATEGORY_PATH . self::QUESTION_SUBPATH . '/question_hints/question_hint');
        $this->add_path(self::CATEGORY_PATH . self::LEGACY_QUESTION_SUBPATH . '/question_hints/question_hint');

        $connectionpoint = new restore_path_element('question', self::CATEGORY_PATH . self::QUESTION_SUBPATH);
        foreach (\core\plugin_manager::instance()->get_plugins_of_type('qtype') as $qtype) {
            $restore = $this->get_qtype_restore($qtype->name);
            if (!$restore) {
                continue;
            }
            $structure = $restore->define_plugin_structure($connectionpoint);
            foreach ($structure as $element) {
                $subpath = str_replace(self::CATEGORY_PATH . self::QUESTION_SUBPATH . '/', '', $element->get_path());
                $pathparts = explode('/', $subpath);
                $path = self::CATEGORY_PATH . self::QUESTION_SUBPATH;
                $legacypath = self::CATEGORY_PATH . self::LEGACY_QUESTION_SUBPATH;
                foreach ($pathparts as $part) {
                    $path .= '/' . $part;
                    $legacypath .= '/' . $part;
                    if (!in_array($path, $this->paths)) {
                        $this->add_path($path);
                        $this->add_path($legacypath);
                    }
                }
            }
        }
    }

    protected function dispatch_chunk($data) {
        // Prepare question_category record
        if ($data['path'] == self::CATEGORY_PATH) {
            $info     = (object)$data['tags'];
            $itemname = 'question_category';
            $itemid   = $info->id;
            $parentitemid = $info->contextid;
            $this->lastcatid = $itemid;

        // Prepare question record
        } else if ($data['path'] == self::CATEGORY_PATH . self::QUESTION_SUBPATH ||
                $data['path'] == self::CATEGORY_PATH . self::LEGACY_QUESTION_SUBPATH) {
            // Remove sub-elements from the question info we're going to save.
            $info = (object) array_filter($data['tags'], fn($tag) => !is_array($tag));
            $itemname = 'question';
            $itemid   = $info->id;
            $parentitemid = $this->lastcatid;
            $restore = $this->get_qtype_restore($data['tags']['qtype']);
            if ($restore) {
                $questiondata = $restore->convert_backup_to_questiondata($data['tags']);
            } else {
                $questiondata = restore_qtype_plugin::convert_backup_to_questiondata($data['tags']);
            }
            // Store a hash of question fields for comparison with existing questions.
            $info->questionhash = $this->generate_question_identity_hash($questiondata);

        // Not question_category nor question, impossible. Throw exception.
        } else {
            throw new progressive_parser_exception('restore_questions_parser_processor_unexpected_path', $data['path']);
        }

        // Only load it if needed (exist same question_categoryref itemid in table)
        if (restore_dbops::get_backup_ids_record($this->restoreid, 'question_categoryref', $this->lastcatid)) {
            restore_dbops::set_backup_ids_record($this->restoreid, $itemname, $itemid, 0, $parentitemid, $info);
        }
    }

    protected function notify_path_start($path) {
        // nothing to do
    }

    protected function notify_path_end($path) {
        // nothing to do
    }

    /**
     * Provide NULL decoding
     */
    public function process_cdata($cdata) {
        if ($cdata === '$@NULL@$') {
            return null;
        }
        return $cdata;
    }

    /**
     * Load and instantiate the restore class for the given question type.
     *
     * If there is no restore class, null is returned.
     *
     * @param string $qtype The question type name (no qtype_ prefix)
     * @return ?restore_qtype_plugin
     */
    protected static function get_qtype_restore(string $qtype): ?restore_qtype_plugin {
        global $CFG;
        $step = new restore_quiz_activity_structure_step('questions', 'question.xml');
        $filepath = "{$CFG->dirroot}/question/type/{$qtype}/backup/moodle2/restore_qtype_{$qtype}_plugin.class.php";
        if (!file_exists($filepath)) {
            return null;
        }
        require_once($filepath);
        $restoreclass = "restore_qtype_{$qtype}_plugin";
        if (!class_exists($restoreclass)) {
            return null;
        }
        return new $restoreclass('qtype', $qtype, $step);
    }

    /**
     * Given a data structure containing the data for a question, reduce it to a flat array and return a sha1 hash of the data.
     *
     * @param stdClass $questiondata An array containing all the data for a question, including hints and qtype plugin data.
     * @param ?backup_xml_transformer $transformer If provided, run the backup transformer process on all text fields. This ensures
     *     that values from the database are compared like-for-like with encoded values from the backup.
     * @return string A sha1 hash of all question data, normalised and concatenated together.
     */
    public static function generate_question_identity_hash(
        stdClass $questiondata,
        ?backup_xml_transformer $transformer = null,
    ): string {
        $questiondata = clone($questiondata);
        $restore = self::get_qtype_restore($questiondata->qtype);
        if ($restore) {
            $restore->define_plugin_structure(new restore_path_element('question', self::CATEGORY_PATH . self::QUESTION_SUBPATH));
            // Combine default exclusions with those specified by the plugin.
            $questiondata = $restore->remove_excluded_question_data($questiondata, $restore->get_excluded_identity_hash_fields());
        } else {
            // The qtype has no restore class, use the default reduction method.
            $questiondata = restore_qtype_plugin::remove_excluded_question_data($questiondata);
        }

        // Convert questiondata to a flat array of values.
        $hashdata = [];
        // Convert the object to a multi-dimensional array for compatibility with array_walk_recursive.
        $questiondata = json_decode(json_encode($questiondata), true);
        array_walk_recursive($questiondata, function($value) use (&$hashdata) {
            // Normalise data types. Depending on where the data comes from, it may be a mixture of nulls, strings,
            // ints and floats. Convert everything to strings, then all numbers to floats to ensure we are doing
            // like-for-like comparisons without losing accuracy.
            $value = (string) $value;
            if (is_numeric($value)) {
                $value = (float) ($value);
            } else if (str_contains($value, "\r\n")) {
                // Normalise line breaks.
                $value = str_replace("\r\n", "\n", $value);
            }
            $hashdata[] = $value;
        });

        sort($hashdata, SORT_STRING);
        $hashstring = implode(self::HASHDATA_SEPARATOR, $hashdata);
        if ($transformer) {
            $hashstring = $transformer->process($hashstring);
            // Need to re-sort the hashdata with the transformed strings.
            $hashdata = explode(self::HASHDATA_SEPARATOR, $hashstring);
            sort($hashdata, SORT_STRING);
            $hashstring = implode(self::HASHDATA_SEPARATOR, $hashdata);
        }
        return sha1($hashstring);
    }
}