<?php
namespace assignsubmission_dta;
// 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/>.

/**
 * persistence layer utility class
 *
 * @package assignsubmission_dta
 * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 * @copyright Gero Lueckemeyer and student project teams
 */

use assignsubmission_dta\dta_backend_utils;
use assignsubmission_dta\view_submission_utils;
use assignsubmission_dta\models\dta_result;
use assignsubmission_dta\models\dta_result_summary;
use assignsubmission_dta\models\dta_recommendation;
class db_utils {

    /**
     * Summary database table name.
     */
    private const TABLE_SUMMARY = "assignsubmission_dta_summary";
    /**
     * Result database table name.
     */
    private const TABLE_RESULT = "assignsubmission_dta_result";

    private const TABLE_RECOMMENDATIONS = "assignsubmission_dta_recommendations";

    public static function get_recommendations_from_database(int $assignmentid, int $submissionid): array {
        global $DB,$USER;
        $userid = $USER->id;
    
        // Schritt 1: Alle Empfehlungen abrufen
        $records = $DB->get_records(self::TABLE_RECOMMENDATIONS, [
            'assignment_id' => $assignmentid,
            'submission_id' => $submissionid,
        ]);
    
        // Schritt 2: Modul-ID für 'assign' abrufen
        $module = $DB->get_record('modules', ['name' => 'assign'], 'id');
        if (!$module) {
            // Fehlerbehandlung, falls das Modul nicht gefunden wird
            return $records;
        }
        $moduleid = $module->id;
    
        // Schritt 3: Überprüfe jeden Datensatz
        foreach ($records as $key => $record) {
            // Hol den Namen der Übung aus dem Datensatz
            $exercisename = $record->exercise_name;
    
            // Suche das Assignment mit diesem Namen
            $assign = $DB->get_record('assign', ['name' => $exercisename], 'id');
    
            if ($assign) {
                // Hole die Kursmodul-ID (coursemoduleid) für dieses Assignment
                $cm = $DB->get_record('course_modules', [
                    'module' => $moduleid,
                    'instance' => $assign->id
                ], 'id');
    
                if ($cm) {
                    // Überprüfe den Abschlussstatus für dieses Kursmodul und den Benutzer
                    $completion = $DB->get_record('course_modules_completion', [
                        'coursemoduleid' => $cm->id,
                        'userid' => $userid
                    ], 'completionstate');
    
                    // Wenn der Abschlussstatus 1 ist, entferne den Datensatz aus $records
                    if ($completion && $completion->completionstate == 1) {
                        unset($records[$key]);
                        
                    }
                }
            }
        }
    
        // Rückgabe der gefilterten Datensätze
        return $records;
    }
    

    /**
     * gets summary with all corresponding result entries
     *
     * @param int $assignmentid assignment id to search for
     * @param int $submissionid submission id to search for
     * @return DttResultSummary representing given submission
     */
    public static function get_result_summary_from_database(
        int $assignmentid,
        int $submissionid
    ): dta_result_summary {
        global $DB;

        // Fetch data from database.
        $summaryrecord = $DB->get_record(self::TABLE_SUMMARY, [
            "assignment_id" => $assignmentid,
            "submission_id" => $submissionid,
        ]);

        $resultsarray = $DB->get_records(self::TABLE_RESULT, [
            "assignment_id" => $assignmentid,
            "submission_id" => $submissionid,
        ]);

        // Create a summary instance.
        $summary = new dta_result_summary();
        $summary->timestamp = $summaryrecord->timestamp;
        $summary->globalstacktrace = $summaryrecord->global_stacktrace;
        $summary->successfultestcompetencies = $summaryrecord->successful_competencies;
        $summary->overalltestcompetencies = $summaryrecord->tested_competencies;
        $summary->results = [];

        // Create result instances and add to array of summary instance.
        foreach ($resultsarray as $rr) {
            $result = new dta_result();
            $result->packagename = $rr->package_name;
            $result->classname = $rr->class_name;
            $result->name = $rr->name;
            $result->state = $rr->state;
            $result->failuretype = $rr->failure_type;
            $result->failurereason = $rr->failure_reason;
            $result->stacktrace = $rr->stacktrace;
            $result->columnnumber = $rr->column_number;
            $result->linenumber = $rr->line_number;
            $result->position = $rr->position;

            $summary->results[] = $result;
        }

        return $summary;
    }
    public static function store_recommendations_to_database(
        int $assignmentid,
        int $submissionid,
        array $recommendations
    ): void {
        global $DB;
        error_log(print_r($recommendations, true));
    
        // If recommendations already exist, delete old values beforehand.
        $existingrecords = $DB->get_records('assignsubmission_dta_recommendations', [
            'assignment_id' => $assignmentid,
            'submission_id' => $submissionid,
        ]);
    
        if ($existingrecords) {
            $DB->delete_records('assignsubmission_dta_recommendations', [
                'assignment_id' => $assignmentid,
                'submission_id' => $submissionid,
            ]);
        }
    
        // Create new recommendation entries.
        foreach ($recommendations as $recommendation) {
            // Ensure $recommendation is an instance of DtaRecommendation
            if ($recommendation instanceof dta_recommendation) {
                // Add assignment and submission IDs to the recommendation object
                $recommendation->assignment_id = $assignmentid;
                $recommendation->submission_id = $submissionid;
    
                error_log("Insert record");
                error_log(print_r($recommendation, true));
    
                // Insert the recommendation into the database
                $DB->insert_record('assignsubmission_dta_recommendations', $recommendation);
            } else {
                // Handle the case where $recommendation is not a DtaRecommendation instance
                error_log("Invalid recommendation object");
            }
        }
    }
    

    /**
     * save given result summary and single results to database
     * under given assignment and submission id
     *
     * @param int $assignmentid assigment this is submission is linked to
     * @param int $submissionid submission of this result
     * @param dta_result_summary $summary instance to persist
     */
    public static function store_result_summary_to_database(
        int $assignmentid,
        int $submissionid,
        dta_result_summary $summary
    ): void {
        global $DB;

        // Prepare new database entries.
        $summaryrecord = new dta_result_summary();
        $summaryrecord->assignment_id = $assignmentid;
        $summaryrecord->submission_id = $submissionid;
        $summaryrecord->timestamp = $summary->timestamp;
        $summaryrecord->global_stacktrace = $summary->globalstacktrace;
        $summaryrecord->successful_competencies = $summary->successfultestcompetencies;
        $summaryrecord->tested_competencies = $summary->overalltestcompetencies;
        
        // Prepare results to persist to array.
        $resultrecords = [];
        foreach ($summary->results as $r) {
            $record = new dta_result();
            $record->assignment_id = $assignmentid;
            $record->submission_id = $submissionid;
            $record->package_name = $r->packagename;
            $record->class_name = $r->classname;
            $record->name = $r->name;
            $record->state = $r->state;
            $record->failure_type = $r->failuretype;
            $record->failure_reason = $r->failurereason;
            $record->stacktrace = $r->stacktrace;
            $record->column_number = $r->columnnumber;
            $record->line_number = $r->linenumber;
            $record->position = $r->position;
            $resultrecords[] = $record;
        }

        // If results already exist, delete old values beforehand.
        $submission = $DB->get_record(self::TABLE_SUMMARY, [
            'assignment_id' => $assignmentid,
            'submission_id' => $submissionid,
        ]);

        if ($submission) {
            $DB->delete_records(self::TABLE_RESULT, [
                'assignment_id' => $assignmentid,
                'submission_id' => $submissionid,
            ]);

            $DB->delete_records(self::TABLE_SUMMARY, [
                'assignment_id' => $assignmentid,
                'submission_id' => $submissionid,
            ]);
        }

        // Create summary and single result entries.
        $DB->insert_record(self::TABLE_SUMMARY, $summaryrecord);
        foreach ($resultrecords as $rr) {
            $DB->insert_record(self::TABLE_RESULT, $rr);
        }
    }

    /**
     * cleans up database if plugin is uninstalled
     */
    public static function uninstall_plugin_cleaup(): void {
        global $DB;

        $DB->delete_records(self::TABLE_RESULT, null);
        $DB->delete_records(self::TABLE_SUMMARY, null);
        $DB->delete_records(self::TABLE_RECOMMENDATIONS, null);

    }

}