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

namespace tool_brickfield;

/**
 * Class manager
 * @package tool_brickfield
 * @copyright  2021 Brickfield Education Labs https://www.brickfield.ie
 * @license https://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */
class manager {

    /**
     * Defines the waiting for analysis status.
     */
    const STATUS_WAITING = 0;

    /**
     * Defined the analysis in progress status.
     */
    const STATUS_INPROGRESS = -1;

    /**
     * Defines the analysis has completed status.
     */
    const STATUS_CHECKED = 1;

    /**
     * Defines summary error value.
     */
    const SUMMARY_ERROR = 0;

    /**
     * Defines summary failed value.
     */
    const SUMMARY_FAILED = 1;

    /**
     * Defines summary percent value.
     */
    const SUMMARY_PERCENT = 2;

    /**
     * Default bulk record limit.
     */
    const BULKRECORDLIMIT = 1000;

    /**
     * Name of this plugin.
     */
    const PLUGINNAME = 'tool_brickfield';

    /**
     * Areas table name.
     */
    const DB_AREAS = self::PLUGINNAME . '_areas';

    /**
     * Cacheacts table name.
     */
    const DB_CACHEACTS = self::PLUGINNAME . '_cache_acts';

    /**
     * Cachecheck table name.
     */
    const DB_CACHECHECK = self::PLUGINNAME . '_cache_check';

    /**
     * Checks table name.
     */
    const DB_CHECKS = self::PLUGINNAME . '_checks';

    /**
     * Content table name.
     */
    const DB_CONTENT = self::PLUGINNAME . '_content';

    /**
     * Errors table name.
     */
    const DB_ERRORS = self::PLUGINNAME . '_errors';

    /**
     * Process table name.
     */
    const DB_PROCESS = self::PLUGINNAME . '_process';

    /**
     * Results table name.
     */
    const DB_RESULTS = self::PLUGINNAME . '_results';

    /**
     * Schedule table name.
     */
    const DB_SCHEDULE = self::PLUGINNAME . '_schedule';

    /**
     * Summary table name.
     */
    const DB_SUMMARY = self::PLUGINNAME . '_summary';

    /** @var string The URL to find help at. */
    private static $helpurl = 'https://www.brickfield.ie/moodle-help-311';


    /** @var  array Statically stores the database checks records. */
    static protected $checks;

    /**
     * Returns the URL used for registration.
     *
     * @return \moodle_url
     */
    public static function registration_url(): \moodle_url {
        return accessibility::get_plugin_url('registration.php');
    }

    /**
     * Returns an appropriate message about the current registration state.
     *
     * @return string
     * @throws \coding_exception
     * @throws \dml_exception
     * @throws \moodle_exception
     */
    public static function registration_message(): string {
        $firstline = get_string('notregistered', self::PLUGINNAME);
        if (has_capability('moodle/site:config', \context_system::instance())) {
            $secondline = \html_writer::link(self::registration_url(), get_string('registernow', self::PLUGINNAME));
        } else {
            $secondline = get_string('contactadmin', self::PLUGINNAME);
        }
        return $firstline . '<br />' . $secondline;
    }

    /**
     * Get the help page URL.
     * @return string
     * @throws dml_exception
     */
    public static function get_helpurl(): string {
        return self::$helpurl;
    }

    /**
     * Return an array of system checks available, and store them statically.
     *
     * @return array
     * @throws \dml_exception
     */
    public static function get_checks(): array {
        global $DB;
        if (self::$checks === null) {
            self::$checks = $DB->get_records(self::DB_CHECKS, [] , 'id');
        }
        return self::$checks;
    }

    /**
     * Find all available areas.
     *
     * @return area_base[]
     * @throws \ReflectionException
     */
    public static function get_all_areas(): array {
        return array_filter(
            array_map(
                function($classname) {
                    $reflectionclass = new \ReflectionClass($classname);
                    if ($reflectionclass->isAbstract()) {
                        return false;
                    }
                    $instance = new $classname();

                    if ($instance->is_available()) {
                        return $instance;
                    } else {
                        return null;
                    }
                },
                array_keys(\core_component::get_component_classes_in_namespace('tool_brickfield', 'local\areas'))
            )
        );
    }

    /**
     * Calculate contenthash of a given content string
     *
     * @param string|null $content
     * @return string
     */
    public static function get_contenthash(?string $content = null): string {

<         return sha1($content);



>         return sha1($content ?? '');


    }

    /**
     * Does the current area content need to be scheduled for check?
     *
     * It does not need to be scheduled if:
     * - it is the current content
     * OR
     * - there is already schedule
     *
     * @param int $areaid
     * @param string $contenthash
     * @return bool
     * @throws \dml_exception
     */
    protected static function content_needs_scheduling(int $areaid, string $contenthash): bool {
        global $DB;
        return ! $DB->get_field_sql('SELECT 1 FROM {' . self::DB_CONTENT . '} '.
            'WHERE areaid = ?
            AND (status = 0 OR (iscurrent = 1 AND contenthash = ?))',
            [$areaid, $contenthash], IGNORE_MULTIPLE);
    }

    /**
     * Schedule an area for analysis if there has been changes.
     *
     * @param \stdClass $arearecord record with the fields from the {tool_brickfield_areas} table
     *    as returned by area_base::find_relevant_areas().
     *    It also contains the 'content' property with the current area content
     * @throws \dml_exception
     */
    protected static function schedule_area_if_necessary(\stdClass $arearecord) {
        global $DB;

        $contenthash = static::get_contenthash($arearecord->content);
        $searchparams = array_diff_key((array)$arearecord, ['content' => 1, 'reftable' => 1, 'refid' => 1]);
        if ($dbrecord = $DB->get_record(self::DB_AREAS, $searchparams)) {
            if ( ! static::content_needs_scheduling($dbrecord->id, $contenthash)) {
                // This is already the latest content record or there is already scheduled record, nothing to do.
                return;
            }
        } else {
            $dbrecord = (object)array_diff_key((array)$arearecord, ['content' => 1]);
            $dbrecord->id = $DB->insert_record(self::DB_AREAS, $dbrecord);
        }
        // Schedule the area for the check. Note that we do not record the contenthash, we will calculate it again
        // during the actual check.
        $DB->insert_record(self::DB_CONTENT,
            (object)['areaid' => $dbrecord->id, 'contenthash' => '', 'timecreated' => time(),
                'status' => self::STATUS_WAITING]);
    }

    /**
     * Asks all area providers if they have any areas that might have changed as a result of an event and schedules them
     *
     * @param \core\event\base $event
     * @throws \ReflectionException
     * @throws \dml_exception
     */
    public static function find_new_or_updated_areas(\core\event\base $event) {
        foreach (static::get_all_areas() as $area) {
            if ($records = $area->find_relevant_areas($event)) {
                foreach ($records as $record) {
                    static::schedule_area_if_necessary($record);
                }
                $records->close();
            }
        }
    }

    /**
     * Returns the current content of the area.
     *
     * @param \stdClass $arearecord record from the tool_brickfield_areas table
     * @return array|null array where the first element is the value of the field and the second element
     *    is the 'format' for this field if it is present. If the record was not found null is returned.
     * @throws \ddl_exception
     * @throws \ddl_table_missing_exception
     * @throws \dml_exception
     */
    protected static function get_area_content(\stdClass $arearecord): array {
        global $DB;
        if ($arearecord->type == area_base::TYPE_FIELD) {
            $tablename = $arearecord->tablename;
            $fieldname = $arearecord->fieldorarea;
            $itemid = $arearecord->itemid;

            if (!$DB->get_manager()->table_exists($tablename)) {
                return [];
            }
            if (!$DB->get_manager()->field_exists($tablename, $fieldname)) {
                return [];
            }
            $fields = $fieldname;
            if ($DB->get_manager()->field_exists($tablename, $fieldname . 'format')) {
                $fields .= ',' . $fieldname . 'format';
            }
            if ($record = $DB->get_record($tablename, ['id' => $itemid], $fields)) {
                return array_values((array)$record);
            }
        }
        return [];
    }

    /**
     * Asks all area providers if they have any areas that might have changed per courseid and schedules them.
     *
     * @param int $courseid
     * @throws \ReflectionException
     * @throws \coding_exception
     * @throws \ddl_exception
     * @throws \ddl_table_missing_exception
     * @throws \dml_exception
     */
    public static function find_new_or_updated_areas_per_course(int $courseid) {
        $totalcount = 0;
        foreach (static::get_all_areas() as $area) {
            if ($records = $area->find_course_areas($courseid)) {
                foreach ($records as $record) {
                    $totalcount++;
                    static::schedule_area_if_necessary($record);
                }
                $records->close();
            }
            // For a site course request, also process the site level areas.
            if (($courseid == SITEID) && ($records = $area->find_system_areas())) {
                foreach ($records as $record) {
                    $totalcount++;
                    // Currently, the courseid in the area table is null if there is a category id.
                    if (!empty($record->categoryid)) {
                        $record->courseid = null;
                    }
                    static::schedule_area_if_necessary($record);
                }
                $records->close();
            }
        }
        // Need to run for total count of areas.
        static::check_scheduled_areas($totalcount);
    }

    /**
     * Finds all areas that are waiting to be checked, performs checks. Returns true if there were records processed, false if not.
     * To be called from scheduled task
     *
     * @param int $batch
     * @return bool
     * @throws \coding_exception
     * @throws \ddl_exception
     * @throws \ddl_table_missing_exception
     * @throws \dml_exception
     */
    public static function check_scheduled_areas(int $batch = 0): bool {
        global $DB;

        $processingtime = 0;
        $resultstime = 0;

        $config = get_config(self::PLUGINNAME);
        if ($batch == 0) {
            $batch = $config->batch;
        }
        // Creating insert array for courseid cache reruns.
        $recordsfound = false;
        $batchinserts = [];
        echo("Batch amount is ".$batch.", starttime ".time()."\n");
        $rs = $DB->get_recordset_sql('SELECT a.*, ch.id AS contentid
            FROM {' . self::DB_AREAS. '} a
            JOIN {' . self::DB_CONTENT . '} ch ON ch.areaid = a.id
            WHERE ch.status = ?
            ORDER BY a.id, ch.timecreated, ch.id',
            [self::STATUS_WAITING], 0, $batch);

        foreach ($rs as $arearecord) {
            $recordsfound = true;
            $DB->set_field(self::DB_CONTENT, 'status', self::STATUS_INPROGRESS, ['id' => $arearecord->contentid]);
            $content = static::get_area_content($arearecord);
            if ($content[0] == null) {
                $content[0] = '';
            }
            accessibility::run_check($content[0], $arearecord->contentid, $processingtime, $resultstime);

            // Set all content 'iscurrent' fields for this areaid to 0.
            $DB->set_field(self::DB_CONTENT, 'iscurrent', 0, ['areaid' => $arearecord->id]);
            // Update this content record to be the current record.
            $DB->update_record(self::DB_CONTENT,
                (object)['id' => $arearecord->contentid, 'status' => self::STATUS_CHECKED, 'timechecked' => time(),
                    'contenthash' => static::get_contenthash($content[0]), 'iscurrent' => 1]);

            // If full caching has been run, then queue, if not in queue already.
            if (($arearecord->courseid != null) && static::is_okay_to_cache() &&
                !isset($batchinserts[$arearecord->courseid])) {
                $batchinserts[$arearecord->courseid] = ['courseid' => $arearecord->courseid, 'item' => 'cache'];
            }
        }

        if (count($batchinserts) > 0) {
            $DB->insert_records(self::DB_PROCESS, $batchinserts);
        }

        mtrace('Total time in htmlchecker: ' . $processingtime . ' secs.');
        mtrace('Total time in results: ' . $resultstime . ' secs.');
        return $recordsfound;
    }

    /**
     * Return true if analysis hasn't been disabled.
     * @return bool
     * @throws \dml_exception
     */
    public static function is_okay_to_cache(): bool {
        return (analysis::type_is_byrequest());
    }

    /**
     * Finds all areas that are waiting to be deleted, performs deletions.
     *
     * @param int $batch limit, can be called from runcli.php
     * To be called from scheduled task
     * @throws \coding_exception
     * @throws \dml_exception
     */
    public static function check_scheduled_deletions(int $batch = 0) {
        global $DB;

        $config = get_config(self::PLUGINNAME);
        if ($batch == 0) {
            $batch = $config->batch;
        }

        // Creating insert array for courseid cache reruns.
        $batchinserts = [];

        $rs = $DB->get_recordset(self::DB_PROCESS, ['contextid' => -1, 'timecompleted' => 0], '', '*', 0, $batch);

        foreach ($rs as $record) {

            if ($record->item == "core_course") {
                $tidyparams = ['courseid' => $record->courseid];
                static::delete_summary_data($record->courseid); // Delete cache too.
            } else if ($record->item == "course_categories") {
                $tidyparams = ['component' => 'core_course', 'categoryid' => $record->innercontextid];
            } else if ($record->item == "course_sections") {
                // Locate course sections, using innercontextid, contextid set to -1 for delete.
                $tidyparams = ['courseid' => $record->courseid, 'component' => 'core_course',
                    'tablename' => $record->item, 'itemid' => $record->innercontextid];
            } else if ($record->item == "lesson_pages") {
                // Locate lesson pages, using innercontextid, contextid set to -1 for delete.
                $tidyparams = ['courseid' => $record->courseid, 'component' => 'mod_lesson',
                    'tablename' => $record->item, 'itemid' => $record->innercontextid];
            } else if ($record->item == "book_chapters") {
                // Locate book chapters, using innercontextid, contextid set to -1 for delete.
                $tidyparams = ['courseid' => $record->courseid, 'component' => 'mod_book',
                    'tablename' => $record->item, 'itemid' => $record->innercontextid];
            } else if ($record->item == "question") {
                // Locate question areas, using innercontextid, contextid set to -1 for delete.
                $tidyparams = [
                    'courseid' => $record->courseid, 'component' => 'core_question',
                    'tablename' => $record->item, 'itemid' => $record->innercontextid
                ];
            } else {
                // Locate specific module instance, using innercontextid, contextid set to -1 for delete.
                $tidyparams = ['courseid' => $record->courseid, 'component' => $record->item,
                    'itemid' => $record->innercontextid];
            }

            $areas = $DB->get_records(self::DB_AREAS, $tidyparams);
            foreach ($areas as $area) {
                static::delete_area_tree($area);
            }

            $DB->delete_records(self::DB_PROCESS, ['id' => $record->id]);

            // If full caching has been run, then queue, if not in queue already.
            if ($record->courseid != null && static::is_okay_to_cache() && !isset($batchinserts[$record->courseid])) {
                $batchinserts[$record->courseid] = ['courseid' => $record->courseid, 'item' => 'cache'];
            }
        }
        $rs->close();

        if (count($batchinserts) > 0) {
            $DB->insert_records(self::DB_PROCESS, $batchinserts);
        }
    }

    /**
     * Checks all queued course updates, and finds all relevant areas.
     *
     * @param int $batch limit
     * To be called from scheduled task
     * @throws \ReflectionException
     * @throws \dml_exception
     */
    public static function check_course_updates(int $batch = 0) {
        global $DB;

        if ($batch == 0) {
            $config = get_config(self::PLUGINNAME);
            $batch = $config->batch;
        }

        $recs = $DB->get_records(self::DB_PROCESS, ['item' => 'coursererun'], '', 'DISTINCT courseid', 0, $batch);

        foreach ($recs as $record) {
            static::find_new_or_updated_areas_per_course($record->courseid);
            $DB->delete_records(self::DB_PROCESS, ['courseid' => $record->courseid, 'item' => 'coursererun']);
            static::store_result_summary($record->courseid);
        }
    }

    /**
     * Finds all records for a given content area and performs deletions.
     *
     * To be called from scheduled task
     * @param \stdClass $area
     * @throws \dml_exception
     */
    public static function delete_area_tree(\stdClass $area) {
        global $DB;

        $contents = $DB->get_records(self::DB_CONTENT, ['areaid' => $area->id]);
        foreach ($contents as $content) {
            $results = $DB->get_records(self::DB_RESULTS, ['contentid' => $content->id]);
            foreach ($results as $result) {
                $DB->delete_records(self::DB_ERRORS, ['resultid' => $result->id]);
            }
            $DB->delete_records(self::DB_RESULTS, ['contentid' => $content->id]);
        }

        // Also, delete all child areas, if existing.
        $childparams = ['type' => $area->type, 'reftable' => $area->tablename,
            'refid' => $area->itemid];
        $childareas = $DB->get_records(self::DB_AREAS, $childparams);
        foreach ($childareas as $childarea) {
            static::delete_area_tree($childarea);
        }

        $DB->delete_records(self::DB_CONTENT, ['areaid' => $area->id]);
        $DB->delete_records(self::DB_AREAS, ['id' => $area->id]);
    }

    /**
     * Finds all records which are no longer current and performs deletions.
     *
     * To be called from scheduled task.
     */
    public static function delete_historical_data() {
        global $DB;

        $config = get_config(self::PLUGINNAME);

        if ($config->deletehistoricaldata) {
            $contents = $DB->get_records(self::DB_CONTENT, ['iscurrent' => 0, 'status' => self::STATUS_CHECKED]);
            foreach ($contents as $content) {
                $results = $DB->get_records(self::DB_RESULTS, ['contentid' => $content->id]);
                foreach ($results as $result) {
                    $DB->delete_records(self::DB_ERRORS, ['resultid' => $result->id]);
                }
                $DB->delete_records(self::DB_RESULTS, ['contentid' => $content->id]);
                $DB->delete_records(self::DB_CONTENT, ['id' => $content->id]);
            }
        }
    }

    /**
     * Finds all summary cache records for a given courseid and performs deletions.
     * To be called from scheduled task.
     *
     * @param int $courseid
     * @throws \dml_exception
     */
    public static function delete_summary_data(int $courseid) {
        global $DB;

        if ($courseid == null) {
            mtrace('Attempting to run delete_summary_data with no courseid, returning');
            return;
        }

        $DB->delete_records(self::DB_SUMMARY, ['courseid' => $courseid]);
        $DB->delete_records(self::DB_CACHECHECK, ['courseid' => $courseid]);
        $DB->delete_records(self::DB_CACHEACTS, ['courseid' => $courseid]);
    }

    /**
     * Finds all results required to display accessibility report and stores them in the database.
     *
     * To be called from scheduled task.
     * @param int|null $courseid
     * @throws \coding_exception
     * @throws \dml_exception
     */
    public static function store_result_summary(int $courseid = null) {
        global $DB;

        if (static::is_okay_to_cache() && ($courseid == null)) {
            mtrace('Attempting to run update cache with no courseid, returning');
            return;
        }

        $extrasql = !$courseid ? "" : "AND courseid = ?";
        $coursesqlval = !$courseid ? [] : [$courseid];

        // Count of failed activities and count of errors by check.
        $errorsql = "SELECT areas.courseid, chx.checkgroup,
                COUNT(DISTINCT (".$DB->sql_concat('areas.contextid', 'areas.component').")) AS failed,
                SUM(res.errorcount) AS errors
                FROM {" . self::DB_AREAS . "} areas
                INNER JOIN {" . self::DB_CONTENT . "} ch ON ch.areaid = areas.id
                INNER JOIN {" . self::DB_RESULTS . "} res ON res.contentid = ch.id
                INNER JOIN {" . self::DB_CHECKS . "} chx ON chx.id = res.checkid
                WHERE res.errorcount > ? AND ch.iscurrent = ? ". $extrasql ." GROUP BY courseid, chx.checkgroup";

        $recordserrored = $DB->get_recordset_sql($errorsql,  array_merge([0, 1], $coursesqlval));

        // Count of failed activities by course.
        $failsql = "SELECT areas.courseid,
                COUNT(DISTINCT (".$DB->sql_concat('areas.contextid', 'areas.component').")) AS failed,
                SUM(res.errorcount) AS errors
                FROM {" . self::DB_AREAS . "} areas
                INNER JOIN {" . self::DB_CONTENT . "} ch ON ch.areaid = areas.id
                INNER JOIN {" . self::DB_RESULTS . "} res ON res.contentid = ch.id
                WHERE res.errorcount > ? AND ch.iscurrent = ? ". $extrasql ." GROUP BY courseid";

        $recordsfailed = $DB->get_recordset_sql($failsql, array_merge([0, 1], $coursesqlval));

        $extrasql = !$courseid ? "" : "WHERE courseid = ?";
        // Count of activities per course.
        $countsql = "SELECT courseid, COUNT(DISTINCT (".$DB->sql_concat('areas.contextid', 'areas.component').")) AS activities
                FROM {" . self::DB_AREAS . "} areas ". $extrasql ." GROUP BY areas.courseid";

        $recordscount = $DB->get_records_sql($countsql, $coursesqlval);

        $final = [];
        $values = [];

        foreach ($recordscount as $countrecord) {
            $final[$countrecord->courseid] = array_pad(array(), 8,
                    [self::SUMMARY_ERROR => 0, self::SUMMARY_FAILED => 0, self::SUMMARY_PERCENT => 100]
                ) + [
                    "activitiespassed" => $countrecord->activities,
                    "activitiesfailed" => 0,
                    "activities" => $countrecord->activities
                ];
        }

        foreach ($recordsfailed as $failedrecord) {
            $final[$failedrecord->courseid]["activitiespassed"] -= $failedrecord->failed;
            $final[$failedrecord->courseid]["activitiesfailed"] += $failedrecord->failed;
        }

        foreach ($recordserrored as $errorrecord) {
            $final[$errorrecord->courseid][$errorrecord->checkgroup][self::SUMMARY_ERROR] = $errorrecord->errors;
            $final[$errorrecord->courseid][$errorrecord->checkgroup][self::SUMMARY_FAILED] = $errorrecord->failed;
            $final[$errorrecord->courseid][$errorrecord->checkgroup][self::SUMMARY_PERCENT] = round(100 * (1 -
                    ($final[$errorrecord->courseid][$errorrecord->checkgroup][self::SUMMARY_FAILED]
                        / $final[$errorrecord->courseid]["activities"])));
        }

        foreach ($recordscount as $course) {
            if (!$course->courseid) {
                continue;
            }
            $element = [
                'courseid' => $course->courseid,
                'status' => self::STATUS_CHECKED,
                'activities' => $final[$course->courseid]["activities"],
                'activitiespassed' => $final[$course->courseid]["activitiespassed"],
                'activitiesfailed' => $final[$course->courseid]["activitiesfailed"],
                'errorschecktype1' => $final[$course->courseid][area_base::CHECKGROUP_FORM][self::SUMMARY_ERROR],
                'errorschecktype2' => $final[$course->courseid][area_base::CHECKGROUP_IMAGE][self::SUMMARY_ERROR],
                'errorschecktype3' => $final[$course->courseid][area_base::CHECKGROUP_LAYOUT][self::SUMMARY_ERROR],
                'errorschecktype4' => $final[$course->courseid][area_base::CHECKGROUP_LINK][self::SUMMARY_ERROR],
                'errorschecktype5' => $final[$course->courseid][area_base::CHECKGROUP_MEDIA][self::SUMMARY_ERROR],
                'errorschecktype6' => $final[$course->courseid][area_base::CHECKGROUP_TABLE][self::SUMMARY_ERROR],
                'errorschecktype7' => $final[$course->courseid][area_base::CHECKGROUP_TEXT][self::SUMMARY_ERROR],
                'failedchecktype1' => $final[$course->courseid][area_base::CHECKGROUP_FORM][self::SUMMARY_FAILED],
                'failedchecktype2' => $final[$course->courseid][area_base::CHECKGROUP_IMAGE][self::SUMMARY_FAILED],
                'failedchecktype3' => $final[$course->courseid][area_base::CHECKGROUP_LAYOUT][self::SUMMARY_FAILED],
                'failedchecktype4' => $final[$course->courseid][area_base::CHECKGROUP_LINK][self::SUMMARY_FAILED],
                'failedchecktype5' => $final[$course->courseid][area_base::CHECKGROUP_MEDIA][self::SUMMARY_FAILED],
                'failedchecktype6' => $final[$course->courseid][area_base::CHECKGROUP_TABLE][self::SUMMARY_FAILED],
                'failedchecktype7' => $final[$course->courseid][area_base::CHECKGROUP_TEXT][self::SUMMARY_FAILED],
                'percentchecktype1' => $final[$course->courseid][area_base::CHECKGROUP_FORM][self::SUMMARY_PERCENT],
                'percentchecktype2' => $final[$course->courseid][area_base::CHECKGROUP_IMAGE][self::SUMMARY_PERCENT],
                'percentchecktype3' => $final[$course->courseid][area_base::CHECKGROUP_LAYOUT][self::SUMMARY_PERCENT],
                'percentchecktype4' => $final[$course->courseid][area_base::CHECKGROUP_LINK][self::SUMMARY_PERCENT],
                'percentchecktype5' => $final[$course->courseid][area_base::CHECKGROUP_MEDIA][self::SUMMARY_PERCENT],
                'percentchecktype6' => $final[$course->courseid][area_base::CHECKGROUP_TABLE][self::SUMMARY_PERCENT],
                'percentchecktype7' => $final[$course->courseid][area_base::CHECKGROUP_TEXT][self::SUMMARY_PERCENT]
            ];
            $resultid = $DB->get_field(self::DB_SUMMARY, 'id', ['courseid' => $course->courseid]);
            if ($resultid) {
                $element['id'] = $resultid;
                $DB->update_record(self::DB_SUMMARY, (object)$element);
                continue;
            }
            array_push($values, $element);
        }

        $DB->insert_records(self::DB_SUMMARY, $values);

        $extrasql = !$courseid ? "WHERE courseid != ?" : "WHERE courseid = ?";
        $coursesqlval = !$courseid ? [0] : [$courseid];
        // Count of failed errors per check.
        $checkssql = "SELECT area.courseid, ".self::STATUS_CHECKED." AS status, res.checkid,
                COUNT(res.errorcount) as checkcount, SUM(res.errorcount) AS errorcount
                FROM {" . self::DB_AREAS . "} area
                INNER JOIN {" . self::DB_CONTENT . "} ch ON ch.areaid = area.id AND ch.iscurrent = 1
                INNER JOIN {" . self::DB_RESULTS . "} res ON res.contentid = ch.id
                ".$extrasql." GROUP BY area.courseid, res.checkid";

        $checksresult = $DB->get_recordset_sql($checkssql, $coursesqlval);

        $checkvalues = [];
        foreach ($checksresult as $check) {
            if ($result = $DB->get_record(self::DB_CACHECHECK, ['courseid' => $check->courseid, 'checkid' => $check->checkid])) {
                $check->id = $result->id;
                $DB->update_record(self::DB_CACHECHECK, $check);
            } else {
                array_push($checkvalues, (array)$check);
            }
        }
        $DB->insert_records(self::DB_CACHECHECK, $checkvalues);

        // Count of failed or passed rate per activity.
        $activitysql = "SELECT courseid, ".self::STATUS_CHECKED." AS status, area.component,
                COUNT(DISTINCT area.contextid) AS totalactivities, 0 AS failedactivities,
                COUNT(DISTINCT area.contextid) AS passedactivities, 0 AS errorcount
                FROM {" . self::DB_AREAS . "} area
                ".$extrasql."
                GROUP BY area.courseid, area.component";

        $activityresults = $DB->get_recordset_sql($activitysql, $coursesqlval);

        $activityvalues = [];

        // Count of failed errors per courseid per activity.
        $activityfailedsql = "SELECT area.courseid, area.component, area.contextid, SUM(res.errorcount) AS errorcount
                FROM {" . self::DB_AREAS . "} area
                INNER JOIN {" . self::DB_CONTENT . "} ch ON ch.areaid = area.id AND ch.iscurrent = 1
                INNER JOIN {" . self::DB_RESULTS . "} res ON res.contentid = ch.id
                ".$extrasql." AND res.errorcount != 0
                GROUP BY area.courseid, area.component, area.contextid";

        $activityfailedresults = $DB->get_recordset_sql($activityfailedsql, $coursesqlval);

        foreach ($activityresults as $activity) {
            $tmpkey = $activity->courseid.$activity->component;
            $activityvalues[$tmpkey] = $activity;
        }

        foreach ($activityfailedresults as $failed) {
            $tmpkey = $failed->courseid.$failed->component;
            $activityvalues[$tmpkey]->failedactivities ++;
            $activityvalues[$tmpkey]->passedactivities --;
            $activityvalues[$tmpkey]->errorcount += $failed->errorcount;
        }

        $activityvaluespush = [];
        foreach ($activityvalues as $value) {
            if ($result = $DB->get_record(self::DB_CACHEACTS, ['courseid' => $value->courseid, 'component' => $value->component])) {
                $value->id = $result->id;
                $DB->update_record(self::DB_CACHEACTS, $value);
            } else {
                array_push($activityvaluespush, (array)$value);
            }
        }

        $DB->insert_records(self::DB_CACHEACTS, $activityvaluespush);

        $recordserrored->close();
        $recordsfailed->close();
        $checksresult->close();
        $activityresults->close();
        $activityfailedresults->close();
    }

    /**
     * Get course module summary information for a course.
     *
     * @param   int $courseid

<      * @return  stdClass[]



>      * @return  \stdClass[]


     */
    public static function get_cm_summary_for_course(int $courseid): array {
        global $DB;

        $sql = "
        SELECT
            area.cmid,
            sum(errorcount) as numerrors,
            count(errorcount) as numchecks
         FROM {" . self::DB_AREAS . "} area
         JOIN {" . self::DB_CONTENT . "} ch ON ch.areaid = area.id AND ch.iscurrent = 1
         JOIN {" . self::DB_RESULTS . "} res ON res.contentid = ch.id
        WHERE area.courseid = :courseid AND component != :component
     GROUP BY cmid";

        $params = [
            'courseid' => $courseid,
            'component' => 'core_course',
        ];

        return $DB->get_records_sql($sql, $params);
    }

    /**
     * Get section summary information for a course.
     *
     * @param   int $courseid
     * @return  stdClass[]
     */
    public static function get_section_summary_for_course(int $courseid): array {
        global $DB;

        $sql = "
        SELECT
            sec.section,
            sum(errorcount) AS numerrors,
            count(errorcount) as numchecks
         FROM {" . self::DB_AREAS . "} area
         JOIN {" . self::DB_CONTENT . "} ch ON ch.areaid = area.id AND ch.iscurrent = 1
         JOIN {" . self::DB_RESULTS . "} res ON res.contentid = ch.id
         JOIN {course_sections} sec ON area.itemid = sec.id
        WHERE area.tablename = :tablename AND area.courseid = :courseid
     GROUP BY sec.section";

        $params = [
            'courseid' => $courseid,
            'tablename' => 'course_sections'
        ];

        return $DB->get_records_sql($sql, $params);
    }
}