/**
 * EGroupware eTemplate2 - A simple PHP expression parser written in JS
 *
 * @license http://opensource.org/licenses/gpl-license.php GPL - GNU General Public License
 * @package etemplate
 * @subpackage api
 * @link https://www.egroupware.org
 * @author Andreas Stöckel
 * @copyright EGroupware GmbH 2011-2021
 */

/*egw:uses
	et2_core_common;
*/

import {egw} from "../jsapi/egw_global";

/**
 * Function which compiles the given PHP string to a JS function which can be
 * easily executed.
 *
 * @param _expr is the PHP string expression
 * @param _vars is an array with variable names (without the PHP $).
 * 	The parameters have to be passed to the resulting JS function in the same
 * 	order.
 */
export  function et2_compilePHPExpression(_expr, _vars)
{
	if (typeof _vars == "undefined")
	{
		_vars = [];
	}

	try {
		// Initialize the parser object and create the syntax tree for the given
		// expression
		var parser = _php_parser(_expr);

		var syntaxTree = [];

		// Parse the given expression as if it was a double quoted string
		_php_parseDoubleQuoteString(parser, syntaxTree);

		// Transform the generated syntaxTree into a JS string
		var js = _php_compileJSCode(_vars, syntaxTree);

		// Log the successfull compiling
		egw.debug("log", "Compiled PHP " + _expr + " --> " + js);
	}
	catch(e) {
		// if expression does NOT compile use it literally and log a warning, but not stop execution
		egw.debug("warn", "Error compiling PHP "+_expr+" --> using it literally ("+
			(typeof e == 'string' ? e : e.message)+")!");
		return function(){ return _expr; };
	}
	// Prepate the attributes for the function constuctor
	var attrs = [];
	for (var i = 0; i < _vars.length; i++)
	{
		attrs.push("_" + _vars[i]);
	}
	attrs.push(js);

	// Create the function and return it
	return (Function.apply(Function, attrs));
}

const STATE_DEFAULT = 0;
const STATE_ESCAPED = 1;
const STATE_CURLY_BRACE_OPEN = 2;
const STATE_EXPECT_CURLY_BRACE_CLOSE = 3;
const STATE_EXPECT_RECT_BRACE_CLOSE = 4;
const STATE_EXPR_BEGIN = 5;
const STATE_EXPR_END = 6;

function _throwParserErr(_p, _err)
{
	throw("Syntax error while parsing '" + _p.expr + "' at " +
		_p.pos + ", " + _err);
}

function _php_parseDoubleQuoteString(_p, _tree)
{
	// Extract all PHP variables from the string
	var state = STATE_DEFAULT;
	var str = "";

	while (_p.pos < _p.expr.length)
	{
		// Read the current char and then increment the parser position by
		// one
		var c = _p.expr.charAt(_p.pos++);

		switch (state)
		{

			case STATE_DEFAULT:
			case STATE_CURLY_BRACE_OPEN:

				switch (c)
				{
					case '\\':
						state = STATE_ESCAPED;
						break;

					case '$':
						// check for '$$' as used in placeholder syntax, it is NOT expanded and returned as is
						if (_p.expr.charAt(_p.pos) == "$" && state == STATE_DEFAULT)
						{
							_p.pos++;
							str += '$$';
							break;
						}
						// check for '$' as last char, as in PHP "test$" === 'test$', $ as last char is NOT expanded
						if (_p.pos == _p.expr.length)
						{
							str += '$';
							break;
						}
						// check for regular expression "/  $/"
						if (_p.expr.charAt(_p.pos) == '/' && _p.expr.charAt(0) == '/')
						{
							str += '$';
							break;
						}
						if (str)
						{
							_tree.push(str); str = "";
						}

						// Support for the ${[expr] sytax
						if (_p.expr.charAt(_p.pos) == "{" && state != STATE_CURLY_BRACE_OPEN)
						{
							state = STATE_CURLY_BRACE_OPEN;
							_p.pos++;
						}

						if (state == STATE_CURLY_BRACE_OPEN)
						{
							_tree.push(_php_parseVariable(_p));
							state = STATE_EXPECT_CURLY_BRACE_CLOSE;
						}
						else
						{
							_tree.push(_php_parseVariable(_p));
						}

						break;

					case '{':
						state = STATE_CURLY_BRACE_OPEN;
						break;

					default:
						if (state == STATE_CURLY_BRACE_OPEN)
						{
							str += '{';
							state = STATE_DEFAULT;
						}
						str += c;
				}

				break;

			case STATE_ESCAPED:
				str += c;
				break;

			case STATE_EXPECT_CURLY_BRACE_CLOSE:
				// When returning from the variableEx parser,
				// the current char must be a "}"
				if (c != "}")
				{
					_throwParserErr(_p, "expected '}', but got " + c);
				}

				state = STATE_DEFAULT;
				break;
		}
	}

	// Throw an error when reaching the end of the string but expecting
	// "}"
	if (state == STATE_EXPECT_CURLY_BRACE_CLOSE)
	{
		_throwParserErr(_p, "unexpected end of string, expected '}'");
	}

	// Push the last part of the string onto the syntax tree
	if (state == STATE_CURLY_BRACE_OPEN)
	{
		str += "{";
	}

	if (str)
	{
		_tree.push(str);
	}
}

// Regular expression which matches on PHP variable identifiers (without the $)
var PHP_VAR_PREG = /^([A-Za-z0-9_]+)/;

function _php_parseVariableName(_p)
{
	// Extract the variable name form the expression
	var vname = PHP_VAR_PREG.exec(_p.expr.substr(_p.pos));

	if (vname)
	{
		// Increment the parser position by the length of vname
		_p.pos += vname[0].length;
		return {"variable": vname[0], "accessExpressions": []};
	}

	_throwParserErr(_p, "expected variable identifier.");
}

function _php_parseVariable(_p)
{
	// Parse the first variable
	var variable = _php_parseVariableName(_p);

	// Parse all following variable access identifiers
	var state = STATE_DEFAULT;

	while (_p.pos < _p.expr.length)
	{
		var c = _p.expr.charAt(_p.pos++);

		switch (state)
		{
			case STATE_DEFAULT:
				switch (c)
				{
					case "[":
						// Parse the expression inside the rect brace
						variable.accessExpressions.push(_php_parseExpression(_p));
						state = STATE_EXPECT_RECT_BRACE_CLOSE;
						break;

					default:
						_p.pos--;
						return variable;
				}
				break;

			case STATE_EXPECT_RECT_BRACE_CLOSE:
				if (c != "]")
				{
					_throwParserErr(_p, " expected ']', but got " + c);
				}

				state = STATE_DEFAULT;
				break;
		}
	}

	return variable;
}

/**
 * Reads a string delimited by the char _delim or the regExp _delim from the
 * current parser context and returns it.
 *
 * @param {object} _p parser contect
 * @param {string} _delim delimiter
 * @return {string} string read (or throws an exception)
 */
function _php_readString(_p, _delim)
{
	var state = STATE_DEFAULT;
	var str = "";

	while (_p.pos < _p.expr.length)
	{
		var c = _p.expr.charAt(_p.pos++);

		switch (state)
		{

			case STATE_DEFAULT:
				if (c == "\\")
				{
					state = STATE_ESCAPED;
				}
				else if (c === _delim || (typeof _delim != "string" && _delim.test(c)))
				{
					return str;
				}
				else
				{
					str += c;
				}
				break;

			case STATE_ESCAPED:
				str += c;
				state = STATE_DEFAULT;
				break;
		}
	}

	_throwParserErr(_p, "unexpected end of string while parsing string!");
}

function _php_parseExpression(_p)
{
	var state = STATE_EXPR_BEGIN;
	var result : any = null;

	while (_p.pos < _p.expr.length)
	{
		var c = _p.expr.charAt(_p.pos++);

		switch (state)
		{
			case STATE_EXPR_BEGIN:
				switch(c)
				{
					// Skip whitespace
					case " ": case "\n": case "\r": case "\t":
						break;

					case "\"":
						result = [];

						var p = _php_parser(_php_readString(_p, "\""));
						_php_parseDoubleQuoteString(p, result);
						state = STATE_EXPR_END;
						break;
					case "\'":
						result = _php_readString(_p, "'");
						state = STATE_EXPR_END;
						break;
					case "$":
						result = _php_parseVariable(_p);
						state = STATE_EXPR_END;
						break;
					default:
						_p.pos--;
						result = _php_readString(_p, /[^A-Za-z0-9_#]/);

						if (!result)
						{
							_throwParserErr(_p, "unexpected char " + c);
						}

						_p.pos--;
						state = STATE_EXPR_END;
						break;
				}
				break;

			case STATE_EXPR_END:
				switch(c)
				{
					// Skip whitespace
					case " ": case "\n": case "\r": case "\t":
						break;

					default:
						_p.pos--;
						return result;
				}

		}
	}

	_throwParserErr(_p, "unexpected end of string while parsing access expressions!");
}

function _php_parser(_expr)
{
	return {
		expr: _expr,
		pos: 0
	};
}

function _throwCompilerErr(_err)
{
	throw("PHP to JS compiler error, " + _err);
}

function _php_compileVariable(_vars, _variable)
{
	if (_vars.indexOf(_variable.variable) >= 0)
	{
		// Attach a "_" to the variable name as PHP variable names may start
		// with numeric values
		var result = "_" + _variable.variable;

		// Create the access functions
		for (var i = 0; i < _variable.accessExpressions.length; i++)
		{
			result += "[" +
				_php_compileString(_vars, _variable.accessExpressions[i]) +
				"]";
		}

		return '(typeof _'+_variable.variable+' != "undefined" && typeof '+result + '!="undefined" && ' + result + ' != null ? ' + result + ':"")';
	}

	_throwCompilerErr("Variable $" + _variable.variable + " is not defined.");
}

function _php_compileString(_vars, _string)
{
	if (!(_string instanceof Array))
	{
		_string = [_string];
	}

	var parts = [];
	var hasString = false;
	for (var i = 0; i < _string.length; i++)
	{
		var part = _string[i];

		if (typeof part == "string")
		{
			hasString = true;
			// Escape all "'" and "\" chars and add the string to the parts array
			parts.push("'" + part.replace(/\\/g, "\\\\").replace(/'/g, "\\'") + "'");
		}
		else
		{
			parts.push(_php_compileVariable(_vars, part));
		}
	}

	if (!hasString) // Force the result to be of the type string
	{
		parts.push('""');
	}

	return parts.join(" + ");
}

function _php_compileJSCode(_vars, _tree)
{
	// Each tree starts with a "string"
	return "return " + _php_compileString(_vars, _tree) + ";";
}

// Include this code in in order to test the above code
/*(function () {
	var row = 10;
	var row_cont = {"title": "Hello World!"};
	var cont = {10: row_cont};

	function test(_php, _res)
	{
		console.log(
			et2_compilePHPExpression(_php, ["row", "row_cont", "cont"])
				(row, row_cont, cont) === _res);
	}

	test("${row}[title]", "10[title]");
	test("{$row_cont[title]}", "Hello World!");
	test('{$cont["$row"][\'title\']}', "Hello World!");
	test("$row_cont[${row}[title]]");
	test("\\\\", "\\");
	test("", "");
})();*/

