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

declare(strict_types=1);

namespace core_course\reportbuilder\datasource;

use completion_completion;
use completion_criteria_self;
use core_reportbuilder_generator;
use core_reportbuilder\local\aggregation\{avg, max, min};
use core_reportbuilder\local\filters\{boolean_select, date, duration, select, text};
use core_reportbuilder\tests\core_reportbuilder_testcase;
use core\user;
use grade_item;

/**
 * Course participants datasource tests
 *
 * @package     core_course
 * @covers      \core_course\reportbuilder\datasource\participants
 * @copyright   2022 David Matamoros <davidmc@moodle.com>
 * @license     http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */
final class participants_test extends core_reportbuilder_testcase {

    /**
     * Load required test libraries
     */
    public static function setUpBeforeClass(): void {
        global $CFG;

        require_once("{$CFG->libdir}/gradelib.php");
        require_once("{$CFG->dirroot}/completion/criteria/completion_criteria_self.php");
        parent::setUpBeforeClass();
    }

    /**
     * Test default datasource
     */
    public function test_datasource_default(): void {
        global $DB;

        $this->resetAfterTest();

        // Course one, two manually enrolled users.
        $courseone = $this->getDataGenerator()->create_course(['fullname' => 'Zebras']);
        $userone = $this->getDataGenerator()->create_and_enrol($courseone, 'student', ['firstname' => 'Zoe']);
        $usertwo = $this->getDataGenerator()->create_and_enrol($courseone, 'student', ['firstname' => 'Amy']);

        // Course two, two self enrolled users (one inactive).
        $coursetwo = $this->getDataGenerator()->create_course(['fullname' => 'Aardvarks']);

        $enrol = $DB->get_record('enrol', ['courseid' => $coursetwo->id, 'enrol' => 'self']);
        enrol_get_plugin($enrol->enrol)->update_status($enrol, ENROL_INSTANCE_ENABLED);

        $this->getDataGenerator()->enrol_user($userone->id, $coursetwo->id, null, 'self');
        $this->getDataGenerator()->enrol_user($usertwo->id, $coursetwo->id, null, 'self', 0, 0, ENROL_USER_SUSPENDED);

        /** @var core_reportbuilder_generator $generator */
        $generator = $this->getDataGenerator()->get_plugin_generator('core_reportbuilder');
        $report = $generator->create_report(['name' => 'Participants', 'source' => participants::class, 'default' => 1]);

        $content = $this->get_custom_report_content($report->get('id'));

        // Default columns are course, user, method. Sorted by each.
        $courseoneurl = course_get_url($courseone);
        $coursetwourl = course_get_url($coursetwo);

        $useroneurl = user::get_profile_url($userone);
        $usertwourl = user::get_profile_url($usertwo);

        $this->assertEquals([
            ["<a href=\"{$coursetwourl}\">{$coursetwo->fullname}</a>",
                "<a href=\"{$useroneurl}\">" . fullname($userone) . "</a>", 'Self enrolment (Student)'],
            ["<a href=\"{$courseoneurl}\">{$courseone->fullname}</a>",
                "<a href=\"{$usertwourl}\">" . fullname($usertwo) . "</a>", 'Manual enrolments'],
            ["<a href=\"{$courseoneurl}\">{$courseone->fullname}</a>",
                "<a href=\"{$useroneurl}\">" . fullname($userone) . "</a>", 'Manual enrolments'],
        ], array_map('array_values', $content));
    }

    /**
     * Test datasource columns that aren't added by default
     */
    public function test_datasource_non_default_columns(): void {
        global $DB;
        $this->resetAfterTest();

        $timestart = time() - DAYSECS;
        $timeend = $timestart + 3 * DAYSECS;
        $timecompleted = $timestart + 2 * DAYSECS;
        $timelastaccess = time() + 4 * DAYSECS;

        $category = $this->getDataGenerator()->create_category(['name' => 'Music']);
        $course = $this->getDataGenerator()->create_course([
            'category' => $category->id,
            'fullname' => 'All about Lionel at the work place',
            'enablecompletion' => true,
            'startdate' => $timestart,
            'enddate' => $timeend,
        ]);

        $user1 = self::getDataGenerator()->create_user();
        $this->getDataGenerator()->enrol_user($user1->id, $course->id, 'student',
            'manual', $timestart, $timeend, ENROL_USER_ACTIVE);

        // Add them to a group.
        $group = self::getDataGenerator()->create_group(['courseid' => $course->id]);
        self::getDataGenerator()->create_group_member(['groupid' => $group->id, 'userid' => $user1->id]);

        // Create self completion, mark as complete for the user.
        $criteriaconfig = (object) ['id' => $course->id, 'criteria_self' => true];
        (new completion_criteria_self())->update_config($criteriaconfig);

        $ccompletion = new completion_completion(['course' => $course->id, 'userid' => $user1->id]);
        $ccompletion->mark_enrolled($timestart);
        $ccompletion->mark_complete($timecompleted);

        // Update final grade for the user.
        $courseitem = grade_item::fetch_course_item($course->id);
        $courseitem->update_final_grade($user1->id, 42.5);

        // Add some cohort data.
        $cohort = $this->getDataGenerator()->create_cohort(['name' => 'My cohort']);
        cohort_add_member($cohort->id, $user1->id);

        // Set some last access value for the user in the course.
        $DB->insert_record('user_lastaccess',
            ['userid' => $user1->id, 'courseid' => $course->id, 'timeaccess' => $timelastaccess]);

        /** @var core_reportbuilder_generator $generator */
        $generator = $this->getDataGenerator()->get_plugin_generator('core_reportbuilder');
        $report = $generator->create_report(['name' => 'Participants', 'source' => participants::class, 'default' => false]);

        $generator->create_column(['reportid' => $report->get('id'),
            'uniqueidentifier' => 'course:fullname']);
        $generator->create_column(['reportid' => $report->get('id'),
            'uniqueidentifier' => 'course_category:name']);
        $generator->create_column(['reportid' => $report->get('id'),
            'uniqueidentifier' => 'user:fullname']);

        // Enrol entity (report ordering by enrolment name).
        $generator->create_column(['reportid' => $report->get('id'), 'uniqueidentifier' => 'enrol:name', 'sortenabled' => 1]);
        $generator->create_column(['reportid' => $report->get('id'), 'uniqueidentifier' => 'enrol:plugin']);
        $generator->create_column(['reportid' => $report->get('id'), 'uniqueidentifier' => 'enrol:enabled']);
        $generator->create_column(['reportid' => $report->get('id'), 'uniqueidentifier' => 'enrol:period']);
        $generator->create_column(['reportid' => $report->get('id'), 'uniqueidentifier' => 'enrol:startdate']);
        $generator->create_column(['reportid' => $report->get('id'), 'uniqueidentifier' => 'enrol:enddate']);

        // Role entity.
        $generator->create_column(['reportid' => $report->get('id'), 'uniqueidentifier' => 'role:name']);
        $generator->create_column(['reportid' => $report->get('id'), 'uniqueidentifier' => 'role:shortname']);
        $generator->create_column(['reportid' => $report->get('id'), 'uniqueidentifier' => 'role:description']);

        $generator->create_column(['reportid' => $report->get('id'),
            'uniqueidentifier' => 'group:name']);
        $generator->create_column(['reportid' => $report->get('id'), 'uniqueidentifier' => 'cohort:name']);
        $generator->create_column(['reportid' => $report->get('id'), 'uniqueidentifier' => 'completion:criteria']);
        $generator->create_column(['reportid' => $report->get('id'),
            'uniqueidentifier' => 'completion:completed']);
        $generator->create_column(['reportid' => $report->get('id'),
            'uniqueidentifier' => 'access:timeaccess']);
        $generator->create_column(['reportid' => $report->get('id'),
            'uniqueidentifier' => 'completion:progresspercent']);
        $generator->create_column(['reportid' => $report->get('id'),
            'uniqueidentifier' => 'completion:timeenrolled']);
        $generator->create_column(['reportid' => $report->get('id'),
            'uniqueidentifier' => 'completion:timestarted']);
        $generator->create_column(['reportid' => $report->get('id'),
            'uniqueidentifier' => 'completion:timecompleted']);
        $generator->create_column(['reportid' => $report->get('id'),
            'uniqueidentifier' => 'completion:reaggregate']);
        $generator->create_column(['reportid' => $report->get('id'),
            'uniqueidentifier' => 'completion:dayscourse']);
        $generator->create_column(['reportid' => $report->get('id'),
            'uniqueidentifier' => 'completion:daysuntilcompletion']);
        $generator->create_column(['reportid' => $report->get('id'),
            'uniqueidentifier' => 'completion:grade']);

        // It should get 3 records (manual enrolment, self and guest).
        $content = $this->get_custom_report_content($report->get('id'));
        $this->assertCount(3, $content);

        // Filter by Manual enrolment method.
        $generator->create_filter(['reportid' => $report->get('id'), 'uniqueidentifier' => 'enrol:plugin']);
        $content = $this->get_custom_report_content($report->get('id'), 30, [
            'enrol:plugin_operator' => select::EQUAL_TO,
            'enrol:plugin_value' => 'manual',
        ]);

        $this->assertCount(1, $content);

        $this->assertEquals([
            'All about Lionel at the work place', // Course name.
            'Music', // Course category name.
            fullname($user1), // User fullname.
            'Manual enrolments', // Enrolment method.
            'Manual enrolments', // Enrolment plugin.
            'Yes', // Enrolment enabled.
            '', // Enrolment period.
            '', // Enrolment start date.
            '', // Enrolment end date.
            'Student', // Role name.
            'student', // Role shortname.
            'Students generally have fewer privileges within a course.', // Role description.
            $group->name, // Group name.
            $cohort->name, // Cohort name.
            "All criteria below are required<ul>\n<li>Self completion: Self completion</li>\n</ul>", // Completion criteria.
            'Yes', // Course completed.
            userdate($timelastaccess), // Time last access.
            '100.0%', // Progress percentage.
            userdate($timestart), // Time enrolled.
            '', // Time started.
            userdate($timecompleted), // Time completed.
            '', // Reagreggate.
            '2 days', // Days taking course.
            '2 days', // Days until completion.
            '42.50', // Grade.
        ], array_values($content[0]));
    }


    /**
     * Test creating participants report, with aggregated last access date (minimum and maximum)
     */
    public function test_course_last_access_aggregation(): void {
        $this->resetAfterTest();

        $course = $this->getDataGenerator()->create_course();

        $userone = $this->getDataGenerator()->create_and_enrol($course);
        $useronelastaccess = $this->getDataGenerator()->create_user_course_lastaccess($userone, $course, 1622502000);

        $usertwo = $this->getDataGenerator()->create_and_enrol($course);
        $usertwolastaccess = $this->getDataGenerator()->create_user_course_lastaccess($usertwo, $course, 1622847600);

        /** @var core_reportbuilder_generator $generator */
        $generator = $this->getDataGenerator()->get_plugin_generator('core_reportbuilder');

        $report = $generator->create_report(['name' => 'Participants', 'source' => participants::class, 'default' => 0]);
        $generator->create_column(['reportid' => $report->get('id'), 'uniqueidentifier' => 'course:fullname']);

        // Course aggregated with "Minimum" last access.
        $column = $generator->create_column([
            'reportid' => $report->get('id'),
            'uniqueidentifier' => 'access:timeaccess',
            'aggregation' => min::get_class_name(),
        ]);

        $content = $this->get_custom_report_content($report->get('id'));
        $this->assertEquals([
            [$course->fullname, userdate($useronelastaccess->timeaccess)],
        ], array_map('array_values', $content));

        // Course aggregated with "Maximum" last access.
        $column->set('aggregation', max::get_class_name())->update();
        $content = $this->get_custom_report_content($report->get('id'));
        $this->assertEquals([
            [$course->fullname, userdate($usertwolastaccess->timeaccess)],
        ], array_map('array_values', $content));
    }

    /**
     * Test creating participants report, with aggregated days taking course column
     */
    public function test_completion_days_taking_course_aggregation(): void {
        $this->resetAfterTest();

        $courseone = $this->getDataGenerator()->create_course(['fullname' => 'Course 1', 'startdate' => 1622502000]);
        $coursetwo = $this->getDataGenerator()->create_course(['fullname' => 'Course 2']);

        // User one completed the course in two days.
        $userone = $this->getDataGenerator()->create_and_enrol($courseone);
        $completion = new completion_completion(['course' => $courseone->id, 'userid' => $userone->id]);
        $completion->mark_complete(1622502000 + (2 * DAYSECS));

        // User two completed the course in three days (lazy bum).
        $usertwo = $this->getDataGenerator()->create_and_enrol($courseone);
        $completion = new completion_completion(['course' => $courseone->id, 'userid' => $usertwo->id]);
        $completion->mark_complete(1622502000 + (3 * DAYSECS));

        /** @var core_reportbuilder_generator $generator */
        $generator = $this->getDataGenerator()->get_plugin_generator('core_reportbuilder');

        $report = $generator->create_report(['name' => 'Participants', 'source' => participants::class, 'default' => 0]);
        $generator->create_column(['reportid' => $report->get('id'), 'uniqueidentifier' => 'course:fullname', 'sortenabled' => 1]);
        $generator->create_column([
            'reportid' => $report->get('id'),
            'uniqueidentifier' => 'completion:dayscourse',
            'aggregation' => avg::get_class_name(),
        ]);

        $content = $this->get_custom_report_content($report->get('id'));
        $this->assertEquals([
            [$courseone->fullname, '2 days 12 hours'],
            [$coursetwo->fullname, ''],
        ], array_map('array_values', $content));
    }

    /**
     * Data provider for {@see test_datasource_filters}
     *
     * @return array
     */
    public static function datasource_filters_provider(): array {
        global $DB;

        return [
            [
                'enrolment:status',
                [
                    'enrolment:status_operator' => select::EQUAL_TO,
                    'enrolment:status_value' => 1,
                ],
                ['Luna'],
            ],
            [
                'enrolment:timecreated',
                [
                    'enrolment:timecreated_operator' => date::DATE_CURRENT,
                    'enrolment:timecreated_unit' => date::DATE_UNIT_DAY,
                ],
                ['Kira'],
            ],
            [
                'enrolment:timestarted',
                [
                    'enrolment:timestarted_operator' => date::DATE_CURRENT,
                    'enrolment:timecreated_unit' => date::DATE_UNIT_DAY,
                ],
                ['Luna'],
            ],
            [
                'enrolment:timeended',
                [
                    'enrolment:timeended_operator' => date::DATE_CURRENT,
                    'enrolment:timeended_unit' => date::DATE_UNIT_DAY,
                ],
                ['Luna'],
            ],
            [
                'enrol:enabled',
                [
                    'completion:enabled_operator' => boolean_select::CHECKED,
                ],
                ['Lionel', 'Kira', 'Luna'],
            ],
            [
                'enrol:period',
                [
                    'enrol:period_operator' => duration::DURATION_MAXIMUM,
                    'enrol:period_unit' => MINSECS,
                    'enrol:period_value' => 2,
                ],
                ['Lionel', 'Kira', 'Luna'],
            ],
            [
                'enrol:startdate',
                [
                    'enrol:startdate_operator' => date::DATE_EMPTY,
                ],
                ['Lionel', 'Kira', 'Luna'],
            ],
            [
                'enrol:enddate',
                [
                    'enrol:enddate_operator' => date::DATE_EMPTY,
                ],
                ['Lionel', 'Kira', 'Luna'],
            ],
            [
                'enrol:customname',
                [
                    'enrol:customname_operator' => text::IS_EMPTY,
                ],
                ['Luna', 'Kira', 'Lionel'],
            ],
            [
                'enrol:customname',
                [
                    'enrol:customname_operator' => text::IS_EQUAL_TO,
                    'enrol:customname_value' => 'All night long'
                ],
                [],
            ],
            [
                'role:name',
                [
                    'role:name_operator' => select::EQUAL_TO,
                    'role:name_value' => $DB->get_field('role', 'id', ['shortname' => 'editingteacher']),
                ],
                ['Luna'],
            ],
            [
                'group:name',
                [
                    'group:name_operator' => text::IS_EQUAL_TO,
                    'group:name_value' => 'My group',
                ],
                ['Lionel'],
            ],
            [
                'cohort:name',
                [
                    'cohort:name_operator' => text::IS_EQUAL_TO,
                    'cohort:name_value' => 'My cohort',
                ],
                ['Kira'],
            ],
            [
                'completion:completed',
                [
                    'completion:completed_operator' => boolean_select::CHECKED,
                ],
                ['Lionel'],
            ],
            [
                'completion:timecompleted',
                [
                    'completion:timecompleted_operator' => date::DATE_NOT_EMPTY,
                ],
                ['Lionel'],
            ],
            [
                'completion:timeenrolled',
                [
                    'completion:timeenrolled_operator' => date::DATE_NOT_EMPTY,
                ],
                ['Lionel'],
            ],
            [
                'completion:timestarted',
                [
                    'completion:timestarted_operator' => date::DATE_NOT_EMPTY,
                ],
                ['Lionel'],
            ],
            [
                'completion:reaggregate',
                [
                    'completion:reaggregate_operator' => date::DATE_NOT_EMPTY,
                ],
                ['Lionel'],
            ],
        ];
    }

    /**
     * Test getting filter SQL
     *
     * @param string $filter
     * @param array $filtervalues
     * @param string[] $expected
     *
     * @dataProvider datasource_filters_provider
     */
    public function test_datasource_filters(string $filter, array $filtervalues, array $expected): void {
        global $DB;
        $this->resetAfterTest();

        $timestart = time() - DAYSECS;
        $timeend = $timestart + 3 * DAYSECS;
        $timecompleted = $timestart + 2 * DAYSECS;
        $timelastaccess = time() + 4 * DAYSECS;

        $category = $this->getDataGenerator()->create_category(['name' => 'Music']);
        $course = $this->getDataGenerator()->create_course([
            'category' => $category->id,
            'fullname' => 'All about Lionel at the work place',
            'enablecompletion' => true,
            'startdate' => $timestart,
            'enddate' => $timeend,
        ]);

        $user1 = self::getDataGenerator()->create_user(['firstname' => 'Lionel']);
        $user2 = self::getDataGenerator()->create_user(['firstname' => 'Kira']);
        $user3 = self::getDataGenerator()->create_user(['firstname' => 'Luna']);

        $this->getDataGenerator()->enrol_user($user1->id, $course->id, 'student',
            'manual', $timestart - 8 * DAYSECS, $timeend, ENROL_USER_ACTIVE);
        $this->getDataGenerator()->enrol_user($user2->id, $course->id, 'student',
            'manual', $timestart, $timeend, ENROL_USER_ACTIVE);
        $this->getDataGenerator()->enrol_user($user3->id, $course->id, 'editingteacher',
            'manual', time(), time(), ENROL_USER_SUSPENDED);

        // Add user1 to a group.
        $group = $this->getDataGenerator()->create_group(['courseid' => $course->id, 'name' => 'My group']);
        $this->getDataGenerator()->create_group_member(['groupid' => $group->id, 'userid' => $user1->id]);

        // Add some cohort data.
        $cohort = $this->getDataGenerator()->create_cohort(['name' => 'My cohort']);
        cohort_add_member($cohort->id, $user2->id);

        // Mark course as completed for the user.
        $ccompletion = new completion_completion(array('course' => $course->id, 'userid' => $user1->id));
        $ccompletion->mark_enrolled($timestart);
        $ccompletion->mark_inprogress($timestart);
        $ccompletion->mark_complete($timecompleted);

        // Set some last access value for the user in the course.
        $DB->insert_record('user_lastaccess',
            ['userid' => $user1->id, 'courseid' => $course->id, 'timeaccess' => $timelastaccess]);

        /** @var core_reportbuilder_generator $generator */
        $generator = $this->getDataGenerator()->get_plugin_generator('core_reportbuilder');
        $report = $generator->create_report(['name' => 'Participants', 'source' => participants::class, 'default' => false]);

        // Add user firstname column to the report.
        $generator->create_column(['reportid' => $report->get('id'), 'uniqueidentifier' => 'user:firstname']);

        $DB->set_field('user_enrolments', 'timecreated', 0, ['userid' => $user1->id]);
        $DB->set_field('user_enrolments', 'timecreated', 0, ['userid' => $user3->id]);

        // Add filters to the report.
        $generator->create_filter(['reportid' => $report->get('id'), 'uniqueidentifier' => 'enrol:plugin']);
        $generator->create_filter(['reportid' => $report->get('id'), 'uniqueidentifier' => $filter]);

        // Apply filters.
        $filtermanual = ['enrol:plugin_operator' => select::EQUAL_TO, 'enrol:plugin_value' => 'manual'];
        $content = $this->get_custom_report_content($report->get('id'), 30, $filtermanual + $filtervalues);

        $this->assertEqualsCanonicalizing($expected, array_column($content, 'c0_firstname'));
    }

    /**
     * Stress test datasource
     *
     * In order to execute this test PHPUNIT_LONGTEST should be defined as true in phpunit.xml or directly in config.php
     */
    public function test_stress_datasource(): void {
        if (!PHPUNIT_LONGTEST) {
            $this->markTestSkipped('PHPUNIT_LONGTEST is not defined');
        }

        $this->resetAfterTest();

        $course = $this->getDataGenerator()->create_course();
        $this->getDataGenerator()->create_and_enrol($course);

        $this->datasource_stress_test_columns(participants::class);
        $this->datasource_stress_test_columns_aggregation(participants::class);
        $this->datasource_stress_test_conditions(participants::class, 'course:idnumber');
    }
}
