<?php
namespace assignsubmission_dta\models;

/**
 * Entity class for DTA submission plugin result summary.
 *
 * This class holds:
 * - A timestamp for when the summary was generated.
 * - An optional global stack trace (in case the entire process failed).
 * - A competency profile of how many tests passed for each competency (successfulTestCompetencyProfile).
 * - A competency profile of the total coverage for each competency (overallTestCompetencyProfile).
 * - An array of DTA result objects that detail individual test results.
 */
class dta_result_summary {

    /** @var int Unix timestamp for the summary. */
    public $timestamp;

    /** @var string A global stacktrace if the entire run had a fatal error (optional). */
    public $globalstacktrace;

    /** @var string Semi-colon-separated numbers for competencies actually passed. */
    public $successfultestcompetencies;

    /** @var string Semi-colon-separated numbers for total tested competencies. */
    public $overalltestcompetencies;

    /** @var dta_result[] Array of individual test results. */
    public $results;

    /**
     * Decodes a JSON string into a dta_result_summary object.
     *
     * @param string $jsonstring JSON that includes timestamp, globalstacktrace, competency profiles, and results.
     * @return dta_result_summary
     */
    public static function assignsubmission_dta_decode_json(string $jsonstring): dta_result_summary {
        $response = json_decode($jsonstring);

        $summary = new dta_result_summary();
        $summary->timestamp = $response->timestamp ?? 0;
        $summary->globalstacktrace = $response->globalstacktrace ?? '';

        // If your JSON keys are 'successfulTestCompetencyProfile' and 'overallTestCompetencyProfile':
        $summary->successfultestcompetencies = $response->successfulTestCompetencyProfile ?? '';
        $summary->overalltestcompetencies    = $response->overallTestCompetencyProfile ?? '';

        // Decode the "results" array into an array of dta_result objects.
        if (!empty($response->results) && is_array($response->results)) {
            $summary->results = self::assignsubmission_dta_decode_json_result_array($response->results);
        } else {
            $summary->results = [];
        }

        return $summary;
    }

    /**
     * Helper that transforms a list of JSON objects into an array of dta_result objects.
     *
     * @param array $jsonarray Array of JSON-decoded result objects.
     * @return dta_result[]
     */
    private static function assignsubmission_dta_decode_json_result_array(array $jsonarray): array {
        $ret = [];
        foreach ($jsonarray as $entry) {
            $value = new dta_result();

            $value->packagename   = $entry->packageName     ?? '';
            $value->classname     = $entry->className       ?? '';
            $value->name          = $entry->name            ?? '';
            $value->state         = $entry->state           ?? 0;
            $value->failuretype   = $entry->failureType     ?? '';
            $value->failurereason = $entry->failureReason   ?? '';
            $value->stacktrace    = $entry->stacktrace      ?? '';
            $value->columnnumber  = $entry->columnNumber    ?? 0;
            $value->linenumber    = $entry->lineNumber      ?? 0;
            $value->position      = $entry->position        ?? 0;

            $ret[] = $value;
        }
        return $ret;
    }

    /**
     * Get the total number of results (tests) recorded in this summary.
     *
     * @return int
     */
    public function assignsubmission_dta_result_count(): int {
        return count($this->results);
    }

    /**
     * Generic helper to count how many results have the given $state.
     *
     * States can be:
     *  0 => unknown
     *  1 => success
     *  2 => fail
     *  3 => compilation error
     *
     * @param int $state The numeric state code to match.
     * @return int Number of results with that state.
     */
    public function assignsubmission_dta_state_occurence_count(int $state): int {
        $num = 0;
        foreach ($this->results as $r) {
            if ((int)$r->state === $state) {
                $num++;
            }
        }
        return $num;
    }

    /**
     * Count how many results had compilation errors (state=3).
     *
     * @return int
     */
    public function assignsubmission_dta_compilation_error_count(): int {
        return $this->assignsubmission_dta_state_occurence_count(3);
    }

    /**
     * Count how many results failed (state=2).
     *
     * @return int
     */
    public function assignsubmission_dta_failed_count(): int {
        return $this->assignsubmission_dta_state_occurence_count(2);
    }

    /**
     * Count how many results were successful (state=1).
     *
     * @return int
     */
    public function assignsubmission_dta_successful_count(): int {
        return $this->assignsubmission_dta_state_occurence_count(1);
    }

    /**
     * Count how many results are unknown (state=0).
     *
     * @return int
     */
    public function assignsubmission_dta_unknown_count(): int {
        return $this->assignsubmission_dta_state_occurence_count(0);
    }

    /**
     * Computes the success rate as a percentage of all results (0..100).
     * Note: This includes tests that might have compile errors, unknown states, etc.
     *
     * @return float A floating percentage between 0.0 and 100.0.
     */
    public function assignsubmission_dta_success_rate(): float {
        $count = $this->assignsubmission_dta_result_count();
        if ($count === 0) {
            return 0.0;
        }
        $successful = $this->assignsubmission_dta_successful_count();
        return ($successful / $count) * 100.0;
    }
}