<?php

require_once "OpenEndedTask.php";

require_once "class/LogicFunction.php";

require_once "class/Utils.php";

class TruthTableTask extends PicturedTask
{
    private LogicFunction $lf; // logic functions
    private string $output_variable; // output variable
    public function __construct(array $a = null)
    {
        parent::__construct("truthtable", $a);

        if (isset($a["function"])) { // fetching from a JSON-stored object
            $this->lf = LogicFunction::fromArray($a["function"]);
        } else if (isset($a["expression"], $a["input_variables"])) { // building from the scratch
            $this->lf = new LogicFunction($a["expression"], $a["input_variables"]);
        } else {
            $this->lf = new LogicFunction();
        }

        $this->setOutputVariable($a["output_variable"] ?? "f");
    }

    public function staticCheck(): void
    {
        $ans_tt = $this->player_answer;
        $cans_tt = $this->lf->getTruthTable();
        $errs = 0;
        for ($i = 0; $i < $this->lf->getNStates(); $i++) {
            if (($ans_tt[$i] ?? " ") != $cans_tt[$i]) {
                $errs++;
            }
        }
        $mark = ($errs === 0) ? 1.0 : 0.0;
        $this->setMark($mark);
    }

    public function setOutputVariable(string $ovar): void {
        $this->output_variable = $ovar;
    }

    public function getOutputVariable(): string {
        return $this->output_variable;
    }

    public function setLogicFunction(LogicFunction $lf): void {
        $this->lf = $lf;
    }

    public function getLogicFunction(): LogicFunction {
        return $this->lf;
    }

    public function generateRandomFunction(array $input_vars, int $min_depth, int $max_depth): void {
        $this->lf = LogicFunction::genRandom($input_vars, $min_depth, $max_depth);
    }

    public function generateRandomDF(array $input_vars): void {
        $this->lf = LogicFunction::genRandomDF($input_vars);
    }

    public function getFunctionAsDNF(): string {
        return $this->lf->toDNF();
    }

    public function isValidDNF(): bool {
        return LogicFunction::isCorrectDNF($this->lf->getInputVars(), $this->lf->getExpression());
    }

    public function setLogicFunctionExpr(string $expr, array $input_vars = []): void {
        $this->lf = new LogicFunction($expr, $input_vars);
    }

    public function getLogicFunctionExpr(string $fmt = "verilog_bitwise"): string {
        return $this->lf->getExpression($fmt);
    }

    public function getLogicFunctionDNF(): string {
        return $this->lf->toDNF();
    }

    public function toArray(string $mode = "all"): array
    {
        $a = parent::toArray($mode);

        if ($mode === "all") {
            $a["function"] = $this->lf->toArray();
        }

        $a["correct_answer"] = $this->lf->getTruthTable();
        $a["input_variables"] = $this->lf->getInputVars();
        $a["output_variable"] = $this->output_variable;

        return $a;
    }

    public function randomize(): void
    {
        parent::randomize();

        if ($this->hasFlag("drawnetwork")) {
            $this->setImageData($this->lf->drawNetwork($this->output_variable));
            $this->setImageType("svg");
        }
    }
}