class.assSingleChoiceGUI.php

Go to the documentation of this file.

<?php

class assSingleChoiceGUI extends assQuestionGUI implements ilGuiQuestionScoringAdjustable, ilGuiAnswerScoringAdjustable
{
    private bool $rebuild_thumbnails = false;
    public function __construct(int $id = -1)
    {
        parent::__construct();
        $this->object = new assSingleChoice();
        if ($id >= 0) {
            $this->object->loadFromDb($id);
        }
    }

    public function hasInlineFeedback(): bool
    {
        return $this->object->feedbackOBJ->isSpecificAnswerFeedbackAvailable($this->object->getId());
    }

    protected function writePostData(bool $always = false): int
    {
        if ($always || !$this->editQuestion(true)) {
            $this->writeQuestionGenericPostData();
            $this->writeQuestionSpecificPostData(new ilPropertyFormGUI());
            $this->writeAnswerSpecificPostData(new ilPropertyFormGUI());
            $this->saveTaxonomyAssignments();
            return 0;
        }
        return 1;
    }

    protected function getEditAnswersSingleLine(bool $checkonly = false): bool
    {
        if ($this->object->getSelfAssessmentEditingMode()) {
            return $this->object->isSingleline();
        }

        if ($checkonly) {
            return $this->request_data_collector->int('types') === 0;
        }

        if (empty($this->object->getLastChange())
            && !$this->request_data_collector->isset('types')) {
            // a new question is edited
            return $this->object->getMultilineAnswerSetting() === 0;
        }
        // a saved question is edited
        return $this->object->isSingleline();
    }

    public function editQuestion(
        bool $checkonly = false,
        ?bool $is_save_cmd = null
    ): bool {
        $save = $is_save_cmd ?? $this->isSaveCommand();

        $form = new ilPropertyFormGUI();
        $this->editForm = $form;

        $form->setFormAction($this->ctrl->getFormAction($this));
        $form->setTitle($this->outQuestionType());
        $is_singleline = $this->getEditAnswersSingleLine($checkonly);
        if ($is_singleline) {
            $form->setMultipart(true);
        } else {
            $form->setMultipart(false);
        }
        $form->setTableWidth('100%');
        $form->setId('asssinglechoice');

        $this->addBasicQuestionFormProperties($form);
        $this->populateQuestionSpecificFormPart($form, $is_singleline);
        $this->populateAnswerSpecificFormPart($form, $is_singleline);

        $this->populateTaxonomyFormSection($form);

        $this->addQuestionFormCommandButtons($form);

        $errors = false;

        if ($save) {
            foreach ($this->request_data_collector->getParsedBody() as $key => $value) {
                $item = $form->getItemByPostVar($key);
                if ($item === null) {
                    continue;
                }
                switch (get_class($item)) {
                    case 'ilDurationInputGUI':
                        $item->setHours($value['hh']);
                        $item->setMinutes($value['mm']);
                        $item->setSeconds($value['ss']);
                        break;
                    default:
                        $item->setValue($value);
                }
            }

            $errors = !$form->checkInput();
            if ($errors) {
                $checkonly = false;
            }
        }

        if (!$checkonly) {
            $this->renderEditForm($form);
        }
        return $errors;
    }

    public function uploadchoice(): void
    {
        $this->setAdditionalContentEditingModeFromPost();
        $this->writePostData(true);
        $this->editQuestion();
    }

    public function removeimagechoice(): void
    {
        $this->setAdditionalContentEditingModeFromPost();
        $this->writePostData(true);
        $position = key($this->request_data_collector->raw('cmd')['removeimagechoice']);
        $this->object->removeAnswerImage($position);
        $this->editQuestion();
    }

    public function addchoice(): void
    {
        $this->writePostData(true);
        $position = key($this->request_data_collector->raw('cmd')['addchoice']);
        $this->object->addAnswer('', 0, $position + 1);
        $this->editQuestion();
    }

    public function removechoice(): void
    {
        $this->writePostData(true);
        $position = key($this->request_data_collector->raw('cmd')['removechoice']);
        $this->object->deleteAnswer($position);
        $this->editQuestion();
    }

    public function getSolutionOutput(
        int $active_id,
        ?int $pass = null,
        bool $graphical_output = false,
        bool $result_output = false,
        bool $show_question_only = true,
        bool $show_feedback = false,
        bool $show_correct_solution = false,
        bool $show_manual_scoring = false,
        bool $show_question_text = true,
        bool $show_inline_feedback = true
    ): string {

        if (($active_id > 0) && (!$show_correct_solution)) {
            $user_solutions = $this->object->getSolutionValues($active_id, $pass);

        } else {
            $found_index = -1;
            $max_points = 0;
            foreach ($this->object->answers as $index => $answer) {
                if ($answer->getPoints() > $max_points) {
                    $max_points = $answer->getPoints();
                    $found_index = $index;
                }
            }
            $user_solutions = [['value1' => $found_index]];
        }

        return $this->renderSolutionOutput(
            $user_solutions,
            $active_id,
            $pass,
            $graphical_output,
            $result_output,
            $show_question_only,
            $show_feedback,
            $show_correct_solution,
            $show_manual_scoring,
            $show_question_text,
            false,
            $show_inline_feedback,
        );
    }

    public function renderSolutionOutput(
        mixed $user_solutions,
        int $active_id,
        ?int $pass,
        bool $graphical_output = false,
        bool $result_output = false,
        bool $show_question_only = true,
        bool $show_feedback = false,
        bool $show_correct_solution = false,
        bool $show_manual_scoring = false,
        bool $show_question_text = true,
        bool $show_autosave_title = false,
        bool $show_inline_feedback = false,
    ): ?string {
        $user_solution = '';
        foreach ($user_solutions as $idx => $solution_value) {
            $user_solution = $solution_value['value1'];
        }

        $template = new ilTemplate('tpl.il_as_qpl_mc_sr_output_solution.html', true, true, 'components/ILIAS/TestQuestionPool');
        $solutiontemplate = new ilTemplate('tpl.il_as_tst_solution_output.html', true, true, 'components/ILIAS/TestQuestionPool');

        $keys = $this->getChoiceKeys();
        foreach ($keys as $answer_id) {
            $answer = $this->object->answers[$answer_id];
            if ($active_id > 0 && !$show_correct_solution && $graphical_output) {
                $correctness = $this->generateCorrectness(
                    (string) $user_solution,
                    (string) $answer_id,
                    $answer->getPoints(),
                    $this->object->getMaximumPoints()
                );
                $template->setCurrentBlock('icon_ok');
                $template->setVariable('ICON_OK', $this->generateCorrectnessIconsForCorrectness($correctness));
                $template->parseCurrentBlock();
            }
            if ($answer->hasImage()) {
                $template->setCurrentBlock('answer_image');
                if ($this->object->getThumbSize()) {
                    $template->setVariable('ANSWER_IMAGE_URL', $this->object->getImagePathWeb() . $this->object->getThumbPrefix() . $answer->getImage());
                } else {
                    $template->setVariable('ANSWER_IMAGE_URL', $this->object->getImagePathWeb() . $answer->getImage());
                }
                $alt = $answer->getImage();
                if (strlen($answer->getAnswertext())) {
                    $alt = $answer->getAnswertext();
                }
                $alt = preg_replace('/<[^>]*?>/', '', $alt);
                $template->setVariable('ANSWER_IMAGE_ALT', ilLegacyFormElementsUtil::prepareFormOutput($alt));
                $template->setVariable('ANSWER_IMAGE_TITLE', ilLegacyFormElementsUtil::prepareFormOutput($alt));
                $template->parseCurrentBlock();
            }

            if (($show_feedback || !$this->isTestPresentationContext()) && $show_inline_feedback) {
                $this->populateInlineFeedback($template, $answer_id, $user_solution);
            }
            $template->setCurrentBlock('answer_row');
            $template->setVariable('ANSWER_TEXT', ilLegacyFormElementsUtil::prepareTextareaOutput($answer->getAnswertext(), true));

            if ($this->renderPurposeSupportsFormHtml() || $this->isRenderPurposePrintPdf()) {
                if ((string) $user_solution === (string) $answer_id) {
                    $template->setVariable('SOLUTION_IMAGE', ilUtil::getHtmlPath(ilUtil::getImagePath('object/radiobutton_checked.png')));
                    $template->setVariable('SOLUTION_ALT', $this->lng->txt('checked'));
                } else {
                    $template->setVariable('SOLUTION_IMAGE', ilUtil::getHtmlPath(ilUtil::getImagePath('object/radiobutton_unchecked.png')));
                    $template->setVariable('SOLUTION_ALT', $this->lng->txt('unchecked'));
                }
            } else {
                $template->setVariable('QID', $this->object->getId());
                $template->setVariable('SUFFIX', $show_correct_solution ? 'bestsolution' : 'usersolution');
                $template->setVariable('SOLUTION_VALUE', $answer_id);
                if ((string) $user_solution === (string) $answer_id) {
                    $template->setVariable('SOLUTION_CHECKED', 'checked');
                }
            }

            if ($result_output) {
                $points = $this->object->answers[$answer_id]->getPoints();
                $resulttext = ($points == 1) ? "(%s {$this->lng->txt('point')})" : "(%s {$this->lng->txt('points')})";
                $template->setVariable('RESULT_OUTPUT', sprintf($resulttext, $points));
            }
            $template->parseCurrentBlock();
        }

        $questiontext = $this->object->getQuestionForHTMLOutput();
        if ($show_inline_feedback && $this->hasInlineFeedback()) {
            $questiontext .= $this->buildFocusAnchorHtml();
        }
        if ($show_question_text === true) {
            $template->setVariable('QUESTIONTEXT', ilLegacyFormElementsUtil::prepareTextareaOutput($questiontext, true));
        }
        $questionoutput = $template->get();
        $feedback = ($show_feedback && !$this->isTestPresentationContext()) ? $this->getGenericFeedbackOutput((int) $active_id, $pass) : '';
        if ($feedback !== '') {
            $cssClass = (
                $this->hasCorrectSolution($active_id, $pass) ?
                ilAssQuestionFeedback::CSS_CLASS_FEEDBACK_CORRECT : ilAssQuestionFeedback::CSS_CLASS_FEEDBACK_WRONG
            );

            $solutiontemplate->setVariable('ILC_FB_CSS_CLASS', $cssClass);
            $solutiontemplate->setVariable('FEEDBACK', ilLegacyFormElementsUtil::prepareTextareaOutput($feedback, true));
        }
        $solutiontemplate->setVariable('SOLUTION_OUTPUT', $questionoutput);

        $solutionoutput = $solutiontemplate->get();

        if (!$show_question_only) {
            // get page object output
            $solutionoutput = $this->getILIASPage($solutionoutput);
        }
        return $solutionoutput;
    }

    private function generateCorrectness(
        string $user_solution,
        string $answer_id,
        float $answer_points,
        float $maximum_points
    ): int {
        if ($user_solution === $answer_id
                && $answer_points === $maximum_points
            || $user_solution !== $answer_id
                && $answer_points === 0.0
        ) {
            return self::CORRECTNESS_OK;
        }

        if ($user_solution === $answer_id
            && $answer_points > 0.0) {
            return self::CORRECTNESS_MOSTLY_OK;
        }

        return self::CORRECTNESS_NOT_OK;
    }

    public function getPreview(
        bool $show_question_only = false,
        bool $show_inline_feedback = false
    ): string {
        $keys = $this->getChoiceKeys();

        $template = new ilTemplate('tpl.il_as_qpl_mc_sr_output.html', true, true, 'components/ILIAS/TestQuestionPool');
        foreach ($keys as $answer_id) {
            $answer = $this->object->answers[$answer_id];
            if ($answer->hasImage()) {
                if ($this->object->getThumbSize()) {
                    $template->setCurrentBlock('preview');
                    $template->setVariable('URL_PREVIEW', $this->object->getImagePathWeb() . $answer->getImage());
                    $template->setVariable('TEXT_PREVIEW', $this->lng->txt('preview'));
                    $template->setVariable('IMG_PREVIEW', ilUtil::getImagePath('media/enlarge.svg'));
                    $template->setVariable('ANSWER_IMAGE_URL', $this->object->getImagePathWeb() . $this->object->getThumbPrefix() . $answer->getImage());
                    list($width, $height, $type, $attr) = getimagesize($this->object->getImagePath() . $answer->getImage());
                    $alt = $answer->getImage();
                    if (strlen($answer->getAnswertext())) {
                        $alt = $answer->getAnswertext();
                    }
                    $alt = preg_replace('/<[^>]*?>/', '', $alt);
                    $template->setVariable('ANSWER_IMAGE_ALT', ilLegacyFormElementsUtil::prepareFormOutput($alt));
                    $template->setVariable('ANSWER_IMAGE_TITLE', ilLegacyFormElementsUtil::prepareFormOutput($alt));
                    $template->parseCurrentBlock();
                } else {
                    $template->setCurrentBlock('answer_image');
                    $template->setVariable('ANSWER_IMAGE_URL', $this->object->getImagePathWeb() . $answer->getImage());
                    list($width, $height, $type, $attr) = getimagesize($this->object->getImagePath() . $answer->getImage());
                    $alt = $answer->getImage();
                    if (strlen($answer->getAnswertext())) {
                        $alt = $answer->getAnswertext();
                    }
                    $alt = preg_replace('/<[^>]*?>/', '', $alt);
                    $template->setVariable('ATTR', $attr);
                    $template->setVariable('ANSWER_IMAGE_ALT', ilLegacyFormElementsUtil::prepareFormOutput($alt));
                    $template->setVariable('ANSWER_IMAGE_TITLE', ilLegacyFormElementsUtil::prepareFormOutput($alt));
                    $template->parseCurrentBlock();
                }
            }
            if ($show_inline_feedback && is_object($this->getPreviewSession())) {
                $this->populateInlineFeedback($template, $answer_id, $this->getPreviewSession()->getParticipantsSolution());
            }
            $template->setCurrentBlock('answer_row');
            $template->setVariable('QID', $this->object->getId() . 'ID');
            $template->setVariable('ANSWER_ID', $answer_id);
            $template->setVariable('ANSWER_TEXT', ilLegacyFormElementsUtil::prepareTextareaOutput($answer->getAnswertext(), true));

            if (is_object($this->getPreviewSession())) {
                $user_solution = $this->getPreviewSession()->getParticipantsSolution();
                if ((string) $user_solution === (string) $answer_id) {
                    $template->setVariable('CHECKED_ANSWER', ' checked="checked"');
                }
            }

            $template->parseCurrentBlock();
        }
        $questiontext = $this->object->getQuestionForHTMLOutput();
        if ($show_inline_feedback && $this->hasInlineFeedback()) {
            $questiontext .= $this->buildFocusAnchorHtml();
        }
        $template->setVariable('QUESTIONTEXT', ilLegacyFormElementsUtil::prepareTextareaOutput($questiontext, true));
        $questionoutput = $template->get();
        if (!$show_question_only) {
            // get page object output
            $questionoutput = $this->getILIASPage($questionoutput);
        }
        return $questionoutput;
    }

    public function getTestOutput(
        int $active_id,
        int $pass,
        bool $is_question_postponed = false,
        array|bool $user_post_solutions = false,
        bool $show_specific_inline_feedback = false
    ): string {
        $keys = $this->getChoiceKeys();

        $user_solution = '';
        if ($active_id !== 0) {
            $solutions = $this->object->getTestOutputSolutions($active_id, $pass);
            foreach ($solutions as $solution_value) {
                $user_solution = $solution_value['value1'];
            }
        }

        $template = new ilTemplate('tpl.il_as_qpl_mc_sr_output.html', true, true, 'components/ILIAS/TestQuestionPool');
        foreach ($keys as $answer_id) {
            $answer = $this->object->answers[$answer_id];
            if ($answer->hasImage()) {
                if ($this->object->getThumbSize()) {
                    $template->setCurrentBlock('preview');
                    $template->setVariable('URL_PREVIEW', $this->object->getImagePathWeb() . $answer->getImage());
                    $template->setVariable('TEXT_PREVIEW', $this->lng->txt('preview'));
                    $template->setVariable('IMG_PREVIEW', ilUtil::getImagePath('media/enlarge.svg'));
                    $template->setVariable('ANSWER_IMAGE_URL', $this->object->getImagePathWeb() . $this->object->getThumbPrefix() . $answer->getImage());
                    list($width, $height, $type, $attr) = getimagesize($this->object->getImagePath() . $answer->getImage());
                    $alt = $answer->getImage();
                    if (strlen($answer->getAnswertext())) {
                        $alt = $answer->getAnswertext();
                    }
                    $alt = preg_replace('/<[^>]*?>/', '', $alt);
                    $template->setVariable('ANSWER_IMAGE_ALT', ilLegacyFormElementsUtil::prepareFormOutput($alt));
                    $template->setVariable('ANSWER_IMAGE_TITLE', ilLegacyFormElementsUtil::prepareFormOutput($alt));
                    $template->parseCurrentBlock();
                } else {
                    $template->setCurrentBlock('answer_image');
                    $template->setVariable('ANSWER_IMAGE_URL', $this->object->getImagePathWeb() . $answer->getImage());
                    list($width, $height, $type, $attr) = getimagesize($this->object->getImagePath() . $answer->getImage());
                    $alt = $answer->getImage();
                    if (strlen($answer->getAnswertext())) {
                        $alt = $answer->getAnswertext();
                    }
                    $alt = preg_replace('/<[^>]*?>/', '', $alt);
                    $template->setVariable('ATTR', $attr);
                    $template->setVariable('ANSWER_IMAGE_ALT', ilLegacyFormElementsUtil::prepareFormOutput($alt));
                    $template->setVariable('ANSWER_IMAGE_TITLE', ilLegacyFormElementsUtil::prepareFormOutput($alt));
                    $template->parseCurrentBlock();
                }
            }

            if ($show_specific_inline_feedback) {
                $this->populateInlineFeedback($template, $answer_id, $user_solution);
            }
            $template->setCurrentBlock('answer_row');
            $template->setVariable('ANSWER_ID', $answer_id);
            $template->setVariable('ANSWER_TEXT', ilLegacyFormElementsUtil::prepareTextareaOutput($answer->getAnswertext(), true));
            if ($user_solution === (string) $answer_id) {
                $template->setVariable('CHECKED_ANSWER', ' checked="checked"');
            }
            $template->parseCurrentBlock();
        }
        $template->setVariable('QUESTIONTEXT', $this->object->getQuestionForHTMLOutput());
        $questionoutput = $template->get();
        $pageoutput = $this->outQuestionPage('', $is_question_postponed, $active_id, $questionoutput, $show_specific_inline_feedback);
        return $pageoutput;
    }

    /*
     * Create the key index numbers for the array of choices
     *
     * @return array
     */
    public function getChoiceKeys()
    {
        $choice_keys = array_keys($this->object->answers);

        if ($this->object->getShuffle()) {
            $choice_keys = $this->object->getShuffler()->transform($choice_keys);
        }

        return $choice_keys;
    }

    public function getSpecificFeedbackOutput(array $user_solution): string
    {
        // No return value, this question type supports inline specific feedback.
        $output = '';
        return ilLegacyFormElementsUtil::prepareTextareaOutput($output, true);
    }

    public function writeQuestionSpecificPostData(ilPropertyFormGUI $form): void
    {
        $is_multi_line = $this->request_data_collector->string('types');
        if ($is_multi_line === '') {
            $is_multi_line = '0';
        }
        $this->object->setMultilineAnswerSetting($is_multi_line);
        $this->object->setShuffle($this->request_data_collector->bool('shuffle') ?? false);

        $choice = $this->request_data_collector->raw('choice');
        if (isset($choice['imagename']) && is_array($choice['imagename']) && $is_multi_line === '1') {
            $this->object->setIsSingleline(true);
            $this->tpl->setOnScreenMessage('info', $this->lng->txt('info_answer_type_change'), true);
        } else {
            $this->object->setIsSingleline($is_multi_line === '0');
        }

        $object_thumb_size = $this->object->getThumbSize();
        $thumb_size = $this->request_data_collector->int('thumb_size') ?? $object_thumb_size;
        if ($thumb_size !== $object_thumb_size) {
            $this->object->setThumbSize($thumb_size);
            $this->rebuild_thumbnails = true;
        }
    }

    public function populateQuestionSpecificFormPart(\ilPropertyFormGUI $form, bool $is_singleline = false): ilPropertyFormGUI
    {
        // shuffle
        $shuffle = new ilCheckboxInputGUI($this->lng->txt('shuffle_answers'), 'shuffle');
        $shuffle->setValue(1);
        $shuffle->setChecked($this->object->getShuffle());
        $shuffle->setRequired(false);
        $form->addItem($shuffle);

        if (!$this->object->getSelfAssessmentEditingMode()) {
            // Answer types
            $types = new ilSelectInputGUI($this->lng->txt('answer_types'), 'types');
            $types->setRequired(false);
            $types->setOptions(
                [
                                    0 => $this->lng->txt('answers_singleline'),
                                    1 => $this->lng->txt('answers_multiline'),
                                ]
            );
            $types->setValue($is_singleline ? 0 : 1);
            $form->addItem($types);
        }

        if ($is_singleline) {
            // thumb size
            $thumb_size = new ilNumberInputGUI($this->lng->txt('thumb_size'), 'thumb_size');
            $thumb_size->setSuffix($this->lng->txt('thumb_size_unit_pixel'));
            $thumb_size->setMinValue($this->object->getMinimumThumbSize());
            $thumb_size->setMaxValue($this->object->getMaximumThumbSize());
            $thumb_size->setDecimals(0);
            $thumb_size->setSize(6);
            $thumb_size->setInfo($this->lng->txt('thumb_size_info'));
            $thumb_size->setValue($this->object->getThumbSize());
            $thumb_size->setRequired(true);
        } else {
            $thumb_size = new ilHiddenInputGUI('thumb_size');
            $thumb_size->setValue($this->object->getThumbSize());
        }
        $form->addItem($thumb_size);

        return $form;
    }

    public function getAfterParticipationSuppressionQuestionPostVars(): array
    {
        return [];
    }

    public function writeAnswerSpecificPostData(ilPropertyFormGUI $form): void
    {
        // Delete all existing answers and create new answers from the form data
        $this->object->flushAnswers();
        $choice = $this->cleanupAnswerText(
            $this->request_data_collector->raw('choice') ?? [],
            $this->object->isSingleline() === false
        );

        if ($choice === []) {
            return;
        }

        if (!$this->object->isSingleline()) {
            foreach ($choice['answer'] as $index => $answer) {
                $answertext = $answer;
                $this->object->addAnswer(
                    $answertext,
                    $this->refinery->kindlyTo()->float()->transform($choice['points'][$index]),
                    $index,
                    null,
                    $choice['answer_id'][$index]
                );
            }

            return;
        }

        foreach ($choice['answer'] as $index => $answertext) {
            $answertext = htmlentities($answertext);
            $picturefile = $choice['imagename'][$index] ?? null;
            $file_org_name = $_FILES['choice']['name']['image'][$index] ?? '';
            $file_temp_name = $_FILES['choice']['tmp_name']['image'][$index] ?? '';

            if ($file_temp_name !== '') {
                // check suffix
                $file_name_parts = explode('.', $file_org_name);
                $suffix = strtolower(array_pop($file_name_parts));
                if (in_array($suffix, ['jpg', 'jpeg', 'png', 'gif'])) {
                    // upload image
                    $filename = $this->object->buildHashedImageFilename($file_org_name);
                    if ($this->object->setImageFile($filename, $file_temp_name) == 0) {
                        $picturefile = $filename;
                    }
                }
            }

            $points = (float) str_replace(',', '.', $choice['points'][$index]);
            $this->object->addAnswer(
                $answertext,
                $points,
                $index,
                $picturefile,
                $choice['answer_id'][$index]
            );
        }

        if ($this->rebuild_thumbnails) {
            $this->object->setAnswers(
                $this->object->rebuildThumbnails(
                    $this->object->isSingleline(),
                    $this->object->getThumbSize(),
                    $this->object->getImagePath(),
                    $this->object->getAnswers()
                )
            );
        }
    }

    public function populateAnswerSpecificFormPart(\ilPropertyFormGUI $form, bool $is_singleline = false): ilPropertyFormGUI
    {
        $choices = new ilSingleChoiceWizardInputGUI($this->lng->txt('answers'), 'choice');
        $choices->setRequired(true);
        $choices->setQuestionObject($this->object);
        $choices->setSingleline($is_singleline);
        $choices->setAllowMove(false);
        if ($this->object->getSelfAssessmentEditingMode()) {
            $choices->setSize(40);
        }
        if ($this->object->getAnswerCount() == 0) {
            $this->object->addAnswer('', 0, 0);
        }
        $choices->setValues(array_map(
            function (ASS_AnswerBinaryStateImage $value) {
                $value->setAnswerText(html_entity_decode($value->getAnswerText()));
                return $value;
            },
            $this->object->getAnswers()
        ));
        $form->addItem($choices);
        return $form;
    }

    public function getAfterParticipationSuppressionAnswerPostVars(): array
    {
        return [];
    }

    private function aggregateAnswers($relevant_answers_chosen, $answers_defined_on_question): array
    {
        $aggregate = [];
        foreach ($answers_defined_on_question as $answer) {
            $aggregated_info_for_answer = [];
            $aggregated_info_for_answer['answertext'] = $answer->getAnswerText();
            $aggregated_info_for_answer['count_checked'] = 0;

            foreach ($relevant_answers_chosen as $relevant_answer) {
                if ($relevant_answer['value1'] == $answer->getOrder()) {
                    $aggregated_info_for_answer['count_checked']++;
                }
            }
            $aggregated_info_for_answer['count_unchecked'] =
                ceil(count($relevant_answers_chosen) / count($answers_defined_on_question))
                - $aggregated_info_for_answer['count_checked'];

            $aggregate[] = $aggregated_info_for_answer;
        }
        return $aggregate;
    }

    public function renderAggregateView($aggregate): ilTemplate
    {
        $tpl = new ilTemplate('tpl.il_as_aggregated_answers_table.html', true, true, 'components/ILIAS/TestQuestionPool');

        $tpl->setCurrentBlock('headercell');
        $tpl->setVariable('HEADER', $this->lng->txt('tst_answer_aggr_answer_header'));
        $tpl->parseCurrentBlock();

        $tpl->setCurrentBlock('headercell');
        $tpl->setVariable('HEADER', $this->lng->txt('tst_answer_aggr_frequency_header'));
        $tpl->parseCurrentBlock();

        foreach ($aggregate as $line_data) {
            $tpl->setCurrentBlock('aggregaterow');
            $tpl->setVariable('OPTION', $line_data['answertext']);
            $tpl->setVariable('COUNT', $line_data['count_checked']);
            $tpl->parseCurrentBlock();
        }
        return $tpl;
    }

    private function populateInlineFeedback($template, $answer_id, $user_solution): void
    {
        $feedbackOutputRequired = false;

        switch ($this->object->getSpecificFeedbackSetting()) {
            case 1:
                $feedbackOutputRequired = true;
                break;

            case 2:
                if ((string) $user_solution === (string) $answer_id) {
                    $feedbackOutputRequired = true;
                }
                break;

            case 3:
                if ($this->object->getAnswer($answer_id)->getPoints() > 0) {
                    $feedbackOutputRequired = true;
                }
                break;
        }

        if ($feedbackOutputRequired) {
            $fb = $this->object->feedbackOBJ->getSpecificAnswerFeedbackTestPresentation($this->object->getId(), 0, $answer_id);
            if (strlen($fb)) {
                $template->setCurrentBlock('feedback');
                $template->setVariable('FEEDBACK', ilLegacyFormElementsUtil::prepareTextareaOutput($fb, true));
                $template->parseCurrentBlock();
            }
        }
    }

    public function getAnswersFrequency($relevantAnswers, $questionIndex): array
    {
        $agg = $this->aggregateAnswers($relevantAnswers, $this->object->getAnswers());

        $answers = [];

        foreach ($agg as $ans) {
            $answers[] = [
                'answer' => $ans['answertext'],
                'frequency' => $ans['count_checked']
            ];
        }

        return $answers;
    }

    public function populateCorrectionsFormProperties(ilPropertyFormGUI $form): void
    {
        $choices = new ilAssSingleChoiceCorrectionsInputGUI($this->lng->txt('answers'), 'choice');
        $choices->setRequired(true);
        $choices->setQuestionObject($this->object);
        $choices->setValues($this->object->getAnswers());
        $form->addItem($choices);
    }

    public function saveCorrectionsFormProperties(ilPropertyFormGUI $form): void
    {
        $input = $form->getItemByPostVar('choice');
        $values = $input->getValues();

        foreach ($this->object->getAnswers() as $index => $answer) {
            /* @var ASS_AnswerMultipleResponseImage $answer */
            $points = (float) str_replace(',', '.', $values[$index]->getPoints());
            $answer->setPoints($points);
        }
    }
}