Evaluate.php

<?php
/**
 * Created by PhpStorm.
 * User: crose
 * Date: 1/12/16
 * Time: 4:36 PM
 */

namespace qfq;

use qfq;

require_once(__DIR__ . '/../qfq/store/Store.php');
require_once(__DIR__ . '/../qfq/database/Database.php');
require_once(__DIR__ . '/helper/Support.php');
require_once(__DIR__ . '/helper/OnString.php');
require_once(__DIR__ . '/report/Link.php');

const EVALUATE_DB_INDEX_DEFAULT = 0;
/**
 * Class Evaluate
 * @package qfq
 */
class Evaluate {
    /**
     * @var Store
     */
    private $store = null;

    /**
     * @var Database[]
     */
    private $dbArray = array();

    /**
     * @var Link
     */
    private $link = null;

    private $dbIndex = EVALUATE_DB_INDEX_DEFAULT;
    private $startDelimiter = '';
    private $startDelimiterLength = 0;
    private $endDelimiter = '';
    private $endDelimiterLength = 0;
    private $sqlKeywords = array('SELECT ', 'INSERT ', 'DELETE ', 'UPDATE ', 'SHOW ', 'REPLACE ');
    private $escapeTypeDefault = '';


//    private $debugStack = array();


    /**
     * @param \qfq\Store $store
     * @param Database $db
     * @param string $startDelimiter
     * @param string $endDelimiter
     * @throws CodeException
     * @throws UserFormException
     */
    public function __construct(Store $store, Database $db, $startDelimiter = '{{', $endDelimiter = '}}') {
        $this->store = $store;

        $this->dbArray[EVALUATE_DB_INDEX_DEFAULT] = $db;
        $this->startDelimiter = $startDelimiter;
        $this->startDelimiterLength = strlen($startDelimiter);
        $this->endDelimiter = $endDelimiter;
        $this->endDelimiterLength = strlen($endDelimiter);
        $this->escapeTypeDefault = $this->store->getVar(F_ESCAPE_TYPE_DEFAULT, STORE_SYSTEM);
        if (empty($this->escapeTypeDefault) || $this->escapeTypeDefault == TOKEN_ESCAPE_CONFIG) {
            $this->escapeTypeDefault = $this->store->getVar(SYSTEM_ESCAPE_TYPE_DEFAULT, STORE_SYSTEM);
        }
    }

    /**
     * Evaluate a whole array or an array of arrays.
     *
     * @param       $tokenArray
     * @param array $skip Optional Array with keynames, which will not be evaluated.
     * @param array $debugStack
     *
     * @return array
     * @throws CodeException
     * @throws DbException
     * @throws UserFormException
     * @throws UserReportException
     */
    public function parseArray($tokenArray, array $skip = array(), &$debugStack = array()) {
        $arr = array();

        foreach ($tokenArray as $key => $value) {

            if (array_search($key, $skip) !== false) {
                $arr[$key] = $value;
                continue;
            }

            if (is_array($value)) {
                $arr[] = $this->parseArray($value, $skip);
            } else {
                $value = Support::handleEscapeSpaceComment($value);

                $arr[$key] = $this->parse($value, 0, $debugStack);
            }
        }

        return $arr;
    }

    /**
     * Recursive evaluation of 'line'. Constant string, Variables or SQL Query or all of them. All queries will be
     * fired. In case of an 'INSERT' statement, return the last_insert_id().
     *
     * Token to replace have to be enclosed by '{{' and '}}'
     *
     * @param     $line
     * @param int $recursion
     *
     * @param array $debugStack
     * @param string $foundInStore
     * @return array|mixed|null|string
     * @throws CodeException
     * @throws DbException
     * @throws UserFormException
     * @throws UserReportException
     */
    public function parse($line, $recursion = 0, &$debugStack = array(), &$foundInStore = '') {
        $flagTokenReplaced = false;

        if ($recursion > 4) {
            throw new qfq\UserFormException("Recursion too deep ($recursion). Line: $line", ERROR_RECURSION_TOO_DEEP);
        }

        $result = $line;

        $debugIndent = str_repeat(' ', $recursion);
        $debugLocal[] = $debugIndent . "PARSE: $result";

        $posFirstClose = strpos($result, $this->endDelimiter);

//        $this->store->setVar(SYSTEM_SQL_RAW, $line, STORE_SYSTEM);

        while ($posFirstClose !== false) {

            $posMatchOpen = strrpos(substr($result, 0, $posFirstClose), $this->startDelimiter);
            if ($posMatchOpen === false) {
                throw new UserFormException("Missing open delimiter: $result", ERROR_MISSING_OPEN_DELIMITER);
            }

            $pre = substr($result, 0, $posMatchOpen);
            $post = substr($result, $posFirstClose + $this->endDelimiterLength);
            $match = substr($result, $posMatchOpen + $this->startDelimiterLength, $posFirstClose - $posMatchOpen - $this->startDelimiterLength);

            $evaluated = $this->substitute($match, $foundInStore);

            // newline
            $debugLocal[] = '';

            $debugLocal[] = $debugIndent . "REPLACE: $match";

            if ($foundInStore === '') {

                // Encode the non replaceable part as preparation not to process again. Recode them at the end.
                $evaluated = Support::encryptDoubleCurlyBraces($this->startDelimiter . $match . $this->endDelimiter);
                $debugLocal[] = $debugIndent . "BY: <nothing found - not replaced>";

            } else {

                $flagTokenReplaced = true;

                // If an array is returned, break everything and return this assoc array.
                if (is_array($evaluated)) {
                    $result = $evaluated;
                    $debugLocal[] = $debugIndent . "BY: array(" . count($result) . ")";
                    break;
                }

                $debugLocal[] = $debugIndent . "BY: $evaluated";

                // More to substitute in the new evaluated result? Start recursion just with the new result..
                if (strpos($evaluated, $this->endDelimiter) !== false) {
                    $evaluated = $this->parse($evaluated, $recursion + 1, $debugLocal, $foundInStore);
                }
            }
            $result = $pre . $evaluated . $post;

            $posFirstClose = strpos($result, $this->endDelimiter);
        }

        $result = Support::decryptDoubleCurlyBraces($result);

        if ($flagTokenReplaced === true) {
            $debugLocal[] = $debugIndent . "FINAL: " . is_array($result) ? "array(" . count($result) . ")" : "$result";

            $debugStack = $debugLocal;
        }

        return $result;
    }

    /**
     * Tries to substitute $token.
     * Token might be:
     *   a) a SQL statement to fire
     *   b) fetch from a store. Syntax: 'form', 'form:C', 'form:SC0', 'form:S:alnumx', 'form:F:all:s','form:F:all:s:default'
     *
     * The token have to be _without_ Delimiter '{{' , '}}'
     * If neither a) or b) match, return the token itself.
     *
     * @param string $token
     * @param string $foundInStore Returns the name of the store where $key has been found. If $key is not found,
     *                             return ''.
     *
     * @return array|null|string
     * @throws CodeException
     * @throws DbException
     * @throws UserFormException
     * @throws UserReportException
     */
    public function substitute($token, &$foundInStore = '') {
        $sqlMode = ROW_IMPLODE_ALL;

        $token = trim($token);
        $dbIndex = $this->dbIndex;

        // Check if the $token starts with '[<int>]...' - yes: open the necessary database.
        if (strlen($token) > 2 && $token[0] === '[') {
            if ($token[2] !== ']') {
                throw new UserFormException("Missing token ']' in '$token' on position 3", ERROR_TOKEN_MISSING);
            }
            $dbIndex = $token[1];
            $token = trim(substr($token, 3));

            if (empty($this->dbArray[$dbIndex])) {
                $this->dbArray[$dbIndex] = new Database($dbIndex);
            }
        }

        if ($token === '') {
            return '';
        }

        if ($token[0] === '!') {
            $token = trim(substr($token, 1));
            $sqlMode = ROW_REGULAR;
        }

        // Extract token: check if this is a SQL Statement
        $arrToken = explode(' ', $token);

        // Variable Type 'SQL Statement'
        if (in_array(strtoupper($arrToken[0] . ' '), $this->sqlKeywords)) {
            $foundInStore = TOKEN_FOUND_IN_STORE_QUERY;

            return $this->dbArray[$dbIndex]->sql($token, $sqlMode);
        }

        // Variable Type '... AS LINK'
        $countToken = count($arrToken);
        if ($countToken > 2 && strcasecmp($arrToken[$countToken - 2], 'as') == 0) {

            $type = OnString::stripFirstCharIf('_', $arrToken[$countToken - 1]);

            if (strcasecmp($type, 'link') == 0) {

                $str = OnString::trimQuote(substr($token, 0, strlen($token) - 8));  // strlen('_as_link')=8

                if ($this->link === null) {
                    $this->link = new Link($this->store->getSipInstance(), $dbIndex);
                }

                $foundInStore = TOKEN_FOUND_AS_COLUMN;

                return $this->link->renderLink($str);
            }
        }

        // explode for: <key>:<store priority>:<sanitize class>:<escape>:<default>
        $arrToken = explode(':', $token, 5);
        $arrToken = array_merge($arrToken, [null, null, null, null, null]); // fake isset()

        $escapeTypes = (empty($arrToken[3])) ? $this->escapeTypeDefault : $arrToken[3];

        // search for value in stores
        $value = $this->store->getVar($arrToken[0], $arrToken[1], $arrToken[2], $foundInStore);

        // escape ticks
        if (is_string($value)) {
            // Process all escape requests in the given order.
            for ($ii = 0; $ii < strlen($escapeTypes); $ii++) {
                $escape = $escapeTypes[$ii];
                if ($escape == TOKEN_ESCAPE_CONFIG) {
                    $escape = $this->escapeTypeDefault;
                }
                switch ($escape) {
                    case TOKEN_ESCAPE_SINGLE_TICK:
                        $value = str_replace("'", "\\'", $value);
                        break;
                    case TOKEN_ESCAPE_DOUBLE_TICK:
                        $value = str_replace('"', '\\"', $value);
                        break;
                    case TOKEN_ESCAPE_LDAP_FILTER:
                        $value = Support::ldap_escape($value, null, LDAP_ESCAPE_FILTER);
                        break;
                    case TOKEN_ESCAPE_LDAP_DN:
                        $value = Support::ldap_escape($value, null, LDAP_ESCAPE_DN);
                        break;
                    case TOKEN_ESCAPE_MYSQL:
                        $value = $this->dbArray[$dbIndex]->realEscapeString($value);
                        break;
                    case TOKEN_ESCAPE_NONE: // do nothing
                        break;
                    default:
                        throw new UserFormException("Unknown Escape qualifier: $escape", UNKNOWN_TYPE);
                        break;
                }
            }
        }

        // Not found and a default is given: take the default.
        if ($foundInStore == '' && !empty($arrToken[4])) {
            $foundInStore = TOKEN_FOUND_AS_DEFAULT;
            $value = str_replace('\\:', ':', $arrToken[4]);
        }

        return $value;
    }

    /**
     * @return string
     */
//    public function getDebug() {
//        return '<pre>' . implode("\n", $this->debugStack) . '</pre>';
//    }
}