<?php
// This file is part of the Studyplan plugin for Moodle
//
// 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 <https://www.gnu.org/licenses/>.
/**
 * Class to collect course completion info for a given course
 * @package    local_treestudyplan
 * @copyright  2023 P.M. Kuipers
 * @license    https://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */

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

require_once($CFG->libdir.'/externallib.php');
require_once($CFG->libdir.'/gradelib.php');
require_once($CFG->dirroot.'/course/lib.php');

use core\check\performance\debugging;
use core_course\local\repository\caching_content_item_readonly_repository;
use core_course\local\repository\content_item_readonly_repository;
use grade_item;
use grade_scale;
use grade_outcome;

/**
 * Class to collect course completion info for a given course
 */
class corecompletioninfo {
    /** @var \stdClass */
    private $course;
    /** @var \completion_info */
    private $completion;
    /** @var \course_modinfo */
    private $modinfo;

    /**
     * Cached dict of completion:: constants to equivalent webservice strings
     * @var array */
    private static $completionhandles = null;
    /**
     * Cached dict of all completion type constants to equivalent strings
     * @var array */
    private static $completiontypes = null;

    /**
     * Course id of relevant course
     */
    public function id() {
        return $this->course->id;
    }
    /**
     * Construct new object for a given course
     * @param \stdClass $course Course database record
     */
    public function __construct($course) {
        global $DB;
        $this->course = $course;
        $this->completion = new \completion_info($this->course);
        $this->modinfo = get_fast_modinfo($this->course);
    }

    /**
     * Get dictionary of all completion types as CONST => 'string'
     * @return array
     */
    public static function completiontypes() {
        /*  While it is tempting to use the global array COMPLETION_CRITERIA_TYPES,
            so we don't have to manually add any completion types if moodle decides to add a few.
            We can just as easily add the list here manually, since adding a completion type
            requires adding code to this page anyway.
            And this way we can keep the moodle code style checker happy.
            (Moodle will probably refator that part of the code anyway in the future, without
            taking effects of this plugin into account :)

            Array declaration based completion/criteria/completion_criteria.php:85 where the global
            COMPLETION_CRITERIA_TYPES iw/was defined.
        */
        if (!isset(self::$completiontypes)) {
            self::$completiontypes = [
                COMPLETION_CRITERIA_TYPE_SELF       => 'self',
                COMPLETION_CRITERIA_TYPE_DATE       => 'date',
                COMPLETION_CRITERIA_TYPE_UNENROL    => 'unenrol',
                COMPLETION_CRITERIA_TYPE_ACTIVITY   => 'activity',
                COMPLETION_CRITERIA_TYPE_DURATION   => 'duration',
                COMPLETION_CRITERIA_TYPE_GRADE      => 'grade',
                COMPLETION_CRITERIA_TYPE_ROLE       => 'role',
                COMPLETION_CRITERIA_TYPE_COURSE     => 'course',
            ];
        }
        return self::$completiontypes;
    }

    /**
     * Translate a numeric completion constant to a text string
     * @param int $completion The completion code as defined in completionlib.php to translate to a text handle
     */
    public static function completion_handle($completion) {
        if (empty(self::$completionhandles)) {
            // Cache the translation table, to avoid overhead.
            self::$completionhandles = [
                COMPLETION_INCOMPLETE => "incomplete",
                COMPLETION_COMPLETE => "complete",
                COMPLETION_COMPLETE_PASS => "complete-pass",
                COMPLETION_COMPLETE_FAIL => "complete-fail",
                COMPLETION_COMPLETE_FAIL_HIDDEN => "complete-fail"]; // The front end won't differentiate between hidden or not.
        }
        return self::$completionhandles[$completion] ?? "undefined";
    }

    /**
     * Webservice editor structure for completion_item
     * @param int $value Webservice requirement constant
     */
    public static function completion_item_editor_structure($value = VALUE_REQUIRED): \external_description {
        return new \external_single_structure([
            "id" => new \external_value(PARAM_INT, 'criteria id', VALUE_OPTIONAL),
            "title" => new \external_value(PARAM_RAW, 'name of subitem', VALUE_OPTIONAL),
            "link" => new \external_value(PARAM_RAW, 'optional link to more details', VALUE_OPTIONAL),
            "details" => new \external_single_structure([
                "type" => new \external_value(PARAM_RAW, 'type', VALUE_OPTIONAL),
                "criteria" => new \external_value(PARAM_RAW, 'criteria', VALUE_OPTIONAL),
                "requirement" => new \external_value(PARAM_RAW, 'requirement', VALUE_OPTIONAL),
                "status" => new \external_value(PARAM_RAW, 'status', VALUE_OPTIONAL),
            ]),
            "progress" => completionscanner::structure(),
         ], 'completion type', $value);
    }

    /**
     * Webservice editor structure for completion_type
     * @param int $value Webservice requirement constant
     */
    public static function completion_type_editor_structure($value = VALUE_REQUIRED): \external_description {
        return new \external_single_structure([
            "items" => new \external_multiple_structure(self::completion_item_editor_structure(), 'subitems', VALUE_OPTIONAL),
            "title" => new \external_value(PARAM_RAW, 'optional title', VALUE_OPTIONAL),
            "desc" => new \external_value(PARAM_RAW, 'optional description', VALUE_OPTIONAL),
            "type" => new \external_value(PARAM_TEXT, 'completion type name'),
            "aggregation" => new \external_value(PARAM_TEXT, 'completion aggregation for this type ["all", "any"]'),
         ], 'completion type', $value);
    }

    /**
     * Webservice editor structure for course completion
     * @param int $value Webservice requirement constant
     */
    /**
     * Webservice structure for editor info
     * @param int $value Webservice requirement constant
     */
    public static function editor_structure($value = VALUE_REQUIRED): \external_description {
        return new \external_single_structure([
           "conditions" => new \external_multiple_structure(self::completion_type_editor_structure(), 'completion conditions'),
           "aggregation" => new \external_value(PARAM_TEXT, 'completion aggregation ["all", "any"]'),
           "enabled" => new \external_value(PARAM_BOOL, "whether completion is enabled here"),
        ], 'course completion info', $value);
    }

    /**
     * Webservice user view structure for completion_item
     * @param int $value Webservice requirement constant
     */
    public static function completion_item_user_structure($value = VALUE_REQUIRED): \external_description {
        return new \external_single_structure([
            "id" => new \external_value(PARAM_INT, 'id of completion', VALUE_OPTIONAL),
            "title" => new \external_value(PARAM_RAW, 'name of subitem', VALUE_OPTIONAL),
            "details" => new \external_single_structure([
                "type" => new \external_value(PARAM_RAW, 'type', VALUE_OPTIONAL),
                "criteria" => new \external_value(PARAM_RAW, 'criteria', VALUE_OPTIONAL),
                "requirement" => new \external_value(PARAM_RAW, 'requirement', VALUE_OPTIONAL),
                "status" => new \external_value(PARAM_RAW, 'status', VALUE_OPTIONAL),
            ]),
            "link" => new \external_value(PARAM_RAW, 'optional link to more details', VALUE_OPTIONAL),
            "completed" => new \external_value(PARAM_BOOL, 'simple completed or not'),
            "status" => new \external_value(PARAM_TEXT,
                            'extended completion status ["incomplete", "progress", "complete", "complete-pass", "complete-fail"]'),
            "pending" => new \external_value(PARAM_BOOL,
                            'optional pending state, for submitted but not yet reviewed activities', VALUE_OPTIONAL),
            "grade" => new \external_value(PARAM_TEXT, 'optional grade result for this subitem', VALUE_OPTIONAL),
            "feedback" => new \external_value(PARAM_RAW, 'optional feedback for this subitem ', VALUE_OPTIONAL),
            "warning" => new \external_value(PARAM_TEXT, 'optional warning text', VALUE_OPTIONAL),
         ], 'completion type', $value);
    }

    /**
     * Webservice user view structure for completion_type
     * @param int $value Webservice requirement constant
     */
    public static function completion_type_user_structure($value = VALUE_REQUIRED): \external_description {
        return new \external_single_structure([
            "items" => new \external_multiple_structure(self::completion_item_user_structure(), 'subitems', VALUE_OPTIONAL),
            "title" => new \external_value(PARAM_RAW, 'optional title', VALUE_OPTIONAL),
            "desc" => new \external_value(PARAM_RAW, 'optional description', VALUE_OPTIONAL),
            "type" => new \external_value(PARAM_TEXT, 'completion type name'),
            "aggregation" => new \external_value(PARAM_TEXT, 'completion aggregation for this type ["all", "any"]'),
            "completed" => new \external_value(PARAM_BOOL, 'current completion value for this type'),
            "status" => new \external_value(PARAM_TEXT,
                            'extended completion status ["incomplete", "progress", "complete", "complete-pass", "complete-fail"]'),
            "progress" => new \external_value(PARAM_INT, 'completed sub-conditions'),
            "count" => new \external_value(PARAM_INT, 'total number of sub-conditions'),
         ], 'completion type', $value);
    }

    /**
     * Webservice structure for userinfo
     * @param int $value Webservice requirement constant
     */
    public static function user_structure($value = VALUE_REQUIRED): \external_description {
        return new \external_single_structure([
            "progress" => new \external_value(PARAM_INT, 'completed sub-conditions'),
            "enabled" => new \external_value(PARAM_BOOL, "whether completion is enabled here"),
            "tracked" => new \external_value(PARAM_BOOL, "whether completion is tracked for the user", VALUE_OPTIONAL),
            "count" => new \external_value(PARAM_INT, 'total number of sub-conditions'),
            "conditions" => new \external_multiple_structure(self::completion_type_user_structure(), 'completion conditions'),
            "completed" => new \external_value(PARAM_BOOL, 'current completion value'),
            "aggregation" => new \external_value(PARAM_TEXT, 'completion aggregation ["all", "any"]'),
            "pending" => new \external_value(PARAM_BOOL, "true if the user has any assignments pending grading", VALUE_OPTIONAL),
        ], 'course completion info', $value);
    }

    /**
     * Convert agregation method constant to equivalent string for webservice
     * @param int $method COMPLETION_AGGREGATION_ALL || COMPLETION_AGGREGATION_ANY
     * @return string 'all' or 'any'
     */
    private static function aggregation_handle($method) {
        return ($method == COMPLETION_AGGREGATION_ALL) ? "all" : "any";
    }

    /**
     * Webservice model for editor info
     * @param int[]|null $studentlist List of user id's to use for checking issueing progress within a study plan
     * @return array Webservice data model
     */
    public function editor_model(?array $studentlist = null) {
        global $DB, $CFG;

        $conditions = [];
        $aggregation = "all"; // Default.
        $info = [
            "conditions" => $conditions,
            "aggregation" => self::aggregation_handle($this->completion->get_aggregation_method()),
            "enabled" => $this->completion->is_enabled(),
        ];

        // Check if completion tracking is enabled for this course - otherwise, revert to defaults .
        if ($this->completion->is_enabled()) {
            $aggregation = $this->completion->get_aggregation_method();
            // Loop through all condition types to see if they are applicable.
            foreach (self::completiontypes() as $type => $handle) {
                $criterias = $this->completion->get_criteria($type); // Returns array of relevant criteria items.
                if (count($criterias) > 0) {
                    // Only take it into account if the criteria count is > 0.
                    $cinfo = [
                        "type" => $handle,
                        "aggregation" => self::aggregation_handle($this->completion->get_aggregation_method($type)),
                        "title" => reset($criterias)->get_type_title(),
                        "items" => [],
                    ];

                    foreach ($criterias as $criteria) {
                        /*  Unfortunately, we cannot easily get the criteria details with get_details() without having a
                            user completion object involved, so'we'll have to retrieve the details per completion type.
                            See moodle/completion/criteria/completion_criteria_*.php::get_details() for the code that
                            the code below is based on.
                        */
                        unset($title); // Clear title from previous iteration if it was set.
                        if ($type == COMPLETION_CRITERIA_TYPE_SELF) {
                            $details = [
                                "type" => $criteria->get_title(),
                                "criteria" => $criteria->get_title(),
                                "requirement" => get_string('markingyourselfcomplete', 'completion'),
                                "status" => "",
                            ];
                        } else if ($type == COMPLETION_CRITERIA_TYPE_DATE) {
                            $details = [
                                "type" => get_string('datepassed', 'completion'),
                                "criteria" => get_string('remainingenroleduntildate', 'completion'),
                                "requirement" => date("Y-m-d", $criteria->timeend),
                                "status" => "",
                            ];
                        } else if ($type == COMPLETION_CRITERIA_TYPE_UNENROL) {
                            $details = [
                                "type" => get_string('unenrolment', 'completion'),
                                "criteria" => get_string('unenrolment', 'completion'),
                                "requirement" => get_string('unenrolingfromcourse', 'completion'),
                                "status" => "",
                            ];
                        } else if ($type == COMPLETION_CRITERIA_TYPE_ACTIVITY) {
                            $cm = $this->modinfo->get_cm($criteria->moduleinstance);
                            /* Criteria and requirements will be built in a moment by code copied
                               from completion_criteria_activity.php.
                            */
                            $details = [
                                "type" => $criteria->get_title(),
                                "criteria" => "",
                                "requirement" => "",
                                "status" => "",
                            ];
                            if ($cm->has_view()) {
                                $details['criteria'] = \html_writer::link($cm->url, $cm->get_formatted_name());
                            } else {
                                $details['criteria'] = $cm->get_formatted_name();
                            }
                            // Set title based on cm formatted name.
                            $title = $cm->get_formatted_name();
                            // Build requirements.
                            $details['requirement'] = [];

                            if ($cm->completion == COMPLETION_TRACKING_MANUAL) {
                                $details['requirement'][] = get_string('markingyourselfcomplete', 'completion');
                            } else if ($cm->completion == COMPLETION_TRACKING_AUTOMATIC) {
                                if ($cm->completionview) {
                                    $modulename = \core_text::strtolower(get_string('modulename', $criteria->module));
                                    $details['requirement'][] = get_string('viewingactivity', 'completion', $modulename);
                                }

                                if (!is_null($cm->completiongradeitemnumber)) {
                                    $details['requirement'][] = get_string('achievinggrade', 'completion');
                                }

                                if ($cm->completionpassgrade) {
                                    $details['requirement'][] = get_string('achievingpassinggrade', 'completion');
                                }
                            }

                            $details['requirement'] = implode(', ', $details['requirement']);

                        } else if ($type == COMPLETION_CRITERIA_TYPE_DURATION) {
                            $details = [
                                "type" => get_string('periodpostenrolment', 'completion'),
                                "criteria" => get_string('remainingenroledfortime', 'completion'),
                                "requirement" => get_string('xdays', 'completion', ceil($criteria->enrolperiod / (60 * 60 * 24))),
                                "status" => "",
                            ];
                        } else if ($type == COMPLETION_CRITERIA_TYPE_GRADE) {
                            $displaytype = \grade_get_setting($this->course->id, 'displaytype', $CFG->grade_displaytype);
                            $gradepass = $criteria->gradepass;
                            // Find grade item for course result.
                            $gi = new \grade_item(['courseid' => $this->course->id, 'itemtype' => 'course']);
                            $displaygrade = \grade_format_gradevalue($gradepass, $gi, true, $displaytype, 1);
                            $details = [
                                "type" => get_string('coursegrade', 'completion'),
                                "criteria" => get_string('graderequired', 'completion'),
                                "requirement" => get_string('graderequired', 'completion')
                                                    .": ".$displaygrade,
                                "status" => "",
                            ];
                            $title = get_string('graderequired', 'completion').': '.$displaygrade;

                        } else if ($type == COMPLETION_CRITERIA_TYPE_ROLE) {
                            $details = [
                                "type" => get_string('manualcompletionby', 'completion'),
                                "criteria" => $criteria->get_title(),
                                "requirement" => get_string('markedcompleteby', 'completion', $criteria->get_title()),
                                "status" => "",
                            ];
                        } else if ($type == COMPLETION_CRITERIA_TYPE_COURSE) {
                            $prereq = get_course($criteria->courseinstance);
                            $coursecontext = \context_course::instance($prereq->id, MUST_EXIST);
                            $fullname = format_string($prereq->fullname, true, ['context' => $coursecontext]);
                            $details = [
                                "type" => $criteria->get_title(),
                                "criteria" => '<a href="'.$CFG->wwwroot.'/course/view.php?id='.
                                                    $criteria->courseinstance.'">'.s($fullname).'</a>',
                                "requirement" => get_string('coursecompleted', 'completion'),
                                "status" => "",
                            ];
                        } else {
                            // Moodle added a criteria type.
                            $details = [
                                "type" => "",
                                "criteria" => "",
                                "requirement" => "",
                                "status" => "",
                            ];
                        }

                        $scanner = new completionscanner($criteria, $this->course);

                        // Only add the items list if we actually have items...
                        $cinfo["items"][] = [
                            "id" => $criteria->id,
                            "title" => isset($title) ? $title : $criteria->get_title_detailed(),
                            "details" => $details,
                            "progress" => $scanner->model($studentlist),
                        ];

                    }

                    $info['conditions'][] = $cinfo;
                }
            }
        }

        return $info;
    }

    /**
     * Determine overall completion for a given type
     * @param int $typeaggregation COMPLETION_AGGREGATION_ALL or COMPLETION_AGGREGATION_ANY
     * @param \completion_criteria_completion[] $completions List of completions to aggregate
     * @return bool Completed or not
     */
    private function aggregate_completions($typeaggregation, $completions) {
        $completed = 0;
        $count = count($completions);
        foreach ($completions as $c) {
            if ($c->is_complete()) {
                $completed++;
            }
        }
        if ($typeaggregation == COMPLETION_AGGREGATION_ALL) {
            return $completed >= $count;
        } else { // COMPLETION_AGGREGATION_ANY.
            return $completed > 1;
        }

    }

    /**
     * Webservice model for user course completion info
     * @param int $userid ID of user to check specific info for
     * @return array Webservice data model
     */
    public function user_model($userid) {
        global $DB;

        $progress = $this->get_advanced_progress_percentage($userid);
        $info = [
            'progress' => $progress->completed,
            "count" => $progress->count,
            "conditions" => [],
            "completed" => $this->completion->is_course_complete($userid),
            "aggregation" => self::aggregation_handle($this->completion->get_aggregation_method()),
            "enabled" => $this->completion->is_enabled(),
            "tracked" => $this->completion->is_tracked_user($userid),
        ];

        // Check if completion tracking is enabled for this course - otherwise, revert to defaults .
        if ($this->completion->is_enabled() && $this->completion->is_tracked_user($userid)) {
            $anypending = false;
            // Loop through all conditions to see if they are applicable.
            foreach (self::completiontypes() as $type => $handle) {
                // Get the main completion for this type.
                $completions = $this->completion->get_completions($userid, $type);
                if (count($completions) > 0) {
                    $typeaggregation = $this->completion->get_aggregation_method($type);
                    $completed = $this->aggregate_completions($typeaggregation, $completions);
                    $cinfo = [
                        "type" => $handle,
                        "aggregation" => self::aggregation_handle($typeaggregation),
                        "completed" => $completed,
                        "status" => $completed ? "complete" : "incomplete",
                        "title" => reset($completions)->get_criteria()->get_type_title(),
                        "items" => [],
                    ];

                    $progress = 0;
                    foreach ($completions as $completion) {
                        $criteria = $completion->get_criteria();

                        $iinfo = [
                            "id" => $criteria->id,
                            "title" => $criteria->get_title_detailed(),
                            "details" => $criteria->get_details($completion),
                            "completed" => $completion->is_complete(), // Make sure to override for activi.
                            "status" => self::completion_handle(
                                            $completion->is_complete() ? COMPLETION_COMPLETE : COMPLETION_INCOMPLETE),
                        ];

                        if ($type == COMPLETION_CRITERIA_TYPE_ACTIVITY) {
                            $cm = $this->modinfo->get_cm($criteria->moduleinstance);

                            // Retrieve data for this object.
                            $data = $this->completion->get_data($cm, false, $userid);
                            // If it's an activity completion, add all the relevant activities as sub-items.
                            $completionstatus = $data->completionstate;
                            $gradecompletion = $this->completion->get_grade_completion($cm, $userid);

                            /* To comply with the moodle completion report, only count COMPLETED_PASS as completed if
                               the completion is marked as complete by the system. Occasinally those don't match
                               and we want to show similar behaviour. This happens when completion data is reset
                               in a module
                            */
                            if (!$completion->is_complete()
                                    &&
                                 in_array($gradecompletion, [COMPLETION_COMPLETE, COMPLETION_COMPLETE_PASS])) {
                                /* If a passing grade was provided, but the activity was not completed,
                                 * most likely the completion data was erased.
                                 */

                                if (!is_null($cm->completiongradeitemnumber) || ($cm->completionpassgrade)) {
                                    // Show a warning if this activity has grade completions to help make sense of the completion.
                                    $iinfo["warning"] = get_string("warning_incomplete_pass", "local_treestudyplan");
                                } else {
                                    // Show a warning if this activity has no grade requirment for completion.
                                    $iinfo["warning"] = get_string("warning_incomplete_nograderq", "local_treestudyplan");
                                }
                            }

                            $iinfo['status'] = self::completion_handle($data->completionstate);
                            // Re-evaluate the completed value, to make sure COMPLETE_FAIL doesn't creep in as completed.
                            if (($data->completionstate == COMPLETION_INCOMPLETE)
                                    ||
                                ($data->completionstate == COMPLETION_COMPLETE_FAIL)) {
                                $iinfo['completed'] = false;
                            } else {
                                $iinfo['completed'] = true;
                                $progress += 1; // Add a point to the progress counter.
                            }

                            // Determine the grade (retrieve from grade item, not from completion).
                            $grade = $this->get_grade($cm, $userid);
                            $iinfo['grade'] = $grade->grade;
                            $iinfo['feedback'] = $grade->feedback;
                            $iinfo['pending'] = $grade->pending;

                            $anypending = $anypending || $grade->pending;
                            // Overwrite the status with progress if something has been graded, or is pending.
                            if ($completionstatus != COMPLETION_INCOMPLETE || $anypending) {
                                if ($cinfo["status"] == "incomplete") {
                                    $cinfo["status"] = "progress";
                                }
                            }

                        } else if ($type == COMPLETION_CRITERIA_TYPE_GRADE) {
                            // Make sure we provide the current course grade.
                            $rawgrade = floatval($iinfo['details']['status']);
                            $iinfo['grade'] = $this->format_course_grade($rawgrade);
                            $rq = floatval($iinfo['details']['requirement']);
                            $iinfo['details']['requirement'] = $this->format_course_grade($rq);
                                               ;
                            $iinfo["status"] = $completion->is_complete() ? "complete-pass" : "complete-fail";
                            if ($cinfo["status"] == "incomplete") {
                                $cinfo["status"] = "progress";
                            }

                            if ($completion->is_complete()) {
                                $progress += 1; // Add a point to the progress counter.
                            }
                        } else {
                            if ($completion->is_complete()) {
                                $progress += 1; // Add a point to the progress counter.
                            }
                        }
                        // Finally add the item to the items list.
                        $cinfo["items"][] = $iinfo;
                    }

                    // Set the count and progress stats based on the Type's aggregation style.
                    if ($typeaggregation == COMPLETION_AGGREGATION_ALL) {
                        // Count and Progress amount to the sum of items.
                        $cinfo["count"] = count($cinfo["items"]);
                        $cinfo["progress"] = $progress;
                    } else { // Typeaggregation == COMPLETION_AGGREGATION_ANY.
                        // Count and progress are either 1 or 0, since any of the items.
                        // Complete's the type.
                        $cinfo["count"] = (count($cinfo["items"]) > 0) ? 1 : 0;
                        $cinfo["progress"] = ($progress > 0) ? 1 : 0;
                    }

                    $info['conditions'][] = $cinfo;
                    $info['pending'] = $anypending;
                }
            }
        }

        return $info;
    }

    /**
     * Get the grade for a certain course module
     * @param \cm_info $cm Course module
     * @param int $userid ID of user to retrieve grade for
     * @return stdClass|null object containing 'grade' and optional 'feedback' attribute
     */
    private function get_grade($cm, $userid) {
        $gi = grade_item::fetch(['itemtype' => 'mod',
            'itemmodule' => $cm->modname,
            'iteminstance' => $cm->instance,
            'courseid' => $this->course->id]); // Make sure we only get results relevant to this course.

        if ($gi) {
            // Only the following types of grade yield a result.
            if (($gi->gradetype == GRADE_TYPE_VALUE || $gi->gradetype == GRADE_TYPE_SCALE)) {
                $grade = (object)$gi->get_final($userid); // Get the grade for the specified user.
                $result = new \stdClass;
                // Check if the final grade is available and numeric (safety check).
                if (!empty($grade) && !empty($grade->finalgrade) && is_numeric($grade->finalgrade)) {
                    $result->grade = \grade_format_gradevalue($grade->finalgrade, $gi, true, null, 1);
                    $result->feedback = \trim($grade->feedback);
                    $result->pending = (new gradingscanner($gi))->pending($userid);
                } else {
                    $result->grade = "-"; // Activity is gradable, but user did not receive a grade yet.
                    $result->feedback = null;
                    $result->pending = false;
                }
                return $result;
            }
        }

        return null; // Activity cannot be graded (Shouldn't be happening, but still....).
    }

    /**
     * Get the overall grade for this course
     * @param int $grade The grade object to format
     * @return stdClass|null object containing 'grade' and optional 'feedback' attribute
     */
    private function format_course_grade($grade) {
        $gi = new \grade_item(['itemtype' => 'course',
                                'courseid' => $this->course->id]);

        if ($gi) {
            return \grade_format_gradevalue($grade, $gi, true, null, 1);
        }

        return "x"; // Course cannot be graded (Shouldn't be happening, but still....).
    }

    /**
     * Returns the percentage completed by a certain user, returns null if no completion data is available.
     *
     * @param int $userid The id of the user, 0 for the current user
     * @return \stdClass The percentage info, left all 0 if  completion is not supported in the course,
     *         or if there are no activities that support completion.
     */
    public function get_advanced_progress_percentage($userid): \stdClass {

        // First, let's make sure completion is enabled.
        if (!$this->completion->is_enabled()) {
            debugging("Completion is not enabled for {$this->course->shortname}", DEBUG_NORMAL);
            return (object)[
                'count' => 0,
                'completed' => 0,
                'percentage' => 0,
            ];
        }

        if (!$this->completion->is_tracked_user($userid)) {
            debugging("$userid is not tracked in {$this->course->shortname}");
            return (object)[
                'count' => 0,
                'completed' => 0,
                'percentage' => 0,
            ];
        }

        $completions = $this->completion->get_completions($userid);

        $aggregation = $this->completion->get_aggregation_method();
        $critcount = [];

        // Before we check how many modules have been completed see if the course has completed. .
        // Count all completions, but treat .
        foreach ($completions as $completion) {
            $crit = $completion->get_criteria();

            // Make a new object for the type if it's not already there.
            $type = $crit->criteriatype;
            if (!array_key_exists($type, $critcount)) {
                $critcount[$type] = new \stdClass;
                $critcount[$type]->count = 0;
                $critcount[$type]->completed = 0;
                $critcount[$type]->aggregation = $this->completion->get_aggregation_method($type);
            }
            // Get a reference to the counter object for this type.
            $typecount =& $critcount[$type];

            $typecount->count += 1;
            if ($crit->criteriatype == COMPLETION_CRITERIA_TYPE_ACTIVITY) {
                // Get the cm data object.
                $cm = $this->modinfo->get_cm($crit->moduleinstance);
                // Retrieve data for this object.
                $data = $this->completion->get_data($cm, false, $userid);
                // Count complete, but failed as incomplete too...
                if (($data->completionstate == COMPLETION_INCOMPLETE) || ($data->completionstate == COMPLETION_COMPLETE_FAIL)) {
                    $typecount->completed += 0;
                } else {
                    $typecount->completed += 1;
                }
            } else {
                if ($completion->is_complete()) {
                    $typecount->completed += 1;
                }
            }
        }

        // Now that we have all completions sorted by type, we can be smart about how to do the count.
        $count = 0;
        $completed = 0;
        $completionpercentage = 0;
        foreach ($critcount as $c) {
            // Take only types that are actually present into account.
            if ($c->count > 0) {
                // If the aggregation for the type is ANY, reduce the count to 1 for this type.
                // And adjust the progress accordingly (check if any have been completed or not).
                if ($c->aggregation == COMPLETION_AGGREGATION_ALL) {
                    $ct = $c->count;
                    $cmpl = $c->completed;
                } else {
                    $ct = 1;
                    $cmpl = ($c->completed > 0) ? 1 : 0;
                }
                // If ANY completion for the types, count only the criteria type with the highest completion percentage -.
                // Overwrite data if current type is more complete.
                if ($aggregation == COMPLETION_AGGREGATION_ANY) {
                    $pct = $cmpl / $ct;
                    if ($pct > $completionpercentage) {
                        $count = $ct;
                        $completed = $cmpl;
                        $completionpercentage = $pct;
                    }
                } else {
                    // If ALL completion for the types, add the count for this type to that of the others.
                    $count += $ct;
                    $completed += $cmpl;
                    // Don't really care about recalculating completion percentage every round in this case.
                }
            }
        }

        $result = new \stdClass;
        $result->count = $count;
        $result->completed = $completed;
        $result->percentage = ($count > 0) ? (($completed / $count) * 100) : 0;
        return $result;
    }

}
