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

/**
 * The user screen.
 *
 * @package   gradereport_singleview
 * @copyright 2014 Moodle Pty Ltd (http://moodle.com)
 * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */

namespace gradereport_singleview\local\screen;

use grade_seq;
use gradereport_singleview;
use moodle_url;
use pix_icon;
use html_writer;
use gradereport_singleview\local\ui\range;
use gradereport_singleview\local\ui\bulk_insert;
use grade_item;
use grade_grade;
use stdClass;

defined('MOODLE_INTERNAL') || die;

/**
 * The user screen.
 *
 * @package   gradereport_singleview
 * @copyright 2014 Moodle Pty Ltd (http://moodle.com)
 * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */
class user extends tablelike implements selectable_items {

    /** @var array $categories A cache for grade_item categories */

<     private $categories = array();



>     private $categories = [];



    /** @var int $requirespaging Do we have more items than the paging limit? */
    private $requirespaging = true;


>     /** @var array get a valid user.  */
    /**
>     public $item = [];
     * Get the label for the select box that chooses items for this page.
> 


     * @return string
     */

<     public function select_label() {



>     public function select_label(): string {


        return get_string('selectgrade', 'gradereport_singleview');
    }

    /**
     * Get the description for the screen.
     *
     * @return string
     */

<     public function description() {



>     public function description(): string {


        return get_string('gradeitems', 'grades');
    }

    /**
     * Convert the list of items to a list of options.
     *
     * @return array
     */

<     public function options() {
<         $result = array();



>     public function options(): array {
>         $result = [];


        foreach ($this->items as $itemid => $item) {
            $result[$itemid] = $item->get_name();
        }
        return $result;
    }

    /**
     * Get the type of items on this screen.
     *
     * @return string
     */

<     public function item_type() {



>     public function item_type(): string {


        return 'grade';
    }

    /**
     * Init the screen
     *
     * @param bool $selfitemisempty Have we selected an item yet?
     */
    public function init($selfitemisempty = false) {

<         global $DB;



        if (!$selfitemisempty) {

<             $validusers = $this->load_users();



>             $validusers = \grade_report::get_gradable_users($this->courseid, $this->groupid);


            if (!isset($validusers[$this->itemid])) {
                // If the passed user id is not valid, show the first user from the list instead.
                $this->item = reset($validusers);
                $this->itemid = $this->item->id;
            } else {
                $this->item = $validusers[$this->itemid];
            }
        }


<         $params = array('courseid' => $this->courseid);
< 


        $seq = new grade_seq($this->courseid, true);


<         $this->items = array();



>         $this->items = [];


        foreach ($seq->items as $itemid => $item) {
            if (grade::filter($item)) {
                $this->items[$itemid] = $item;
            }
        }


>         // If we change perpage on pagination we might end up with a page that doesn't exist.
        $this->requirespaging = count($this->items) > $this->perpage;
>         if ($this->perpage) {

>             $numpages = intval(count($this->items) / $this->perpage) + 1;
        $this->setup_structure();
>             if ($numpages <= $this->page) {

>                 $this->page = 0;
        $this->definition = array(
>             }
            'finalgrade', 'feedback', 'override', 'exclude'
>         } else {
        );
>             $this->page = 0;
        $this->set_headers($this->original_headers());
>         }
    }
> 



<         $this->definition = array(



>         $this->definition = [



<         );



>         ];


     * Get the list of headers for the table.
     *
     * @return array List of headers
     */

<     public function original_headers() {
<         return array(
<             '', // For filter icon.



>     public function original_headers(): array {
>         return [


            get_string('assessmentname', 'gradereport_singleview'),

>             '', // For filter icon.


            get_string('gradecategory', 'grades'),

<             get_string('range', 'grades'),


            get_string('grade', 'grades'),

>             get_string('range', 'grades'),


            get_string('feedback', 'grades'),

<             $this->make_toggle_links('override'),
<             $this->make_toggle_links('exclude')
<         );



>             get_string('override', 'gradereport_singleview'),
>             get_string('exclude', 'gradereport_singleview'),
>         ];


    }

    /**
     * Format each row of the table.
     *
     * @param grade_item $item

<      * @return string



>      * @return array


     */

<     public function format_line($item) {



>     public function format_line($item): array {


        global $OUTPUT;

        $grade = $this->fetch_grade_or_default($item, $this->item->id);

<         $lockicon = '';



>         $gradestatus = '';




<         $lockeditem = $lockeditemgrade = 0;
<         if (!empty($grade->locked)) {
<             $lockeditem = 1;
<         }
<         if (!empty($grade->grade_item->locked)) {
<             $lockeditemgrade = 1;
<         }
<         // Check both grade and grade item.
<         if ($lockeditem || $lockeditemgrade) {
<              $lockicon = $OUTPUT->pix_icon('t/locked', 'grade is locked');



>         $context = [
>             'hidden' => $grade->is_hidden(),
>             'locked' => $grade->is_locked(),
>         ];
> 
>         if (in_array(true, $context)) {
>             $context['classes'] = 'gradestatus';
>             $gradestatus = $OUTPUT->render_from_template('core_grades/status_icons', $context);


        }


<         $iconstring = get_string('filtergrades', 'gradereport_singleview', $item->get_name());
< 


        // Create a fake gradetreeitem so we can call get_element_header().
        // The type logic below is from grade_category->_get_children_recursion().

<         $gradetreeitem = array();
<         if (in_array($item->itemtype, array('course', 'category'))) {
<             $gradetreeitem['type'] = $item->itemtype.'item';
<         } else {
<             $gradetreeitem['type'] = 'item';
<         }



>         $gradetreeitem = [];
> 
>         $type = in_array($item->itemtype, ['course', 'category']) ? "{$item->itemtype}item" : 'item';
>         $gradetreeitem['type'] = $type;


        $gradetreeitem['object'] = $item;
        $gradetreeitem['userid'] = $this->item->id;


<         $itemlabel = $this->structure->get_element_header($gradetreeitem, true, false, false, false, true);



>         $itemname = $this->structure->get_element_header($gradetreeitem, true, false, false, false, true);


        $grade->label = $item->get_name();


<         $line = array(
<             $OUTPUT->action_icon($this->format_link('grade', $item->id), new pix_icon('t/editstring', ''), null,
<                     ['title' => $iconstring, 'aria-label' => $iconstring]),
<             $this->format_icon($item) . $lockicon . $itemlabel,



>         $formatteddefinition = $this->format_definition($grade);
> 
>         $itemicon = html_writer::div($this->format_icon($item), 'mr-1');
>         $itemtype = \html_writer::span($this->structure->get_element_type_string($gradetreeitem),
>             'd-block text-uppercase small dimmed_text');
>         // If a behat test site is running avoid outputting the information about the type of the grade item.
>         // This additional information currently causes issues in behat particularly with the existing xpath used to
>         // interact with table elements.
>         if (!defined('BEHAT_SITE_RUNNING')) {
>             $itemcontent = html_writer::div($itemtype . $itemname);
>         } else {
>             $itemcontent = html_writer::div($itemname);
>         }
> 
>         $line = [
>             html_writer::div($itemicon . $itemcontent, "{$type} d-flex align-items-center"),
>             $this->get_item_action_menu($item),


            $this->category($item),

<             new range($item)
<         );
<         $lineclasses = array(
<             "action",
<             "gradeitem",
<             "category",
<             "range"
<         );



>             $formatteddefinition['finalgrade'] . $gradestatus,
>             new range($item),
>             $formatteddefinition['feedback'],
>             $formatteddefinition['override'],
>             $formatteddefinition['exclude'],
>         ];
>         $lineclasses = [
>             'gradeitem',
>             'action',
>             'category',
>             'grade',
>             'range',
>         ];




<         $outputline = array();



>         $outputline = [];


        $i = 0;
        foreach ($line as $key => $value) {
            $cell = new \html_table_cell($value);

<             if ($isheader = $i == 1) {



>             if ($isheader = $i == 0) {


                $cell->header = $isheader;
                $cell->scope = "row";
            }
            if (array_key_exists($key, $lineclasses)) {
                $cell->attributes['class'] = $lineclasses[$key];
            }
            $outputline[] = $cell;
            $i++;
        }


<         return $this->format_definition($outputline, $grade);



>         return $outputline;


    }

    /**
     * Helper to get the icon for an item.
     *
     * @param grade_item $item
     * @return string
     */

<     private function format_icon($item) {
<         $element = array('type' => 'item', 'object' => $item);



>     private function format_icon($item): string {
>         $element = ['type' => 'item', 'object' => $item];


        return $this->structure->get_element_icon($element);
    }

    /**

>      * Return the action menu HTML for the grade item.
     * Helper to get the category for an item.
>      *
     *
>      * @param grade_item $item
     * @param grade_item $item
>      * @return mixed
     * @return grade_category
>      */
     */
>     private function get_item_action_menu(grade_item $item) {
    private function category($item) {
>         global $OUTPUT;
        global $DB;
> 

>         $menuitems = [];
        if (empty($item->categoryid)) {
>         $url = new moodle_url($this->format_link('grade', $item->id));

>         $title = get_string('showallgrades', 'core_grades');
            if ($item->itemtype == 'course') {
>         $menuitems[] = new \action_menu_link_secondary($url, null, $title);
                return $this->course->fullname;
>         $menu = new \action_menu($menuitems);
            }
>         $icon = $OUTPUT->pix_icon('i/moremenu', get_string('actions'));

>         $extraclasses = 'btn btn-link btn-icon icon-size-3 d-flex align-items-center justify-content-center';
            $params = array('id' => $item->iteminstance);
>         $menu->set_menu_trigger($icon, $extraclasses);
            $elem = $DB->get_record('grade_categories', $params);
>         $menu->set_menu_left();

>         $menu->set_boundary('window');
            return $elem->fullname;
> 
        }
>         return $OUTPUT->render($menu);

>     }
        if (!isset($this->categories[$item->categoryid])) {
> 
            $category = $item->get_parent_category();
>     /**



<      * @return grade_category



>      * @return string



<     private function category($item) {



>     private function category(grade_item $item): string {



<             $params = array('id' => $item->iteminstance);



>             $params = ['id' => $item->iteminstance];



        return $this->categories[$item->categoryid]->get_name();
    }

    /**
     * Get the heading for the page.
     *
     * @return string
     */

<     public function heading() {
<         return get_string('gradeuser', 'gradereport_singleview', fullname($this->item));



>     public function heading(): string {
>         global $PAGE;
>         $headinglangstring = $PAGE->user_is_editing() ? 'gradeuseredit' : 'gradeuser';
>         return get_string($headinglangstring, 'gradereport_singleview', fullname($this->item));


    }

    /**
     * Get the summary for this table.
     *
     * @return string
     */

<     public function summary() {



>     public function summary(): string {


        return get_string('summaryuser', 'gradereport_singleview');
    }

    /**
     * Default pager
     *
     * @return string
     */

<     public function pager() {



>     public function pager(): string {


        global $OUTPUT;

        if (!$this->supports_paging()) {
            return '';
        }

        return $OUTPUT->paging_bar(
            count($this->items), $this->page, $this->perpage,

<             new moodle_url('/grade/report/singleview/index.php', array(



>             new moodle_url('/grade/report/singleview/index.php', [


                'perpage' => $this->perpage,
                'id' => $this->courseid,
                'group' => $this->groupid,
                'itemid' => $this->itemid,
                'item' => 'user'

<             ))



>             ])


        );
    }

    /**
     * Does this page require paging?
     *
     * @return bool
     */

<     public function supports_paging() {



>     public function supports_paging(): bool {


        return $this->requirespaging;
    }


    /**
     * Process the data from the form.
     *
     * @param array $data

<      * @return array of warnings



>      * @return stdClass of warnings


     */

<     public function process($data) {



>     public function process($data): stdClass {


        $bulk = new bulk_insert($this->item);
        // Bulk insert messages the data to be passed in
        // ie: for all grades of empty grades apply the specified value.
        if ($bulk->is_applied($data)) {
            $filter = $bulk->get_type($data);
            $insertvalue = $bulk->get_insert_value($data);

            $userid = $this->item->id;
            foreach ($this->items as $gradeitemid => $gradeitem) {
                $null = $gradeitem->gradetype == GRADE_TYPE_SCALE ? -1 : '';
                $field = "finalgrade_{$gradeitem->id}_{$this->itemid}";
                if (isset($data->$field)) {
                    continue;
                }

                $oldfinalgradefield = "oldfinalgrade_{$gradeitem->id}_{$this->itemid}";
                // Bulk grade changes for all grades need to be processed and shouldn't be skipped if they had a previous grade.
                if ($gradeitem->is_course_item() || ($filter != 'all' && !empty($data->$oldfinalgradefield))) {
                    if ($gradeitem->is_course_item()) {
                        // The course total should not be overridden.
                        unset($data->$field);
                        unset($data->oldfinalgradefield);
                        $oldoverride = "oldoverride_{$gradeitem->id}_{$this->itemid}";
                        unset($data->$oldoverride);
                        $oldfeedback = "oldfeedback_{$gradeitem->id}_{$this->itemid}";
                        unset($data->$oldfeedback);
                    }
                    continue;
                }

<                 $grade = grade_grade::fetch(array(



>                 $grade = grade_grade::fetch([


                    'itemid' => $gradeitemid,
                    'userid' => $userid

<                 ));



>                 ]);



                $data->$field = empty($grade) ? $null : $grade->finalgrade;
                $data->{"old$field"} = $data->$field;
            }

            foreach ($data as $varname => $value) {
                if (preg_match('/^oldoverride_(\d+)_(\d+)/', $varname, $matches)) {
                    // If we've selected overriding all grades.
                    if ($filter == 'all') {
                        $override = "override_{$matches[1]}_{$matches[2]}";
                        $data->$override = '1';
                    }
                }
                if (!preg_match('/^finalgrade_(\d+)_(\d+)/', $varname, $matches)) {
                    continue;
                }


<                 $gradeitem = grade_item::fetch(array(



>                 $gradeitem = grade_item::fetch([


                    'courseid' => $this->courseid,

<                     'id' => $matches[1]
<                 ));



>                     'id' => $matches[1],
>                 ]);



                $isscale = ($gradeitem->gradetype == GRADE_TYPE_SCALE);


<                 $empties = (trim($value) === '' or ($isscale and $value == -1));



>                 $empties = (trim($value ?? '') === '' || ($isscale && $value == -1));




<                 if ($filter == 'all' or $empties) {
<                     $data->$varname = ($isscale and empty($insertvalue)) ?
<                         -1 : $insertvalue;



>                 if ($filter == 'all' || $empties) {
>                     $data->$varname = ($isscale && empty($insertvalue)) ? -1 : $insertvalue;


                }
            }
        }
        return parent::process($data);
    }
}