package com.ganteater.ae.processor;

import java.awt.Toolkit;
import java.awt.datatransfer.Clipboard;
import java.awt.datatransfer.DataFlavor;
import java.awt.datatransfer.StringSelection;
import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.StringReader;
import java.io.StringWriter;
import java.io.UnsupportedEncodingException;
import java.net.Inet4Address;
import java.net.InetAddress;
import java.net.NetworkInterface;
import java.net.Socket;
import java.net.SocketException;
import java.net.SocketTimeoutException;
import java.net.URL;
import java.net.URLConnection;
import java.net.UnknownHostException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Base64;
import java.util.Calendar;
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Properties;
import java.util.Random;
import java.util.Set;
import java.util.StringTokenizer;
import java.util.TimeZone;
import java.util.UUID;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

import javax.swing.JOptionPane;
import javax.xml.transform.Source;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.stream.StreamResult;
import javax.xml.transform.stream.StreamSource;

import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.collections.MapUtils;
import org.apache.commons.io.FileUtils;
import org.apache.commons.io.IOUtils;
import org.apache.commons.io.filefilter.IOFileFilter;
import org.apache.commons.io.filefilter.TrueFileFilter;
import org.apache.commons.jexl3.JexlBuilder;
import org.apache.commons.jexl3.JexlContext;
import org.apache.commons.jexl3.JexlEngine;
import org.apache.commons.jexl3.JexlExpression;
import org.apache.commons.jexl3.MapContext;
import org.apache.commons.lang.ArrayUtils;
import org.apache.commons.lang.BooleanUtils;
import org.apache.commons.lang.ObjectUtils;
import org.apache.commons.lang.StringEscapeUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang.math.NumberUtils;
import org.apache.commons.lang3.SystemUtils;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.client.CredentialsProvider;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.HttpRequestBase;
import org.apache.http.client.protocol.HttpClientContext;
import org.apache.http.client.utils.URLEncodedUtils;
import org.apache.http.entity.ByteArrayEntity;
import org.apache.http.impl.client.BasicCredentialsProvider;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.sling.commons.json.JSONArray;
import org.apache.sling.commons.json.JSONException;
import org.apache.sling.commons.json.JSONObject;

import com.ganteater.ae.AEManager;
import com.ganteater.ae.AEWorkspace;
import com.ganteater.ae.ChoiceTaskRunner;
import com.ganteater.ae.CommandException;
import com.ganteater.ae.ILogger;
import com.ganteater.ae.MultiTaskRunDialog;
import com.ganteater.ae.RecipeListener;
import com.ganteater.ae.TaskCancelingException;
import com.ganteater.ae.processor.annotation.CommandDescription;
import com.ganteater.ae.processor.annotation.CommandExamples;
import com.ganteater.ae.util.AEUtils;
import com.ganteater.ae.util.AssertionFailedError;
import com.ganteater.ae.util.NameValuePairImplementation;
import com.ganteater.ae.util.RegexPathFilter;
import com.ganteater.ae.util.TestCase;
import com.ganteater.ae.util.xml.easyparser.EasyParser;
import com.ganteater.ae.util.xml.easyparser.EasyUtils;
import com.ganteater.ae.util.xml.easyparser.Node;
import com.opencsv.CSVReader;

import okhttp3.MediaType;
import okhttp3.OkHttpClient;
import okhttp3.Request.Builder;
import okhttp3.Response;

public class BaseProcessor extends Processor {

        private Random random;

        public BaseProcessor() {
        }

        public BaseProcessor(Processor parent) throws CommandException {
                init(parent);
        }

        public BaseProcessor(AEManager manager, ILogger log, File baseDir) {
                super(manager, log, baseDir);
        }

        public BaseProcessor(Map<String, Object> hashMap, Node node, File baseDir) {
                super(hashMap, node, baseDir);
        }

        public BaseProcessor(Node configNode, Map<String, Object> startVariables, RecipeListener listener, File startDir,
                        ILogger aLog, Processor parent) throws CommandException {
                super(configNode, startVariables, listener, startDir, aLog, parent);
        }

        @CommandExamples({ "<Regexp name='type:property' source='type:property' regex='type:string' group='type:integer'/>",
                        "<Regexp name='type:property' source='type:property' regex='type:string' />" })
        public void runCommandRegexp(final Node action) throws Throwable {
                final String theName = attr(action, "name");
                String regex = replaceProperties(action.getAttribute("regex"));
                int group = Integer.parseInt(attr(action, "group", "0"));
                Object sourceObj = attrValue(action, "source");
                if (sourceObj == null) {
                        throw new IllegalArgumentException("The 'source' value must not be null.");
                }

                if (sourceObj instanceof String) {
                        sourceObj = new String[] { (String) sourceObj };
                }

                Pattern pattern = Pattern.compile(regex);
                List<String> result = new ArrayList<>();
                if (sourceObj instanceof String[]) {
                        String[] sources = (String[]) sourceObj;

                        for (String source : sources) {
                                Matcher matcher = pattern.matcher(source);
                                if (matcher.find()) {
                                        String theText = matcher.group(group);
                                        result.add(theText);
                                }
                        }
                }
                setVariableValue(theName, result);
        }

        @CommandExamples({ "<Replace name='type:property' oldChar='type:integer' newChar='type:integer'/>",
                        "<Replace name='type:property' regex='type:regex' replacement='type:string'/>",
                        "<Replace name='type:property' unescape='enum:java|csv|html|javascript|xml' />",
                        "<Replace name='type:property' escape='enum:java|csv|html|javascript|xml|sql' />" })
        public void runCommandReplace(final Node command) throws Throwable {
                String name = replaceProperties(command.getAttribute("name"));

                Object variableValue = getVariableValue(name);
                String value = null;
                if (variableValue instanceof String) {
                        value = (String) variableValue;
                } else if (variableValue instanceof byte[]) {
                        value = new String((byte[]) variableValue);
                } else {
                        value = ObjectUtils.toString(variableValue);
                }
                value = replaceProperties(value);

                final String theOldChar = replaceProperties(command.getAttribute("oldChar"));
                final String theNewChar = replaceProperties(command.getAttribute("newChar"));
                if (theOldChar != null) {
                        value = value.replace(theOldChar, theNewChar);
                }

                final String regex = replaceProperties(command.getAttribute("regex"));
                final String replacement = replaceProperties(command.getAttribute("replacement"));
                if (regex != null && value != null) {
                        value = value.replaceAll(regex, replacement);
                }

                String unescape = attr(command, "unescape");
                if (unescape != null) {
                        unescape = unescape.toLowerCase();
                        switch (unescape) {
                        case "csv": {
                                value = StringEscapeUtils.unescapeCsv(value);
                                break;
                        }
                        case "html": {
                                value = StringEscapeUtils.unescapeHtml(value);
                                break;
                        }
                        case "java": {
                                value = StringEscapeUtils.unescapeJava(value);
                                break;
                        }
                        case "javascript": {
                                value = StringEscapeUtils.unescapeJavaScript(value);
                                break;
                        }
                        case "xml": {
                                value = StringEscapeUtils.unescapeXml(value);
                                break;
                        }
                        }
                }

                String escape = attr(command, "escape");
                if (escape != null) {
                        escape = escape.toLowerCase();
                        switch (escape) {
                        case "csv": {
                                value = StringEscapeUtils.escapeCsv(value);
                                break;
                        }
                        case "html": {
                                value = StringEscapeUtils.escapeHtml(value);
                                break;
                        }
                        case "java": {
                                value = StringEscapeUtils.escapeJava(value);
                                break;
                        }
                        case "javascript": {
                                value = StringEscapeUtils.escapeJavaScript(value);
                                break;
                        }
                        case "sql": {
                                value = StringEscapeUtils.escapeSql(value);
                                break;
                        }
                        case "xml": {
                                value = StringEscapeUtils.escapeXml(value);
                                break;
                        }
                        }
                }

                setVariableValue(name, value);
        }

        @CommandDescription("The Clipboard command swaps the contents of the system clipboard with the value of the variable specified by the name attribute")
        @CommandExamples({ "<Clipboard name='type:property'/>" })
        public void runCommandClipboard(final Node action) throws Exception {
                String name = action.getAttribute("name");
                Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
                String varValue = null;
                if (name != null) {
                        varValue = String.valueOf(attrValue(action, "name"));

                        String clipboardValue = (String) Toolkit.getDefaultToolkit().getSystemClipboard()
                                        .getData(DataFlavor.stringFlavor);

                        setVariableValue(name, clipboardValue);
                }
                StringSelection stringSelection = new StringSelection(StringUtils.defaultIfEmpty(varValue, StringUtils.EMPTY));
                clipboard.setContents(stringSelection, null);
        }

        @CommandExamples({
                        "<CheckValue actual='type:string' expected='type:string' mode='enum:normal|trimLines' condition='enum:unequal|equal' onErrorMsg='type:string'/>",
                        "<CheckValue value='type:string' regex='type:regex' onErrorMsg='type:string'/>" })
        public void runCommandCheckValue(final Node action) throws Throwable {

                String actual = attr(action, "actual");
                String expected = attr(action, "expected");
                final String errorMsg = replaceProperties(action.getAttribute("onErrorMsg"));

                if (actual != null && expected != null) {

                        final String theRegex = replaceProperties(action.getAttribute("regex"));

                        if (theRegex == null) {
                                final boolean theTrimLines = "trimLines".equals(replaceProperties(action.getAttribute("mode")));
                                try {
                                        if (theTrimLines) {
                                                actual = getTrimmedLines(actual);
                                                expected = getTrimmedLines(expected);
                                        }

                                        final boolean unequal = "unequal".equals(replaceProperties(action.getAttribute("condition")));
                                        if (unequal) {
                                                boolean equals = StringUtils.equals(expected, actual);
                                                TestCase.assertFalse(errorMsg, equals);
                                        } else {
                                                TestCase.assertEquals(errorMsg, expected, actual);
                                        }
                                } catch (final Throwable e) {
                                        taskNode(action, false);
                                        throw e;
                                }
                        } else {
                                final String theValue = replaceProperties(action.getAttribute("value"));
                                final Pattern p = Pattern.compile(theRegex);
                                final Matcher m = p.matcher(theValue);
                                if (m.find() == false) {
                                        taskNode(action, false);
                                        TestCase.fail("Regex validation failed. Regex:" + theRegex + ", value:" + theValue);
                                }
                        }
                } else {
                        throw new AssertionFailedError(errorMsg);
                }

        }

        @CommandExamples({ "<CheckNotNull name='type:property' onErrorMsg='type:string'/>" })
        public void runCommandCheckNotNull(final Node aCurrentAction) throws Throwable {
                final String theName = replaceProperties(aCurrentAction.getAttribute("name"));
                final String theErrorMsg = replaceProperties(aCurrentAction.getAttribute("onErrorMsg"));
                Object theValue = getVariableValue(theName);
                if (theValue != null && theValue instanceof String[] && ((String[]) theValue).length == 0) {
                        theValue = null;
                }
                try {
                        TestCase.assertNotNull(theErrorMsg, theValue);
                } catch (final Throwable e) {
                        taskNode(aCurrentAction, false);
                        throw e;
                }
        }

        @CommandExamples({ "<Choice name='type:property'>" + "<Task name='type:string'>...</Task></Choice>",
                        "<Choice name='type:property' mode='enum:default|table'>" + "<Task name='type:string'>...</Task></Choice>",
                        "<Choice name='type:property' mode='enum:default|table' type='setup'>"
                                        + "<Task name='type:string'/></Choice>",
                        "<Choice name='type:property' mode='enum:default|table' type='call-task'>"
                                        + "<Task name='type:recipe'/></Choice>",
                        "<Choice name='type:property'><Task name='type:string'>...</Task><Started>...</Started></Choice>",
                        "<Choice name='type:property' runAllTaskName='type:string' mode='enum:default|table' type='enum:default|call-task'>"
                                        + "<Task name='type:string'>...</Task><Started>...</Started></Choice>" })
        public void runCommandChoice(final Node aCurrentAction) throws Throwable {

                final String nameOfChoice = replaceProperties(aCurrentAction.getAttribute("name"));
                Object preset = getVariableValue(nameOfChoice);

                String description = replaceProperties(aCurrentAction.getAttribute("description"));

                final String theRunAllTaskName = replaceProperties(aCurrentAction.getAttribute("runAllTaskName"));
                String type = replaceProperties(aCurrentAction.getAttribute("type"));
                final boolean callType = "call-task".equals(type);

                final Map<String, Node> tablesNodes = new LinkedHashMap<>();

                final String theMode = replaceProperties(aCurrentAction.getAttribute("mode"));

                final Node[] taskNodes = aCurrentAction.getNodes("Task");
                for (int i = 0; i < taskNodes.length; i++) {
                        final String name = replaceProperties(taskNodes[i].getAttribute("name"));

                        if ("table".equals(theMode) && name != null && name.equals(theRunAllTaskName)) {
                                continue;
                        }

                        if (!callType || getListener().getManager().getTestPath(name) != null) {
                                tablesNodes.put(name, taskNodes[i]);
                        }
                }

                final String[] names = tablesNodes.keySet().toArray(new String[tablesNodes.size()]);

                debug("Task list: " + nameOfChoice);

                final List<String> activeNodes = new ArrayList<>();

                if ("table".equals(theMode) || "hidden".equals(theMode)) {

                        final String exceptionIgnore = replaceProperties(aCurrentAction.getAttribute("exception"));
                        boolean startsWith = false;
                        if (exceptionIgnore != null) {
                                startsWith = exceptionIgnore.startsWith("ignore");
                        }

                        ChoiceTaskRunner choiceRunner = new ChoiceTaskRunner(nameOfChoice, preset == null);
                        boolean visible = !"hidden".equals(theMode);
                        final MultiTaskRunDialog inputSelectChoice = this.recipeListener.getManager().tasksChoice(choiceRunner,
                                        names, startsWith, preset, this, visible);

                        try {
                                final Iterator<String> selectedTasks = inputSelectChoice.getSelectedTasks();

                                List<String> selectedTaskNames = new ArrayList<>();
                                while (selectedTasks.hasNext()) {
                                        String selectedTask = selectedTasks.next();
                                        activeNodes.add(selectedTask);

                                        selectedTaskNames.add(selectedTask);
                                        inputSelectChoice.begin(selectedTask);

                                        try {
                                                Node action = tablesNodes.get(selectedTask);
                                                startCommandInformation(action);

                                                if (callType) {
                                                        runCommandTask(action);
                                                } else {
                                                        taskNode(action, false);
                                                }
                                                inputSelectChoice.end(selectedTask, true);

                                        } catch (final Throwable e) {
                                                inputSelectChoice.end(selectedTask, false);
                                                if (inputSelectChoice.isExceptionIgnore() == false) {
                                                        throw e;
                                                }
                                        }
                                }

                                if ("setup".equals(type)) {
                                        setVariableValue(nameOfChoice, selectedTaskNames.toArray(new String[selectedTaskNames.size()]));
                                }
                        } finally {
                                inputSelectChoice.done();
                                if (inputSelectChoice.isStarted()) {
                                        Node[] nodes = aCurrentAction.getNodes("Started");
                                        for (Node node : nodes) {
                                                taskNode(node);
                                        }
                                }
                        }

                } else {
                        if (this.recipeListener.getManager() != null) {
                                boolean notifyMe = this.recipeListener.isNotifyMe();
                                description = StringUtils.defaultString(description, nameOfChoice);
                                final String inputSelectChoice = this.recipeListener.getManager().inputChoice(nameOfChoice, description,
                                                names, ObjectUtils.toString(preset, null), this, notifyMe);
                                if (inputSelectChoice != null) {
                                        activeNodes.add(inputSelectChoice);
                                }
                        }

                        debug("Select task: " + (activeNodes != null ? activeNodes : "<not chosen>"));

                        if (!activeNodes.isEmpty()) {
                                if (activeNodes.get(0).equals(theRunAllTaskName) == false) {

                                        if (callType) {
                                                runCommandTask(tablesNodes.get(activeNodes.get(0)));
                                        } else {
                                                taskNode(tablesNodes.get(activeNodes.get(0)));
                                        }

                                } else {
                                        for (int i = 0; i < names.length; i++) {
                                                final String theActiveNode = names[i];
                                                if (theActiveNode.equals(theRunAllTaskName) == false) {
                                                        if (callType) {
                                                                runCommandTask(tablesNodes.get(theActiveNode));
                                                        } else {
                                                                taskNode(tablesNodes.get(theActiveNode));
                                                        }
                                                }
                                        }
                                }
                        }
                }

                setVariableValue(nameOfChoice, activeNodes);
        }

        @CommandExamples({ "<Runnable name='type:property' threadLog='type:boolean'>...code...</Runnable>" })
        public void runCommandRunnable(final Node aCurrentAction) throws CommandException {
                final String theName = replaceProperties(aCurrentAction.getAttribute("name"));
                String theNameThreads = getTestName(aCurrentAction);
                if (theNameThreads == null) {
                        theNameThreads = "Thread";
                }

                boolean threadLog = Boolean.valueOf(StringUtils.defaultIfBlank(attr(aCurrentAction, "threadLog"), "false"));
                ILogger theLog = this.log;
                if (threadLog) {
                        theLog = this.recipeListener.createLog(theNameThreads, false);
                }

                Node task = new Node("Task");
                task.setAttribute("description", aCurrentAction.getAttribute("name"));
                task.addAll(aCurrentAction);
                final TaskProcessorThread runnable = new TaskProcessorThread(this, task, getBaseDir(), theLog);
                setVariableValue(theName, runnable);
        }

        @CommandExamples({ "<Sort name='type:property' type='enum:natural|random' />" })
        public void runCommandSort(final Node aCurrentAction) {
                final String theName = replaceProperties(aCurrentAction.getAttribute("name"));
                String theType = replaceProperties(aCurrentAction.getAttribute("type"));
                if (theType == null) {
                        theType = "natural";
                }

                final Object theObject = getVariableValue(theName);
                if (theObject instanceof String[]) {
                        String[] theArray = (String[]) theObject;
                        if ("natural".equals(theType)) {
                                Arrays.sort(theArray);
                        } else if ("random".equals(theType)) {
                                theArray = randomSort(theArray);
                        } else {
                                throw new IllegalArgumentException("Sort type should be following value: natural, random.");
                        }
                        setVariableValue(theName, theArray);
                }
        }

        @CommandExamples({ "<CheckInArray value='type:string' array='type:property' onErrorMsg='type:string'/>" })
        public void runCommandCheckInArray(final Node aCurrentAction) throws Throwable {
                final String theValue = replaceProperties(aCurrentAction.getAttribute("value"));
                final String theArrayName = replaceProperties(aCurrentAction.getAttribute("array"));
                final String theErrorMsg = replaceProperties(aCurrentAction.getAttribute("onErrorMsg"));
                final Object theObject = checkForArray(getVariableValue(theArrayName));

                if (theObject != null && theObject instanceof Object[]) {
                        final Object[] theValues = (Object[]) theObject;
                        Arrays.sort(theValues);
                        try {
                                TestCase.assertTrue(theErrorMsg, Arrays.binarySearch(theValues, theValue) >= 0);
                        } catch (final Throwable e) {
                                taskNode(aCurrentAction, false);
                                throw e;
                        }
                }
        }

        @CommandDescription("The `Tokenizer` command is used to split a variable by the name specified in the `name` attribute. "
                        + "The variable's value will be split by the delimiter specified in the `delim` attribute. The default separator is the `;` character."
                        + "The result will be an array of strings.")
        @CommandExamples({ "<Tokenizer name='type:property' delim='type:string'/>" })
        public void runCommandTokenizer(final Node aCurrentVar) {
                final Object value = attrValue(aCurrentVar, "name");
                String theDelimAttribut = aCurrentVar.getAttribute("delim");
                if (theDelimAttribut == null) {
                        theDelimAttribut = ";";
                }
                if (value != null) {
                        String theLine = null;
                        if (value instanceof String) {
                                theLine = (String) value;
                        } else if (value instanceof String[] && ((String[]) value).length == 1) {
                                theLine = ((String[]) value)[0];
                        }
                        final ArrayList<String> theArrayList = new ArrayList<String>();
                        if (theLine != null) {
                                final StringTokenizer theStringTokenizer = new StringTokenizer(theLine, theDelimAttribut);
                                while (theStringTokenizer.hasMoreTokens()) {
                                        theArrayList.add(theStringTokenizer.nextToken());
                                }
                                final String[] theArray = new String[theArrayList.size()];
                                for (int i = 0; i < theArrayList.size(); i++) {
                                        if (isStopped()) {
                                                break;
                                        }
                                        theArray[i] = theArrayList.get(i);
                                }
                                setVariableValue(attr(aCurrentVar, "name"), theArray);
                        } else {
                                debug("Tokenized empty string is ignored.");
                        }
                }
        }

        @CommandExamples({ "<Date name='type:string' format='type:string' />",
                        "<Date name='type:string' format='type:string' source='type:property' sformat='type:string' />",
                        "<Date name='type:string' format='type:string' shift='type:time' />" })
        public void runCommandDate(final Node aCurrentAction) throws Throwable {
                final String name = replaceProperties(aCurrentAction.getAttribute("name"));
                String value = replaceProperties(aCurrentAction.getAttribute("value"));
                if (value == null) {
                        String source = aCurrentAction.getAttribute("source");
                        if (source != null) {
                                value = (String) getVariableValue(replaceProperties(source));
                        }
                }

                if (value == null) {
                        Object variableValue = getVariableValue(name);
                        if (variableValue != null) {
                                value = ObjectUtils.toString(variableValue);
                        }
                }

                String format = replaceProperties(aCurrentAction.getAttribute("format"));
                String sformat = StringUtils.defaultString(replaceProperties(aCurrentAction.getAttribute("sformat")), format);

                SimpleDateFormat dateFor = null;
                if (sformat != null && !"ms".equals(sformat)) {
                        dateFor = new SimpleDateFormat(sformat);
                        dateFor.setTimeZone(TimeZone.getTimeZone("UTC"));
                }
                String stringDate = null;
                if (value == null) {
                        if (dateFor != null) {
                                stringDate = dateFor.format(new Date());
                        } else {
                                stringDate = Long.toString(new Date().getTime());
                        }
                        value = stringDate;
                }

                final String shift = replaceProperties(StringUtils.trim(aCurrentAction.getAttribute("shift")));

                Date date;
                if (dateFor != null) {
                        date = dateFor.parse(value);
                } else {
                        date = new Date(Long.parseLong(value));
                }

                if (shift != null) {
                        Calendar c = Calendar.getInstance();
                        c.setTime(date);
                        String substring = StringUtils.substring(shift, 0, shift.length() - 1);
                        int shiftValue = Integer.parseInt(substring);
                        switch (shift.charAt(shift.length() - 1)) {
                        case 's':
                                c.add(Calendar.SECOND, shiftValue);
                                break;
                        case 'm':
                                c.add(Calendar.MINUTE, shiftValue);
                                break;
                        case 'h':
                                c.add(Calendar.HOUR, shiftValue);
                                break;
                        case 'd':
                                c.add(Calendar.DAY_OF_MONTH, shiftValue);
                                break;
                        case 'w':
                                c.add(Calendar.WEEK_OF_MONTH, shiftValue);
                                break;
                        case 'M':
                                c.add(Calendar.MONTH, shiftValue);
                                break;
                        case 'Y':
                                c.add(Calendar.YEAR, shiftValue);
                                break;
                        }

                        date = c.getTime();
                }

                if (format != null && !"ms".equals(format)) {
                        dateFor = new SimpleDateFormat(format);
                        dateFor.setTimeZone(TimeZone.getTimeZone("UTC"));
                        stringDate = dateFor.format(date);
                } else {
                        stringDate = Long.toString(date.getTime());
                }

                setVariableValue(name, stringDate);
        }

        @CommandExamples({ "<Wait delay='type:time'/>", "<Wait/>" })
        public void runCommandWait(final Node aCurrentAction) {
                final long theValue = attrTime(aCurrentAction, "delay", "0");
                if (theValue > 0) {
                        quietWait(theValue);
                } else {
                        pause();
                }
        }

        @CommandDescription("The View command defines a view component to precentation output date provided by Out command.")
        @CommandExamples({ "<View name='type:string' reuse='type:boolean' type='type:view' />" })
        public void runCommandView(final Node aCurrentAction) throws Throwable {
                this.recipeListener.runCommandView(replaceAttributes(aCurrentAction));
        }

        @CommandExamples({ "<Formater name='type:property' type='enum:xml|http-get-request'/>" })
        public void runCommandFormater(final Node aCurrentAction) throws Throwable {
                final String theNameAttribut = replaceProperties(aCurrentAction.getAttribute("name"));
                final String theTypeAttribut = replaceProperties(aCurrentAction.getAttribute("type"));
                Object theValue = getVariableValue(theNameAttribut);
                if (theValue instanceof String) {
                        if ("json".equals(theTypeAttribut)) {
                                theValue = AEUtils.format(ObjectUtils.toString(theValue));
                        } else {
                                theValue = new String[] { (String) theValue };
                        }

                        setVariableValue(theNameAttribut, theValue);
                }
                if (theValue instanceof String[]) {
                        final String[] theValueArray = (String[]) theValue;
                        for (int i = 0; i < theValueArray.length; i++) {
                                if (isStopped()) {
                                        break;
                                }
                                if ("xml".equals(theTypeAttribut)) {
                                        final EasyParser theParser = new EasyParser();
                                        String theCurrentValue = theValueArray[i];
                                        theCurrentValue = prepareXml(theCurrentValue);
                                        final Node object = theParser.getObject(theCurrentValue);
                                        theValueArray[i] = object.getXMLText();
                                }
                        }
                        if (theValueArray.length > 2) {
                                setVariableValue(theNameAttribut, theValueArray);
                        } else if (theValueArray.length == 1) {
                                setVariableValue(theNameAttribut, theValueArray[0]);
                        } else {
                                setVariableValue(theNameAttribut, null);
                        }
                }
        }

        @CommandExamples({ "<Trim name='type:property'/>" })
        public void runCommandTrim(final Node aCurrentAction) throws Throwable {
                String name = replaceProperties(aCurrentAction.getAttribute("name"));
                Object value = getVariableValue(name);
                if (value instanceof String) {
                        value = StringUtils.trimToNull(ObjectUtils.toString(value));
                } else if (value instanceof String[]) {
                        String[] array = (String[]) value;
                        if (array.length == 0) {
                                value = null;
                        } else {
                                List<String> list = new ArrayList<>();
                                for (String object : array) {
                                        String val = ObjectUtils.toString(object);
                                        if (StringUtils.isNotBlank(val)) {
                                                list.add(object);
                                        }
                                }
                                value = list.toArray(new String[list.size()]);
                        }
                } else if (value instanceof List) {
                        @SuppressWarnings("unchecked")
                        List<String> array = (List<String>) value;
                        if (array.size() == 0) {
                                value = null;
                        } else {
                                List<String> list = new ArrayList<>();
                                for (String object : array) {
                                        String val = ObjectUtils.toString(object);
                                        if (StringUtils.isNotBlank(val)) {
                                                list.add(object);
                                        }
                                }
                                value = list.toArray(new String[list.size()]);
                        }
                }
                applyResult(aCurrentAction, name, value);
        }

        @CommandExamples({ "<Xslt name='type:property' xml='type:property' xsl='type:property'/>" })
        public void runCommandXslt(final Node aCurrentAction) throws Throwable {
                final String theNameAttribut = attr(aCurrentAction, "name");
                final String theXmlAttribut = ObjectUtils.toString(attrValue(aCurrentAction, "xml"));
                final String theXslAttribut = ObjectUtils.toString(attrValue(aCurrentAction, "xsl"));
                final StringWriter theStringWriter = new StringWriter();

                if (theXmlAttribut == null || theXmlAttribut.trim().length() == 0 || "null".equals(theXmlAttribut)) {
                        debug("Xml document is empty, transform disable.");
                        return;
                }

                if (theXslAttribut == null || theXslAttribut.trim().length() == 0 || "null".equals(theXslAttribut)) {
                        debug("Xsl document is empty, transform disable.");
                        return;
                }

                try {
                        final Source xslSource = new StreamSource(new StringReader(theXslAttribut));
                        final Transformer transformer = TransformerFactory.newInstance().newTransformer(xslSource);
                        final Source xmlSource = new StreamSource(new StringReader(theXmlAttribut));

                        transformer.transform(xmlSource, new StreamResult(theStringWriter));

                } catch (final Throwable e) {
                        debug("XML Data to transformation:\n" + theXmlAttribut);
                        debug("XSL:\n" + theXslAttribut);
                        this.log.error("Xsl transformation is failed.", e);
                        throw e;
                }

                setVariableValue(theNameAttribut, theStringWriter.toString());
        }

        @CommandDescription("`Out` command use for output a variable value or text.\r\n"
                        + "- to output the value of a variable, you must use the `name` attribute with the name of the variable. "
                        + "- to output text, you should use inner text.\r\n"
                        + "- `level` attribute defines log level, default log level = `info`\r\n"
                        + "- `type` attribute sets type for log view.\r\n"
                        + "- `file` attribute is used for output data in the file.\r\n"
                        + "`Out` command can be used for output information to the special output view, for this need to use an optional `view` "
                        + "attribute with a view name. The view should be defined by the `View` command.")
        @CommandExamples({ "<Out name='type:property' />", "<Out view='type:string'> ... </Out>",
                        "<Out name='type:property' type='enum:txt|html|xml|json|~json|url|path|uri|csv'/>",
                        "<Out view='type:string'>...</Out>", "<Out name='type:property' level='enum:info|debug|warn|error'/>",
                        "<Out name='type:property' level='enum:info|debug|warn|error'> ... </Out>",
                        "<Out level='enum:info|debug|warn|error'>... $var{...} ... </Out>",
                        "<Out file='type:path' append='enum:true|false' encoding='UTF-8'/>" })
        public void runCommandOut(final Node command) throws UnsupportedEncodingException, IOException {
                final String name = attr(command, "name");
                final String description = attr(command, "description");
                String theOutFileNameAttribut = attr(command, "file");

                String logLevel = command.getAttribute("level");
                logLevel = replaceProperties(logLevel);

                if (logLevel == null) {
                        logLevel = StringUtils.defaultIfBlank(getVariableString(DEFAULT_LOG_LEVEL_NAME), "info");
                }

                String type = attr(command, "type");

                FileOutputStream theFileOutputStream = null;
                try {
                        if (theOutFileNameAttribut != null) {
                                String theAppendAttribut = replaceProperties(command.getAttribute("append"));
                                if (theAppendAttribut == null) {
                                        theAppendAttribut = "true";
                                }
                                theOutFileNameAttribut = replaceProperties(theOutFileNameAttribut);
                                final File file = getFile(theOutFileNameAttribut);
                                file.getParentFile().mkdirs();
                                theFileOutputStream = new FileOutputStream(file, "true".equals(theAppendAttribut));
                        }
                        String theEncoding = replaceProperties(command.getAttribute("encoding"));
                        if (theEncoding == null) {
                                theEncoding = "UTF-8";
                        }

                        String theTextOut = null;
                        String varName = name;
                        final Node[] nodes = command.getTextNodes();

                        if (nodes.length > 0) {
                                Node node = nodes[0];
                                theTextOut = replaceProperties(node.getText());
                        } else if (command.size() > 0) {
                                String innerXMLText = command.getInnerXMLText();
                                Node node = new EasyParser().getObject(innerXMLText);
                                EasyUtils.removeTagId(node);
                                theTextOut = replaceProperties(node.toString());
                        }

                        if (theTextOut != null) {
                                if (name != null) {
                                        varName = theTextOut + ": " + varName;
                                }
                                if (theFileOutputStream != null) {
                                        theFileOutputStream.write(theTextOut.getBytes(theEncoding));
                                }

                                Properties attributes = replaceAttributes(command);
                                this.recipeListener.outToView(this, attributes, theTextOut);
                        }

                        if (name != null) {
                                Object theValue = getVariableValue(name);

                                if (theValue instanceof byte[]) {
                                        if (theFileOutputStream != null) {
                                                final byte[] value = (byte[]) theValue;
                                                theFileOutputStream.write(value);
                                                theFileOutputStream.close();
                                                return;
                                        } else {
                                                outputLog(StringUtils.defaultIfEmpty(description, varName), logLevel, theValue, type);
                                                return;
                                        }
                                }

                                if (theValue == null) {
                                        outputLog(StringUtils.defaultIfEmpty(description, varName), logLevel, null, type);

                                } else if (theValue instanceof String) {
                                        if (theFileOutputStream == null) {
                                                outputLog(StringUtils.defaultIfEmpty(description, varName), logLevel, theValue.toString(),
                                                                type);
                                        } else {
                                                theFileOutputStream.write(theValue.toString().getBytes(theEncoding));
                                        }

                                        this.recipeListener.outToView(this, replaceAttributes(command), theValue);

                                } else if (theValue instanceof String[]) {
                                        final StringBuffer theBuffer = new StringBuffer();

                                        final String[] theValueArray = (String[]) theValue;
                                        for (int i = 0; i < theValueArray.length; i++) {
                                                if (isStopped()) {
                                                        break;
                                                }

                                                if (theBuffer.length() > 0) {
                                                        theBuffer.append("\n");
                                                }
                                                theBuffer.append(theValueArray[i]);

                                                Properties params = replaceAttributes(command);
                                                String msg = theValueArray[i];
                                                this.recipeListener.outToView(this, params, msg);
                                        }
                                        if (theFileOutputStream == null) {
                                                outputLog(StringUtils.defaultIfEmpty(description, varName), logLevel, theBuffer.toString(),
                                                                type);
                                        } else {
                                                theFileOutputStream.write(theBuffer.toString().getBytes(theEncoding));
                                        }
                                } else {
                                        outputLog(StringUtils.defaultIfEmpty(description, varName), logLevel, theValue, type);
                                        this.recipeListener.outToView(this, replaceAttributes(command), theValue);
                                }
                        } else {
                                outputLog(StringUtils.defaultIfEmpty(description, varName), logLevel, theTextOut, type);
                        }
                } finally {
                        if (theFileOutputStream != null) {
                                theFileOutputStream.flush();
                                theFileOutputStream.close();
                        }
                }
        }

        @CommandDescription("The <About> information tag (non-executable) is used to display detailed information about a recipe. "
                        + "This tag includes a <description> element, which provides a description of the recipe. "
                        + "The description can be written in plain text or in Markdown format and displayed as additional information on the menu page. "
                        + "In Markdown format, avoid indenting text lines to properly recognize the description type. "
                        + "Each text line must be properly formatted and less than 120 characters long.")
        @CommandExamples({ "<About><description>...</description></About>",
                        "<About><attach><file name='type:url|path' /></attach></About>",
                        "<About><author name='type:string' email='type:string' messager='type:string' phone='type:string'/>"
                                        + "<attach><file name='type:url|path' width='type:number' height='type:number'/></attach></About>" })
        public void runCommandAbout(final Node aCurrentAction) throws Throwable {
        }

        @CommandExamples({ "<Exist name='type:property' text='type:string' value='type:string'/>",
                        "<Exist name='type:property' array='type:property' value='type:string'/>" })
        public void runCommandExist(final Node aCurrentAction) throws Throwable {
                final String theName = replaceProperties(aCurrentAction.getAttribute("name"));
                final String theText = replaceProperties(aCurrentAction.getAttribute("text"));
                final String theArrayName = replaceProperties(aCurrentAction.getAttribute("array"));
                final String theValue = replaceProperties(aCurrentAction.getAttribute("value"));

                if (theArrayName != null) {
                        final Object variableValue = getVariableValue(theArrayName);
                        if (variableValue instanceof String[]) {
                                final String[] variableValueArray = (String[]) variableValue;
                                for (int i = 0; i < variableValueArray.length; i++) {
                                        if (theValue.equals(variableValueArray[i])) {
                                                setVariableValue(theName, "true");
                                                return;
                                        }
                                }
                        }

                        if (variableValue instanceof String) {
                                final String value = (String) variableValue;
                                if (theValue.equals(value)) {
                                        setVariableValue(theName, "true");
                                        return;
                                }
                        }
                        setVariableValue(theName, "false");
                } else {
                        if (theText == null || theValue == null || theName == null) {
                                return;
                        }
                        final int indexOf = theText.indexOf(theValue);
                        setVariableValue(theName, indexOf >= 0 ? "true" : "false");
                }
        }

        @CommandExamples({ "<Load name='type:property' init='console'/>",
                        "<Load name='type:property' init='console'/>...</Load>", "<Load name='type:property' file='type:path'/>",
                        "<Load name='type:property' file='type:path' timeout='type:time' mode='enum:default|noreplace|escapeJS|bytes'/>",
                        "<Load name='type:property' url='type:url' timeout='type:time' mode='enum:default|noreplace|escapeJS|bytes'/>" })
        public void runCommandLoad(final Node action) throws Throwable {
                final boolean noreplace = "noreplace".equals(action.getAttribute("mode"));
                final boolean isArray = "array".equals(action.getAttribute("mode"));
                final boolean defaultMode = "default".equals(action.getAttribute("mode"));
                final boolean escapeJSValue = "escapeJS".equals(action.getAttribute("mode"));
                final boolean bytes = "bytes".equals(action.getAttribute("mode"));
                final boolean base64 = "base64".equals(action.getAttribute("mode"));

                String theEncoding = replaceProperties(action.getAttribute("encoding"));
                if (theEncoding == null) {
                        theEncoding = "UTF-8";
                }

                final String name = replaceProperties(action.getAttribute("name"));
                int timeout = (int) attrTime(action, "timeout", "0");

                final String theUrl = replaceProperties(action.getAttribute("url"));
                if (theUrl != null) {
                        URL url = new URL(theUrl);
                        long startTime = System.currentTimeMillis();
                        while (timeout == 0 || System.currentTimeMillis() < startTime + timeout) {
                                if (isStopped()) {
                                        break;
                                }
                                try {
                                        URLConnection openConnection = url.openConnection();
                                        openConnection.setReadTimeout(timeout);
                                        byte[] byteArray = IOUtils.toByteArray(openConnection.getInputStream());
                                        if (escapeJSValue) {
                                                String data = StringEscapeUtils.escapeJavaScript(new String(byteArray));
                                                setVariableValue(name, data);
                                        } else {
                                                setVariableValue(name, new String(byteArray, theEncoding));
                                        }
                                        return;

                                } catch (IOException e) {
                                        if (timeout == 0) {
                                                throw e;
                                        }
                                        quietWait(200);
                                }
                        }
                }

                String filePath = (String) attr(action, "file");
                final boolean theDialog = isActiveInitFor(action, "console");

                if (theDialog) {
                        File theFile = null;
                        if (filePath != null) {
                                theFile = getFile(filePath);
                        }
                        filePath = this.recipeListener.getManager().inputFile(name, null, theFile, log, this);
                }

                if (filePath != null) {
                        if (base64 || bytes) {
                                File file = getFile(filePath);
                                debug("Loading file: " + file);
                                if (file.exists()) {
                                        try (FileInputStream input = new FileInputStream(file)) {
                                                Object byteArray = IOUtils.toByteArray(input);
                                                if (base64) {
                                                        byteArray = Base64.getEncoder().encodeToString((byte[]) byteArray);
                                                }
                                                setVariableValue(name, byteArray);
                                        }
                                } else {
                                        throw new FileNotFoundException(file.getAbsolutePath());
                                }
                                return;
                        }

                        int iterations = timeout / 1000;
                        if (iterations == 0) {
                                iterations = 1;
                        }
                        for (int i = 0; i < iterations; i++) {
                                if (isStopped()) {
                                        break;
                                }
                                try {

                                        if (!action.isEmpty()) {
                                                File file = getFile(filePath);
                                                try (BufferedReader reader = new BufferedReader(new FileReader(file))) {
                                                        String line;
                                                        while ((line = reader.readLine()) != null) {
                                                                if (this.breakFlag > 0) {
                                                                        break;
                                                                }
                                                                setVariableValue(name, line);
                                                                taskNode(action, false);
                                                        }
                                                } finally {
                                                        if (this.breakFlag > 0) {
                                                                breakFlag--;
                                                        }
                                                }

                                        } else {

                                                String text = AEUtils.loadResource(filePath, getBaseDir(), theEncoding);
                                                if (!noreplace) {
                                                        text = replaceProperties(text, defaultMode);
                                                }

                                                if (escapeJSValue) {
                                                        String data = StringEscapeUtils.escapeJavaScript(text);
                                                        setVariableValue(name, data);
                                                } else {
                                                        Object val = text;
                                                        if (isArray) {
                                                                val = StringUtils.split(text, "\n\r");
                                                        }

                                                        setVariableValue(name, val);
                                                }
                                        }

                                        break;

                                } catch (final FileNotFoundException e) {
                                        if (timeout == 0) {
                                                throw e;
                                        }
                                        quietWait(1000);
                                } catch (final Exception e) {
                                        throw e;
                                }
                        }
                } else {
                        if (isActiveInitFor(action, "mandatory")) {
                                stop();
                        }
                }

        }

        @CommandExamples({ "<Remove name='type:property'/>", "<Remove file='type:path'/>",
                        "<Remove name='type:property' history='type:boolean'/>" })
        public void runCommandRemove(final Node aCurrentAction) throws Throwable {
                String theFileName = aCurrentAction.getAttribute("file");
                if (theFileName != null) {
                        theFileName = replaceProperties(theFileName);
                        final File theFile = getFile(theFileName);
                        if (theFile.isDirectory()) {
                                FileUtils.deleteDirectory(theFile);
                        } else {
                                if (theFile.delete() == false) {
                                        new Exception("File '" + theFile.getAbsolutePath() + "' is not deleted.");
                                }
                        }
                }
                String theVarName = aCurrentAction.getAttribute("name");
                if (theVarName != null) {
                        theVarName = replaceProperties(theVarName);
                        setVariableValue(theVarName, null);
                        if (Boolean.parseBoolean((attr(aCurrentAction, "history")))) {
                                AEWorkspace.getInstance().setDefaultUserConfiguration(".inputValue." + theVarName, null);
                        }
                }
        }

        @CommandDescription("Load the web page by `url`. The response is stored in the variable defined by the `name` attribute.\r\n"
                        + "The optional `auth` attribute set the 'Authorization' header of request.")
        @CommandExamples({ "<Get name='type:property' url='type:url' /> ",
                        "<Get name='type:property' url='type:url' timeout='type:time'/> ",
                        "<Get name='type:property' url='type:url' auth='type:string' mediaType='type:string' retries='1' timeout='type:time'/> " })
        public void runCommandGet(final Node action) throws Throwable {

                String mediaTypeStr = attr(action, "mediaType");
                mediaTypeStr = StringUtils.defaultIfEmpty(mediaTypeStr, "application/json");

                String url = attr(action, "url");
                String auth = attr(action, "auth");
                int retries = Integer.parseInt(attr(action, "retries", "1"));

                Builder builder = new okhttp3.Request.Builder().url(url).get();

                if (mediaTypeStr != null) {
                        builder.addHeader("Content-Type", mediaTypeStr);
                }
                if (auth != null) {
                        builder.addHeader("Authorization", auth);
                }

                okhttp3.Request request = builder.build();

                for (int i = 0; i < retries; i++) {
                        if (isStopped()) {
                                break;
                        }

                        try {
                                okhttp3.OkHttpClient.Builder newBuilder = new OkHttpClient().newBuilder();
                                long timeout = attrTime(action, "timeout", "0");
                                if (timeout > 0) {
                                        newBuilder.connectTimeout(timeout, TimeUnit.MILLISECONDS);
                                        newBuilder.readTimeout(timeout, TimeUnit.MILLISECONDS);
                                        newBuilder.writeTimeout(timeout, TimeUnit.MILLISECONDS);
                                }
                                OkHttpClient client = newBuilder.build();

                                try (Response response = client.newCall(request).execute()) {
                                        String value = new String(response.body().bytes(), "UTF-8");
                                        String name = attr(action, "name");
                                        if (name != null) {
                                                setVariableValue(name, value);
                                        }
                                }

                                break;
                        } catch (SocketTimeoutException e) {
                                if (i == 2) {
                                        throw e;
                                }
                        }
                }
        }

        @CommandDescription("Post the body defined by the `body` attribute to `url`. "
                        + "The response is stored in the variable defined by the `name` attribute. "
                        + "If the body is not simple, you should create a special variable and pass its value via $var{}.\r\n"
                        + "The optional `auth` attribute set the 'Authorization' header of request.")
        @CommandExamples({ "<Post name='type:property' url='type:url' body='type:string'/> ",
                        "<Post name='type:property' url='type:url' body='type:string' timeout='type:time'/> ",
                        "<Post name='type:property' url='type:url' auth='type:string' body='type:string' mediaType='type:string' timeout='type:time'/> " })
        public void runCommandPost(final Node aCurrentAction) throws Throwable {
                String mediaTypeStr = attr(aCurrentAction, "mediaType");
                mediaTypeStr = StringUtils.defaultIfEmpty(mediaTypeStr, "application/json");

                String url = attr(aCurrentAction, "url");
                String auth = attr(aCurrentAction, "auth");
                String bodyStr = StringUtils.defaultIfEmpty(replaceProperties(aCurrentAction.getAttribute("body")), "");

                MediaType mediaType = MediaType.parse(mediaTypeStr);
                okhttp3.RequestBody body = okhttp3.RequestBody.create(mediaType, bodyStr);

                Builder addHeader = new okhttp3.Request.Builder().url(url).method("POST", body).addHeader("Content-Type",
                                mediaTypeStr);
                if (auth != null) {
                        addHeader = addHeader.addHeader("Authorization", auth);
                }
                okhttp3.Request request = addHeader.addHeader("Accept", "*/*").build();
                okhttp3.OkHttpClient.Builder newBuilder = new OkHttpClient().newBuilder();

                long timeout = attrTime(aCurrentAction, "timeout", "0");
                if (timeout > 0) {
                        newBuilder.connectTimeout(timeout, TimeUnit.MILLISECONDS);
                        newBuilder.readTimeout(timeout, TimeUnit.MILLISECONDS);
                        newBuilder.writeTimeout(timeout, TimeUnit.MILLISECONDS);
                }
                OkHttpClient client = newBuilder.build();
                try (Response response = client.newCall(request).execute()) {
                        String value = new String(response.body().bytes(), "UTF-8");

//      if(response.code() == 404) {
//              
//      }

                        String name = attr(aCurrentAction, "name");
                        if (name != null) {
                                setVariableValue(name, value);
                        }
                }
        }

        @CommandDescription("This method allows you to send either HTTP(S) requests or raw socket messages, "
                        + "with support for parameters, headers, authentication, and response handling."
                        + "The `Request` command executes a network request based on the configuration attributes:\r\n"
                        + "- `method`: Specifies the type of network request to perform. Common values are `get` for HTTP GET requests, "
                        + "`post` for HTTP POST requests, or `socket` for raw socket communication.\r\n"
                        + "- `request`: is the name of the request map variable which contains the data to be sent with the request. "
                        + "For HTTP requests, this may include the body and headers. For socket communication, "
                        + "it can be a string or byte array representing the message to send. \r\n"
                        + "- `response` is the name of the variable where the response data will be stored after the request is executed. "
                        + "This allows later access to the result of the network operation.\r\n"
                        + "- `host` is the target URL or host address for the network request. "
                        + "For HTTP(S), this is the full URL. For socket communication, "
                        + "it is typically in the format `hostname:port`\r\n"
                        + "- `timeout` is the maximum time to wait for the network request to complete before aborting.\r\n"
                        + "- `userName` is the username used for HTTP Basic Authentication, if required by the target server.\r\n"
                        + "- `password` is the password used for HTTP Basic Authentication, paired with `userName`.\r\n")
        @CommandExamples({
                        "<Request method='enum:socket|get|post' request='type:property[Map{header;body}]' "
                                        + "response='type:property[Map{status;body}]' host='type:url' timeout='type:time'/>",
                        "<Request method='get' response='type:property[Map{status;body}]' host='type:url' "
                                        + "userName='type:string' password='type:string'><param name='type:string' value='type:string'/></Request>" })
        public void runCommandRequest(final Node aCurrentAction) throws Throwable {
                Object request = attrValue(aCurrentAction, "request");
                final String responseName = attr(aCurrentAction, "response");
                final String method = StringUtils.defaultIfEmpty(attr(aCurrentAction, "method"), "socket");
                String theUrl = attr(aCurrentAction, "host");

                String userName = attr(aCurrentAction, "userName");
                String password = attr(aCurrentAction, "password");
                HttpClientContext localContext = null;
                if (userName != null && password != null) {
                        CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
                        credentialsProvider.setCredentials(AuthScope.ANY,
                                        new UsernamePasswordCredentials(userName + ":" + password));
                        localContext = HttpClientContext.create();
                        localContext.setCredentialsProvider(credentialsProvider);
                }

                HttpRequestBase httpRequest = null;

                final Node[] paramNodes = aCurrentAction.getNodes("param");
                if (paramNodes != null && paramNodes.length > 0) {
                        List<NameValuePairImplementation> parameters = new ArrayList<>();
                        for (Node node : paramNodes) {
                                String name = attr(node, "name");
                                String value = attr(node, "value");

                                NameValuePairImplementation nameValuePair = new NameValuePairImplementation(name, value);
                                parameters.add(nameValuePair);
                        }

                        String query = URLEncodedUtils.format(parameters, "UTF-8");
                        theUrl = theUrl + "?" + query;
                }

                if (theUrl.toLowerCase().startsWith("http")) {
                        if ("get".equalsIgnoreCase(method)) {
                                httpRequest = new HttpGet(theUrl);

                        } else if ("post".equalsIgnoreCase(method)) {
                                HttpPost httpPost = new HttpPost(theUrl);
                                if (request != null) {
                                        @SuppressWarnings("unchecked")
                                        final Map<String, Object> requestMap = (Map<String, Object>) request;
                                        Object bodyObject = requestMap.get("body");
                                        byte[] body = null;
                                        if (bodyObject instanceof byte[]) {
                                                body = (byte[]) bodyObject;
                                        } else if (bodyObject instanceof String) {
                                                body = ((String) bodyObject).getBytes();
                                        }
                                        httpPost.setEntity(new ByteArrayEntity(body));
                                }
                                httpRequest = httpPost;

                        }
                        int timeout = (int) attrTime(aCurrentAction, "timeout", "5000");

                        RequestConfig config = RequestConfig.custom().setConnectTimeout(timeout)
                                        .setConnectionRequestTimeout(timeout).setSocketTimeout(timeout).build();
                        httpRequest.setConfig(config);
                        if (request != null) {
                                @SuppressWarnings("unchecked")
                                Object headerObj = ((Map<String, Object>) request).get("header");
                                if (headerObj instanceof Map) {
                                        @SuppressWarnings("unchecked")
                                        Map<String, String> header = (Map<String, String>) headerObj;
                                        if (header != null) {
                                                Set<Entry<String, String>> entrySet = header.entrySet();
                                                for (Entry<String, String> entry : entrySet) {
                                                        httpRequest.setHeader(entry.getKey(), entry.getValue());
                                                }
                                        }
                                } else {
                                        String header = String.valueOf(headerObj);
                                        httpRequest.setHeader(StringUtils.substringBefore(header, ":").trim(),
                                                        StringUtils.substringAfter(header, ":").trim());
                                }
                        }

                        CloseableHttpResponse response;
                        CloseableHttpClient httpclient = HttpClients.createDefault();

                        long duration = System.currentTimeMillis();
                        if (localContext == null) {
                                response = httpclient.execute(httpRequest);
                        } else {
                                response = httpclient.execute(httpRequest, localContext);
                        }
                        ByteArrayOutputStream body = new ByteArrayOutputStream();
                        response.getEntity().writeTo(body);

                        HashMap<String, Object> aValue = new HashMap<String, Object>();
                        aValue.put("body", body.toByteArray());
                        aValue.put("status", response.getStatusLine().getStatusCode());
                        aValue.put("header", response.getAllHeaders());
                        aValue.put("duration", Long.toString(System.currentTimeMillis() - duration));
                        setVariableValue(responseName, aValue);

                } else {

                        Socket socket = null;
                        try {
                                String host = StringUtils.substringBefore(theUrl, ":");
                                int port = Integer.parseInt(StringUtils.defaultIfBlank(StringUtils.substringAfter(theUrl, ":"), "80"));
                                socket = new Socket(host, port);
                                OutputStream outputStream = socket.getOutputStream();
                                if (request instanceof byte[]) {
                                        IOUtils.write((byte[]) request, outputStream);
                                } else if (request instanceof String) {
                                        IOUtils.write(((String) request).getBytes(), outputStream);
                                }
                                InputStream inputStream = socket.getInputStream();
                                byte[] response = IOUtils.toByteArray(inputStream);
                                setVariableValue(responseName, response);
                        } finally {
                                if (socket != null) {
                                        socket.close();
                                }
                        }

                }

        }

        @CommandExamples({ "<Table name='The table of variables'><var name='type:property' value='type:string'/></Table>",
                        "<Table name='The table of variables' file='type:path'><var name='type:property' value='type:string'/></Table>" })
        public void runCommandTable(final Node aCurrentVar) throws Throwable {
                AEManager manager = this.recipeListener.getManager();
                boolean notifyMe = this.recipeListener.isNotifyMe();

                manager.inputDataTable(this, aCurrentVar, notifyMe);
        }

        @SuppressWarnings({ "unchecked" })
        @CommandExamples({ "<Loop name='type:property' source='type:property' numbers='type:integer'> ... </Loop>",
                        "<Loop numbers='type:integer'> ... </Loop>",
                        "<Loop name='type:property' query='select * from ...' maxCount='type:integer'> ... </Loop>" })
        public void runCommandLoop(final Node aCurrentVar) throws Throwable {
                String theDescript = replaceProperties(aCurrentVar.getAttribute("description"));
                final String theNameAttribut = attr(aCurrentVar, "name");
                boolean mainLoopCommand = false;

                final String theNumbers = StringUtils.trimToNull(replaceProperties(aCurrentVar.getAttribute("numbers")));
                if (theDescript == null) {
                        theDescript = "Loop";
                }
                String sourceAttribute = aCurrentVar.getAttribute("source");
                final String theAttribut = replaceProperties(sourceAttribute);
                Object loopArrayVar = null;
                if (theAttribut != null) {
                        loopArrayVar = getVariableValue(theAttribut);
                }
                List<Object> theLoopArray = new ArrayList<>();
                if (loopArrayVar != null) {
                        if (loopArrayVar instanceof String) {
                                theLoopArray.add((String) loopArrayVar);
                        } else if (loopArrayVar instanceof String[]) {
                                List<String> asList = Arrays.asList((String[]) loopArrayVar);
                                theLoopArray.addAll(asList);
                        } else if (loopArrayVar instanceof List) {
                                theLoopArray = (List<Object>) loopArrayVar;
                        } else if (loopArrayVar instanceof Map) {
                                Map map = (Map) loopArrayVar;
                                theLoopArray.addAll(map.keySet());
                        } else if (loopArrayVar instanceof JSONArray) {
                                JSONArray array = (JSONArray) loopArrayVar;
                                theLoopArray = array.toList();
                        } else {
                                return;
                        }
                }
                int theCount = 0;
                boolean infinityLoop = false;
                if (StringUtils.isNotBlank(theNumbers)) {
                        theCount = (int) Double.parseDouble(theNumbers);
                } else {
                        if (!theLoopArray.isEmpty()) {
                                theCount = theLoopArray.size();
                        } else {
                                infinityLoop = sourceAttribute == null;
                        }
                }
                if (isLoopActivated() == false) {
                        this.mainLoopCommand = true;
                        mainLoopCommand = true;
                }

                if (infinityLoop) {
                        this.mainLoopCommand = false;
                }
                try {
                        for (int i = 0; (i < theCount || infinityLoop) && isStopped() == false; i++) {
                                if (isStopped()) {
                                        break;
                                }
                                if (this.breakFlag > 0) {
                                        break;
                                }
                                if ((mainLoopCommand && !infinityLoop) || theCount > 5) {
                                        this.recipeListener.setProgress(theDescript, theCount, i, false);
                                }
                                startCommandInformation(aCurrentVar);
                                if (theLoopArray != null && theLoopArray.size() > 0) {
                                        if (i < theLoopArray.size()) {
                                                setVariableValue(theNameAttribut, theLoopArray.get(i));
                                        }
                                } else {
                                        setVariableValue(theNameAttribut, ObjectUtils.toString(i));
                                }
                                taskNode(aCurrentVar, false);
                        }
                } finally {
                        if (this.breakFlag > 0) {
                                breakFlag--;
                        }
                        if (mainLoopCommand) {
                                this.mainLoopCommand = false;
                        }
                }
        }

        @CommandExamples({ "<Append name='type:property' value='type:string' type='enum:all|unique'/>",
                        "<Append name='type:property'>...</Append>" })
        public synchronized void runCommandAppend(final Node aCurrentVar) throws Throwable {
                final String name = aCurrentVar.getAttribute("name");
                Object value = attr(aCurrentVar, "value");
                if (value == null) {
                        value = replaceProperties(aCurrentVar.getInnerText());
                }

                String source = aCurrentVar.getAttribute("source");
                if (source != null) {
                        value = getVariableValue(replaceProperties(source));
                }

                Object theOldValue = getVariableValue(name, false);
                if (theOldValue == null) {
                        return;
                }

                theOldValue = checkForArray(theOldValue);

                if (theOldValue instanceof String) {
                        final String theValue1 = (String) theOldValue;
                        value = theValue1 + value;
                        setVariableValue(name, value);

                } else if (theOldValue instanceof Object[]) {
                        final boolean theUniqueTypeAttribut = "unique".equals(aCurrentVar.getAttribute("type"));

                        final Object[] theValue1 = (Object[]) theOldValue;
                        Object[] theValue2 = null;

                        if (theUniqueTypeAttribut) {
                                Set<Object> targetSet = new LinkedHashSet<>(Arrays.asList(theValue1));
                                if (value instanceof String) {
                                        targetSet.add((String) value);
                                } else if (value instanceof String[]) {
                                        for (String val : (String[]) value) {
                                                targetSet.add(val);
                                        }
                                }

                                String[] array = new String[targetSet.size()];
                                Iterator<Object> iterator = targetSet.iterator();
                                int i = 0;
                                while (iterator.hasNext()) {
                                        String object = (String) iterator.next();
                                        array[i++] = object;
                                }

                                theValue2 = array;

                        } else {
                                List<Object> targetList = new ArrayList<>(Arrays.asList(theValue1));
                                if (value instanceof String[]) {
                                        for (String val : (String[]) value) {
                                                targetList.add(val);
                                        }
                                } else {
                                        targetList.add((String) value);
                                }

                                String[] array = new String[targetList.size()];
                                int i = 0;
                                for (Object val : targetList) {
                                        if (val instanceof String) {
                                                array[i++] = (String) val;
                                        } else {
                                                array[i++] = ObjectUtils.toString(val);
                                        }
                                }

                                theValue2 = array;
                        }

                        applyResult(aCurrentVar, name, theValue2);
                }
        }

        private Object checkForArray(Object theOldValue) {
                if (theOldValue instanceof List) {
                        theOldValue = ((List) theOldValue).toArray();
                }
                return theOldValue;
        }

        @CommandExamples({ "<Rnd name='type:property' symbols='type:integer' type='enum:number|default'/>",
                        "<Rnd name='type:property' type='uuid'/>",
                        "<Rnd name='type:property' symbols='type:integer' startCode='type:integer' endCode='type:integer'/>",
                        "<Rnd name='type:property' source='type:property'/>" })
        public void runCommandRnd(final Node aCurrentVar) throws Throwable {
                final String theNameAttribut = replaceProperties(aCurrentVar.getAttribute("name"));
                String result = null;
                String type = replaceProperties(aCurrentVar.getAttribute("type"));

                if ("uuid".equalsIgnoreCase(type)) {
                        result = UUID.randomUUID().toString();

                } else {
                        final String source = replaceProperties(aCurrentVar.getAttribute("source"));
                        if (this.random == null) {
                                this.random = SecureRandom.getInstance("SHA1PRNG");
                        }
                        if (source != null) {
                                Object value = getVariableValue(source);
                                if (value instanceof String[]) {
                                        String[] strings = (String[]) value;
                                        int index = this.random.nextInt(strings.length);
                                        value = strings[index];
                                }
                                setVariableValue(theNameAttribut, value);
                                return;
                        }

                        final String theSymbolsAttribut = replaceProperties(aCurrentVar.getAttribute("symbols"));

                        final long theBegNum = Long.parseLong(theSymbolsAttribut);
                        int startCode = 0x41;
                        final String startCodeStr = replaceProperties(aCurrentVar.getAttribute("startCode"));
                        if (startCodeStr != null) {
                                if (startCodeStr.indexOf('x') > 0) {
                                        startCode = Integer.parseInt(startCodeStr.substring(2), 16);
                                } else {
                                        startCode = Integer.parseInt(startCodeStr);
                                }
                                type = "-number";
                        }

                        int endCode = 0x05A;
                        final String endCodeStr = replaceProperties(aCurrentVar.getAttribute("endCode"));
                        if (endCodeStr != null) {
                                if (endCodeStr.indexOf('x') > 0) {
                                        endCode = Integer.parseInt(endCodeStr.substring(2), 16);
                                } else {
                                        endCode = Integer.parseInt(endCodeStr);
                                }
                                type = "-number";
                        }

                        if ("number".equals(type) == false) {
                                final StringBuffer theBuffer = new StringBuffer();
                                for (int i = 0; i < theBegNum; i++) {
                                        theBuffer.append((char) (this.random.nextInt(endCode - startCode) + startCode));
                                }
                                result = theBuffer.toString();
                        } else {
                                final StringBuffer theBuffer = new StringBuffer();
                                for (int i = 0; i < theBegNum; i++) {
                                        theBuffer.append(this.random.nextInt(9));
                                }
                                result = theBuffer.toString();
                        }
                }

                setVariableValue(theNameAttribut, result);
        }

        @CommandExamples({ "<Inc name='type:property' increase='type:number'/>" })
        public void runCommandInc(final Node aCurrentVar) throws Throwable {
                String theValueAttribut = aCurrentVar.getAttribute("increase");
                theValueAttribut = replaceProperties(theValueAttribut);
                long theIncLong = 1;
                if (theValueAttribut != null) {
                        theIncLong = Long.parseLong(theValueAttribut);
                }
                final String theAttribut = aCurrentVar.getAttribute("name");
                Object theOldValue = getVariableValue(theAttribut);

                if (!(theOldValue instanceof Object[])) {
                        theOldValue = ObjectUtils.toString(theOldValue, null);
                }

                if (theOldValue instanceof String) {
                        final long theLongValue = Long.parseLong((String) theOldValue) + theIncLong;
                        setVariableValue(theAttribut, Long.toString(theLongValue));
                }
                if (theOldValue instanceof String[] && ((String[]) theOldValue).length > 0) {
                        final long theLongValue = Long.parseLong(((String[]) theOldValue)[0]) + theIncLong;
                        setVariableValue(theAttribut, Long.toString(theLongValue));
                } else {
                        new ClassCastException("Tag <Inc> enabled only one number argument.");
                }
        }

        @CommandExamples({
                        "<If name='type:property' startsWith='type:string' endsWith='type:string' contains='type:string' equals='type:string' notEqual='type:string'> ... </If>",
                        "<If value='type:property' startsWith='type:string' endsWith='type:string' contains='type:string' equals='type:string' notEqual='type:string'> ... <Else> ... </Else></If>",
                        "<If expression='type:string'> ... </If>", "<If isNull='type:property'> ... </If>",
                        "<If isNotNull='type:property'> ... </If>" })
        public void runCommandIf(final Node action) throws Throwable {
                runIf(action);
        }

        private boolean runIf(final Node action) throws CommandException, Throwable, ClassNotFoundException {
                String theExpressionAttribut = action.getAttribute("expression");
                String isNull = action.getAttribute("isNull");
                String isNotNull = action.getAttribute("isNotNull");
                String nameAttr = attr(action, "name");

                String valueAttr = action.getAttribute("value");

                String theValue1Attribut = action.getAttribute("value1");
                String theValue2Attribut = action.getAttribute("value2");
                String theConditionAttribut = action.getAttribute("condition");

                boolean result = false;
                if (nameAttr != null || valueAttr != null) {
                        Object variableValue = getVariableValue(nameAttr);
                        String value;

                        if (variableValue == null) {
                                value = replaceProperties(valueAttr);
                        } else {
                                if (variableValue instanceof String[]) {
                                        value = StringUtils.join((String[]) variableValue, "\n");
                                } else {
                                        value = ObjectUtils.toString(variableValue);
                                }
                        }

                        String startsWith = attr(action, "startsWith");
                        String endsWith = attr(action, "endsWith");
                        String contains = attr(action, "contains");
                        String equals = attr(action, "equals");
                        String regex = attr(action, "regex");
                        String notEqual = attr(action, "notEqual");

                        boolean ignoreCase = Boolean.valueOf(attr(action, "ignoreCase", "false"));

                        boolean condition1 = startsWith == null || (ignoreCase ? StringUtils.startsWithIgnoreCase(value, startsWith)
                                        : StringUtils.startsWith(value, startsWith));
                        boolean condition2 = endsWith == null || (ignoreCase ? StringUtils.endsWithIgnoreCase(value, endsWith)
                                        : StringUtils.endsWith(value, endsWith));
                        boolean condition3 = contains == null || (ignoreCase ? StringUtils.containsIgnoreCase(value, contains)
                                        : StringUtils.contains(value, contains));
                        boolean condition4 = equals == null
                                        || (ignoreCase ? StringUtils.equalsIgnoreCase(value, equals) : StringUtils.equals(value, equals));

                        boolean condition5 = true;
                        if (regex != null) {
                                final Pattern p = Pattern.compile(regex);
                                final Matcher m = p.matcher(value);
                                condition5 = m.find();
                        }

                        boolean condition6 = notEqual == null || (ignoreCase ? !StringUtils.equalsIgnoreCase(value, notEqual)
                                        : !StringUtils.equals(value, notEqual));

                        result = condition1 && condition2 && condition3 && condition4 && condition5 && condition6;
                        execIf(action, result);
                        return result;
                } else if (isNull != null) {
                        result = getVariableValue(replaceProperties(isNull)) == null;
                        execIf(action, result);
                        return result;
                } else if (isNotNull != null) {
                        Object variableValue = getVariableValue(replaceProperties(isNotNull));
                        result = variableValue != null;
                        execIf(action, result);
                        return result;
                } else if (theExpressionAttribut != null) {
                        theExpressionAttribut = replaceProperties(theExpressionAttribut);
                        JexlEngine jexl = new JexlBuilder().create();

                        JexlExpression expr_c = jexl.createExpression(theExpressionAttribut);
                        JexlContext context = new MapContext();

                        if (expr_c != null) {
                                Object val = expr_c.evaluate(context);
                                result = "true".equals(val.toString());
                        }

                        execIf(action, result);
                        return result;
                } else if (theValue1Attribut != null || theValue2Attribut != null) {
                        if (theConditionAttribut == null) {
                                theConditionAttribut = "==";
                        }
                        theValue1Attribut = replaceProperties(theValue1Attribut);
                        theValue2Attribut = replaceProperties(theValue2Attribut);

                        if ("==".equals(theConditionAttribut) && theValue1Attribut.equals(theValue2Attribut)) {
                                taskNode(action, false);
                                result = true;
                        } else if (("!=".equals(theConditionAttribut) || "unequal".equals(theConditionAttribut))
                                        && (theValue1Attribut.equals(theValue2Attribut) == false)) {
                                taskNode(action, false);
                                result = true;
                        } else if ("less".equals(theConditionAttribut)
                                        && (Long.parseLong(theValue1Attribut) < Long.parseLong(theValue2Attribut))) {
                                taskNode(action, false);
                                result = true;
                        } else if ("bigger".equals(theConditionAttribut)
                                        && (Long.parseLong(theValue1Attribut) > Long.parseLong(theValue2Attribut))) {
                                taskNode(action, false);
                                result = true;
                        } else {
                                for (Node command : action.getNodes("Else")) {
                                        taskNode(command, false);
                                }
                        }
                }

                return result;
        }

        private void execIf(final Node action, boolean result) throws CommandException, Throwable {
                if (result) {
                        taskNode(action, false);
                } else {
                        for (Node command : action.getNodes("Else")) {
                                if (command.getAttribute("name") == null && action.getAttribute("name") != null) {
                                        command.setAttribute("name", action.getAttribute("name"));
                                }
                                if (command.getAttribute("value") == null && action.getAttribute("value") != null) {
                                        command.setAttribute("value", action.getAttribute("value"));
                                }
                                if (command.getAttribute("name") != null || command.getAttribute("value") != null) {
                                        if (runIf(command)) {
                                                break;
                                        }
                                } else {
                                        taskNode(command);
                                }
                        }
                }
        }

        @CommandDescription("")
        @CommandExamples({
                        "<While name='type:property' startsWith='type:string' endsWith='type:string' contains='type:string' equals='type:string' notEqual='type:string'> ... </While>",
                        "<While value1='type:string' value2='type:string' condition='unequal'> ... <Else value1='type:string' value2='type:string' condition='enum:unequal|equal'> ... </Else></While>",
                        "<While expression='type:string'> ... </While>", "<While isNull='type:property'> ... </While>",
                        "<While isNotNull='type:property'> ... </While>" })
        public void runCommandWhile(final Node aCurrentVar) throws Throwable {
                try {
                        for (; runIf(aCurrentVar);) {
                                if (this.breakFlag > 0) {
                                        break;
                                }
                        }
                } finally {
                        if (this.breakFlag > 0) {
                                breakFlag--;
                        }
                }
        }

        @CommandExamples({ "<Pragma event='console-input' action='default'/>",
                        "<Pragma event='random-select' action='on'/>", "<Pragma event='log-window' action='single'/>" })
        public void runCommandPragma(final Node aCurrentVar) throws Throwable {
                final String theEventAttribut = aCurrentVar.getAttribute("event");
                final String theActionAttribut = aCurrentVar.getAttribute("action");

                if ("console-input".equals(theEventAttribut)) {
                        boolean consoleDefaultInput = "default".equals(theActionAttribut);
                        getListener().getManager().setConsoleDefaultInput(consoleDefaultInput);
                } else if ("random-select".equals(theEventAttribut)) {
                        randomSelect = "on".equals(theActionAttribut);
                } else {
                        this.log.error("Pragma ignored. Event: " + theEventAttribut);
                }
        }

        @SuppressWarnings("unchecked")
        @CommandDescription("The `name` attribute is a name of variable which provides Runnable or List<Runnable> value. "
                        + "To define this value, you should use the Runnable command tag.")
        @CommandExamples({
                        "<Threads name='type:property' threadLog='type:boolean' numbers='type:integer' multi='enum:true|false' />",
                        "<Threads numbers='type:integer' multi='enum:true|false' mode='enum:wait|nowait'><Out name='"
                                        + TaskProcessorThread.THREAD_ID + "'/></Threads>",
                        "<Threads multi='enum:true|false'><Out name='" + TaskProcessorThread.THREAD_ID + "'/></Threads>" })
        public void runCommandThreads(final Node aCurrentAction) throws InterruptedException, CommandException {

                boolean threadLog = Boolean
                                .parseBoolean(StringUtils.defaultIfBlank(attr(aCurrentAction, "threadLog"), "false"));
                int numbers = Integer.parseInt(StringUtils.defaultIfBlank(attr(aCurrentAction, "numbers"), "1"));
                boolean multi = Boolean.parseBoolean(StringUtils.defaultIfBlank(attr(aCurrentAction, "multi"), "true"));

                ThreadPoolExecutor threadPool;
                if (multi) {
                        if (numbers > 0) {
                                threadPool = (ThreadPoolExecutor) Executors.newFixedThreadPool(numbers);
                        } else {
                                threadPool = (ThreadPoolExecutor) Executors.newCachedThreadPool();
                        }
                } else {
                        threadPool = (ThreadPoolExecutor) Executors.newFixedThreadPool(1);
                }

                String callableListName = attr(aCurrentAction, "name");
                if (callableListName == null) {
                        final Iterator<?> theIterator = aCurrentAction.iterator();

                        if (numbers == 0) {
                                while (theIterator.hasNext()) {
                                        final Node theNode = (Node) theIterator.next();

                                        String theNameThreads = getTestName(theNode);
                                        if (theNameThreads == null) {
                                                theNameThreads = "Thread";
                                        }

                                        ILogger theLog = this.log;
                                        if (threadLog) {
                                                theLog = this.recipeListener.createLog(theNameThreads, false);
                                        }

                                        final TaskProcessorThread runnable = new TaskProcessorThread(this, theNode, getBaseDir(), theLog);

                                        threadPool.execute(runnable);

                                }
                        } else {
                                final Node theNode = (Node) aCurrentAction.clone();
                                theNode.setTag("Task");
                                theNode.removeAttribute(callableListName);

                                for (int i = 0; i < numbers; i++) {
                                        String theNameThreads = getTestName(theNode);
                                        String logName = "Thread #" + i;
                                        if (theNameThreads != null) {
                                                logName = theNameThreads + " #" + i;
                                        }

                                        ILogger theLog = this.log;
                                        if (threadLog) {
                                                theLog = this.recipeListener.createLog(logName, false);
                                        }

                                        final TaskProcessorThread runnable = new TaskProcessorThread(this, theNode, getBaseDir(), theLog);
                                        runnable.getVaribleValue(TaskProcessorThread.THREAD_ID, String.valueOf(i));

                                        threadPool.execute(runnable);
                                }
                        }

                } else {
                        Object callableList = getVariableValue(callableListName);
                        if (callableList instanceof List) {
                                for (Runnable runnable : (List<Runnable>) callableList) {
                                        threadPool.execute(runnable);
                                }
                        } else if (callableList instanceof Runnable) {
                                for (int i = 0; i < numbers; i++) {
                                        if (callableList instanceof TaskProcessorThread) {
                                                threadPool.execute(((TaskProcessorThread) callableList).clone(i));
                                        } else {
                                                threadPool.execute((Runnable) callableList);
                                        }
                                }
                        } else {
                                throw new IllegalArgumentException(
                                                "Variable of type must be Runnable or List<Runnable>, actually: " + callableList);
                        }
                }

                String description = replaceProperties(aCurrentAction.getAttribute("description"));

                long completedTaskCount = 0;
                long size = threadPool.getTaskCount();

                threadPoolList.add(threadPool);
                do {
                        completedTaskCount = threadPool.getCompletedTaskCount();
                        progress(size, completedTaskCount, description, false);
                        Thread.sleep(200);

                } while (completedTaskCount < size);
                threadPoolList.remove(threadPool);
        }

        @CommandExamples({ "Run recipe by name: <Task name='type:recipe' />",
                        "Run recipe by name in async mode: <Task name='type:recipe' mode='enum:sync|async' optional='enum:false|true'/>",
                        "Recipe command grouping: <Task> ... </Task>", "Run recipe by file path: <Task file='type:path' />" })
        public void runCommandTask(final Node action) throws Throwable {

                final boolean optional = Boolean.valueOf(attr(action, "optional", "false"));

                final String taskName = replaceProperties(action.getAttribute("name"));
                String taskFile = replaceProperties(action.getAttribute("file"));

                if (taskFile == null) {
                        if (taskName != null) {
                                taskFile = getListener().getManager().getTestPath(taskName);

                                if (taskFile == null) {
                                        if (optional) {
                                                return;
                                        } else {
                                                throw new Exception("Task with name: '" + taskName + "' not found.");
                                        }
                                }
                        }
                } else {
                        if (!(new File(taskFile)).exists()) {
                                if (optional) {
                                        return;
                                } else {
                                        throw new Exception("Task with name: '" + taskFile + "' not found.");
                                }
                        }
                }

                final File theBaseDir = getBaseDir();
                try {
                        if (taskName != null) {
                                String mode = replaceProperties(action.getAttribute("mode"));
                                if ("async".equals(mode)) {
                                        getListener().getManager().runTask(taskName, true);

                                } else {
                                        Properties taskParameters = MapUtils.toProperties(action.getAttributes());
                                        Set<Entry<Object, Object>> entrySet = taskParameters.entrySet();

                                        String currentLogLevel = (String) this.variables.get(DEFAULT_LOG_LEVEL_NAME);
                                        String level = (String) taskParameters.get("level");

                                        for (Entry<Object, Object> entry : entrySet) {
                                                String name = (String) entry.getKey();
                                                if (!"$ID".equals(name) && !"name".equals(name) && !"file".equals(name)
                                                                && !"level".equals(name)) {
                                                        String value = replaceProperties((String) entry.getValue());
                                                        this.variables.put(toUpperCaseName(name), value);
                                                }
                                        }

                                        this.variables.put(DEFAULT_LOG_LEVEL_NAME, level);
                                        this.variables = processTesting(taskFile, this.variables, getBaseDir());
                                        this.variables.put(DEFAULT_LOG_LEVEL_NAME, currentLogLevel);
                                }
                        } else {
                                taskNode(action, false);
                        }
                } finally {
                        setBaseDir(theBaseDir);
                }
        }

        @CommandExamples({ "<IterationRules name='type:property'><Out name='Iteration'/></IterationRules>",
                        "<IterationRules name='type:property' timeLimit='type:time' start='type:integer'> ... </IterationRules>",
                        "<Var name='rules'>#\n[multiple]\na=1\nb $enum=1;2\nc $inc=0;10\nd $file=file_name\n[single]\n...\n[concurrently]\n...\n[independent]\n...\n#</Var>"
                                        + "<IterationRules name='rules'><Out name='Iteration'/></IterationRules>", })
        public void runCommandIterationRules(final Node action) throws IOException, CommandException {
                final String name = (String) attrValue(action, "name");
                String theStartAttribut = action.getAttribute("start");
                long theLimit = attrTime(action, "timeLimit", "180000");

                if (theStartAttribut == null) {
                        theStartAttribut = "0";
                }

                final int theStart = Integer.parseInt(theStartAttribut);
                if (name == null) {
                        throw new CommandException("In tag <IterationRules> variable rules is not defined.", this);
                }
                try {
                        this.iteratorMode = true;
                        final TestIterator theTestIterator = new TestIterator(this, name);
                        final int theMax = theTestIterator.count();
                        progress(theMax, 0, "Iteration process", false);
                        debug("Iteration block. Total count: " + theMax);
                        final long theStertTime = System.currentTimeMillis();
                        for (int i = theStart; i < theMax; i++) {
                                if (isStopped()) {
                                        break;
                                }
                                setVariableValue("Iteration", Integer.toString(i + 1));
                                theTestIterator.nextIteration(this);

                                taskNode(action, false);

                                progress(theMax, i, "Iteration process", false);
                                if (i == 0) {
                                        long theTotalTime = ((System.currentTimeMillis() - theStertTime) * theMax) / 60000;
                                        debug("Total Iteration time: " + Long.toString(theTotalTime) + " min.");
                                        if (theTotalTime > theLimit) {
                                                int theConfirm = 0;
                                                if (this.recipeListener.getManager() != null) {
                                                        if (this.recipeListener.getManager().isConsoleDefaultInput(attr(action, "name"),
                                                                        attr(action, "description")) == false) {
                                                                if (theTotalTime < 60) {
                                                                        theConfirm = JOptionPane.showConfirmDialog(
                                                                                        JOptionPane.getRootFrame(), "Total Iteration time: "
                                                                                                        + Long.toString(theTotalTime) + " min. \nContinue?",
                                                                                        "Warning", JOptionPane.YES_NO_OPTION);
                                                                } else {
                                                                        theTotalTime /= 60;
                                                                        theConfirm = JOptionPane.showConfirmDialog(JOptionPane.getRootFrame(),
                                                                                        "Total Iteration time: " + Long.toString(theTotalTime) + " h. \nContinue?",
                                                                                        "Warning", JOptionPane.YES_NO_OPTION);
                                                                }
                                                        }
                                                        if (theConfirm != JOptionPane.YES_OPTION) {
                                                                break;
                                                        }
                                                }
                                        }
                                }
                        }
                } finally {
                        this.iteratorMode = false;
                }
        }

        @CommandExamples({ "<Listdir path='type:path' name='type:property'/>",
                        "<Listdir name='type:property' path='type:path' filter='type:regex'/>",
                        "<Listdir name='type:property' path='type:path' filter='type:regex' dirFilter='type:regex' />",
                        "<Listdir path='type:path' name='type:property' />" })
        public void runCommandListdir(final Node aCurrentVar) throws Throwable {
                final String pathAttribut = replaceProperties(aCurrentVar.getAttribute("path"));
                final String theNameAttribut = replaceProperties(aCurrentVar.getAttribute("name"));
                final String fileFilterRegex = attr(aCurrentVar, "filter");
                final String dirFilterRegex = attr(aCurrentVar, "dirFilter");
                File path = getFile(pathAttribut);

                if (isActiveInitFor(aCurrentVar, "console")) {
                        String pathStr = this.recipeListener.getManager().inputFile(theNameAttribut, null, path, log, this);
                        if (pathStr != null) {
                                path = new File(pathStr);
                        }
                }

                if (path != null) {
                        debug("Listing of directory: " + path.getAbsolutePath());

                        IOFileFilter fileFilter = TrueFileFilter.TRUE;

                        if (fileFilterRegex != null) {
                                fileFilter = new RegexPathFilter(fileFilterRegex, dirFilterRegex);
                        }

                        Collection<File> files = FileUtils.listFiles(path, fileFilter,
                                        dirFilterRegex != null ? TrueFileFilter.TRUE : null);
                        List<String> result = files.stream().map(f -> f.getAbsolutePath()).collect(Collectors.toList());

                        if (!result.isEmpty()) {
                                Collections.sort(result);
                                setVariableValue(theNameAttribut, result);
                        }
                } else {
                        throw new TaskCancelingException();
                }
        }

        @CommandExamples({ "<NetworkInterfaces name='type:property' />",
                        "<NetworkInterfaces name='type:property' host='type:string' filterFor='type:string'/>" })
        public void runCommandNetworkInterfaces(final Node aCurrentAction) throws SocketException, UnknownHostException {
                final String name = replaceProperties(aCurrentAction.getAttribute("name"));
                String host = replaceProperties(aCurrentAction.getAttribute("host"));

                if (host == null) {
                        Enumeration<NetworkInterface> networkInterfaces = NetworkInterface.getNetworkInterfaces();
                        Set<String> hostIps = new HashSet<>();
                        while (networkInterfaces.hasMoreElements()) {
                                NetworkInterface nextElement = networkInterfaces.nextElement();
                                Enumeration<InetAddress> inetAddresses = nextElement.getInetAddresses();
                                while (inetAddresses.hasMoreElements()) {
                                        InetAddress nextElement2 = inetAddresses.nextElement();
                                        if (nextElement2 instanceof Inet4Address) {
                                                Inet4Address address = (Inet4Address) nextElement2;
                                                String hostAddress = address.getHostAddress();
                                                hostIps.add(hostAddress);
                                        }
                                }
                        }
                        setVariableValue(name, new ArrayList<>(hostIps));
                } else {
                        try {
                                URL url = new URL(host);
                                host = url.getHost();
                        } catch (Exception e) {

                        }

                        InetAddress address1 = InetAddress.getByName(host);
                        setVariableValue(name, address1.getHostAddress());
                }
        }

        @CommandDescription("Executes a command on the local computer. The command will be executed if the regular expression specified in `os` matches the OS_NAME system property. "
                        + "The `dir` attribute specifies the current directory for the command being executed. This attribute can use `~` as the directory for the current recipe.")
        @CommandExamples({ "<Command os='type:regex'>...</Command>",
                        "<Command os='type:regex' env='type:property'>...</Command>",
                        "<Command name='type:property' os='type:regex' exitValue='type:property' cmd='type:string' noCommandLog='type:boolean' dir='type:path'/>",
                        "<Command name='type:property' os='type:regex' exitValue='type:property' cmd='type:string' noCommandLog='type:boolean' dir='type:path'/>...</Command>" })
        public void runCommandCommand(final Node action) throws Throwable {

                String command = attr(action, "cmd");
                final String name = attr(action, "name");
                final String dir = attr(action, "dir");
                final String os = attr(action, "os");

                String osName = SystemUtils.OS_NAME;

                if (os == null || Pattern.compile(os).matcher(osName).matches()) {
                        if (command == null) {
                                final Node[] theNodes = action.getTextNodes();
                                if (theNodes.length > 0) {
                                        command = replaceProperties(theNodes[0].getText());
                                }
                        }

                        Object env = attrValue(action, "env");
                        if (env != null) {
                                if (!(env instanceof Map)) {
                                        throw new CommandException("'env' attribute shuld be Map", this);
                                }
                        }
                        @SuppressWarnings("unchecked")
                        Map<String, String> environment = (Map<String, String>) env;
                        runSystemCommand(command, name, action, dir, environment);
                }
        }

        private void runSystemCommand(final String command, final String theNameAttribut, final Node aCurrentNode,
                        String dir, Map<? extends String, ? extends String> env) throws Throwable {
                final String prefix = "start ";
                if (command.startsWith(prefix) == false) {

                        String regExp = "\"(\\\"|[^\"])*?\"|[^ ]+";
                        Pattern pattern = Pattern.compile(regExp, Pattern.MULTILINE | Pattern.CASE_INSENSITIVE);
                        Matcher matcher = pattern.matcher(command);
                        List<String> commandTokens = new ArrayList<String>();

                        if (SystemUtils.IS_OS_WINDOWS) {
                                commandTokens.add("cmd.exe");
                                commandTokens.add("/c");
                        }

                        while (matcher.find()) {
                                String trim = matcher.group().trim();
                                if (StringUtils.isNotBlank(trim)) {
                                        commandTokens.add(trim);
                                }
                        }
                        String[] parsedCommand = commandTokens.toArray(new String[] {});

                        ProcessBuilder builder = new ProcessBuilder(parsedCommand);

                        if (env != null) {
                                Map<String, String> environment = builder.environment();
                                environment.putAll(env);
                        }

                        if (dir != null) {
                                File directory;
                                if (dir.startsWith("~/")) {
                                        dir = dir.substring(1);
                                        String recipeFile = this.recipeListener.getManager().getTestPath(testName);
                                        if (recipeFile != null) {
                                                directory = new File(new File(recipeFile).getParent(), dir);
                                                builder.directory(directory);
                                        }
                                } else {
                                        directory = new File(dir);
                                        builder.directory(directory);
                                }
                        }

                        builder.redirectErrorStream(true);
                        Process process = builder.start();

                        final String stdin = replaceProperties(aCurrentNode.getAttribute("stdin"));
                        if (stdin != null) {
                                process.getOutputStream().write(stdin.getBytes());
                                process.getOutputStream().close();
                        }

                        processes.add(process);

                        final BufferedReader errorStream = new BufferedReader(new InputStreamReader(process.getInputStream()));
                        boolean noCommandLog = Boolean.valueOf(attr(aCurrentNode, "noCommandLog"));
                        if (!noCommandLog) {
                                debug("Command: " + command);
                        } else {
                                debug("Command: ****** **** *****");
                        }

                        try {
                                final BufferedReader theOutputStream = new BufferedReader(
                                                new InputStreamReader(process.getInputStream()));
                                String theLine;

                                boolean line_output = aCurrentNode.size() == 0;
                                final StringBuffer theBuffer = new StringBuffer();
                                while ((theLine = theOutputStream.readLine()) != null && !isStoppedTest()) {
                                        if (breakFlag > 0) {
                                                break;
                                        }

                                        if (line_output) {
                                                theBuffer.append(theLine);
                                                theBuffer.append('\n');
                                        } else {
                                                setVariableValue(theNameAttribut, theLine);
                                                taskNode(aCurrentNode, false);
                                        }
                                }

                                if (this.breakFlag > 0) {
                                        breakFlag--;
                                }

                                String exitValueName = attr(aCurrentNode, "exitValue");
                                if (exitValueName != null) {
                                        int exitValue = 0;
                                        try {
                                                exitValue = process.exitValue();
                                                if (exitValue > 0) {
                                                        String error = IOUtils.toString(errorStream);
                                                        if (StringUtils.isNotBlank(error)) {
                                                                throw new RuntimeException(error);
                                                        }
                                                }
                                        } catch (IllegalThreadStateException e) {
                                                //
                                        }
                                        setVariableValue(exitValueName, Integer.toString(exitValue));
                                }

                                if (line_output) {
                                        if (theNameAttribut == null) {
                                                debug("System output:" + theBuffer.toString());
                                        } else {
                                                setVariableValue(theNameAttribut, theBuffer.toString());
                                        }
                                }
                        } finally {
                                processes.remove(process);
                                process.destroyForcibly();
                                try {
                                        if (!process.waitFor(5, TimeUnit.SECONDS)) {
                                                process.destroyForcibly();
                                        }
                                } catch (InterruptedException e) {
                                        Thread.currentThread().interrupt();
                                        process.destroyForcibly();
                                }
                        }

                } else {
                        final Thread thread = new SystemCommandStart(command.substring(prefix.length()), this.log);
                        thread.start();
                }
        }

        @CommandExamples({ "<ArraySize name = 'type:property' array = 'type:property'/>" })
        public void runCommandArraySize(final Node aCurrentVar) throws Throwable {
                final String theNameAttribut = replaceProperties(aCurrentVar.getAttribute("name"));
                final String theArrayNameAttribut = replaceProperties(aCurrentVar.getAttribute("array"));
                final Object theValue = getVariableValue(theArrayNameAttribut);

                int theResult = 0;
                if (theValue instanceof String[]) {
                        theResult = ((String[]) theValue).length;
                } else if (theValue instanceof List) {
                        theResult = ((List<String>) theValue).size();
                } else if (theValue instanceof byte[]) {
                        theResult = ((byte[]) theValue).length;
                } else if (theValue instanceof String && StringUtils.isNotBlank((String) theValue)) {
                        theResult = 1;
                } else {
                        theResult = 0;
                }

                setVariableValue(theNameAttribut, String.valueOf(theResult));
        }

        @CommandExamples({ "Get string or array length: <Size name = 'type:property' source = 'type:property'/>" })
        public void runCommandSize(final Node aCurrentVar) throws Throwable {
                final String theNameAttribut = replaceProperties(aCurrentVar.getAttribute("name"));
                final String theArrayNameAttribut = replaceProperties(aCurrentVar.getAttribute("source"));
                final Object theValue = getVariableValue(theArrayNameAttribut);

                int theResult = 0;
                if (theValue instanceof String[]) {
                        String[] theValue2 = (String[]) theValue;
                        for (int i = 0; i < theValue2.length; i++) {
                                theResult += theValue2[i].length();
                        }
                } else if (theValue instanceof byte[]) {
                        theResult = ((byte[]) theValue).length;
                } else if (theValue instanceof Collection) {
                        theResult = ((Collection) theValue).size();
                } else if (theValue instanceof String && StringUtils.isNotBlank((String) theValue)) {
                        theResult = ((String) theValue).length();
                } else {
                        theResult = 0;
                }

                setVariableValue(theNameAttribut, String.valueOf(theResult));
        }

        @CommandExamples({ "<Time name = 'type:property' action = 'enum:start|continue|pause|stop'/>",
                        "<Time name = 'type:property' action = 'format' format='mm:ss:SSS'/>",
                        "<Time name = 'type:property' action = 'duration' >...code whose execution time is to be measured...</Time>" })
        public void runCommandTime(final Node command) throws Throwable {
                final String theNameAttribut = replaceProperties(command.getAttribute("name"));
                final String format = replaceProperties(command.getAttribute("format"));
                final String theTimeCaption = "Time";
                String action = replaceProperties(command.getAttribute("action"));

                if ("duration".equals(action)) {
                        long start = System.currentTimeMillis();

                        taskNode(command, false);

                        long stop = System.currentTimeMillis();
                        final String[] variableValue = new String[] { theTimeCaption, String.valueOf(start), String.valueOf(stop),
                                        "" };

                        String result = formatTime(format, variableValue);
                        setVariableValue(theNameAttribut, result);
                        return;
                }

                if ("start".equals(action)) {
                        final String[] theTime = new String[] { theTimeCaption, String.valueOf(System.currentTimeMillis()), "",
                                        "" };
                        setVariableValue(theNameAttribut, theTime);
                        return;
                }

                if ("continue".equals(action)) {
                        String[] theTime = (String[]) getVariableValue(theNameAttribut);
                        if (theTime == null) {
                                theTime = new String[] { theTimeCaption, String.valueOf(System.currentTimeMillis()), "",
                                                String.valueOf(System.currentTimeMillis()) };
                        }

                        if (theTime == null || theTime[3] == null || theTime[3].length() == 0) {
                                throw new Exception("Timer is not paused.");
                        }

                        if (theTimeCaption.equals(theTime[0])) {
                                final long theStart = Long.parseLong(theTime[1]);
                                final long thePaused = Long.parseLong(theTime[3]);
                                theTime[1] = String.valueOf(theStart - (System.currentTimeMillis() - thePaused));
                                theTime[3] = "";
                                setVariableValue(theNameAttribut, theTime);
                        } else {
                                throw new Exception("Incorrect type.");
                        }
                        return;
                }

                if ("pause".equals(action)) {
                        final String[] theTime = (String[]) getVariableValue(theNameAttribut);

                        if (theTime[3] != null && theTime[3].length() > 0) {
                                throw new Exception("Timer is paused.");
                        }
                        if (theTimeCaption.equals(theTime[0])) {
                                theTime[3] = String.valueOf(System.currentTimeMillis());
                                setVariableValue(theNameAttribut, theTime);
                        } else {
                                throw new Exception("Incorrect type.");
                        }
                        return;
                }

                if ("stop".equals(action)) {
                        final String[] theTime = (String[]) getVariableValue(theNameAttribut);

                        final long theStart = Long.parseLong(theTime[1]);

                        if (theTime[3] != null && theTime[3].length() > 0) {
                                final long thePaused = Long.parseLong(theTime[3]);
                                theTime[1] = String.valueOf(theStart + (System.currentTimeMillis() - thePaused));
                                theTime[3] = "";
                        }

                        if (theTimeCaption.equals(theTime[0])) {
                                theTime[2] = String.valueOf(System.currentTimeMillis());
                                setVariableValue(theNameAttribut, theTime);
                        } else {
                                throw new Exception("Incorrect type.");
                        }
                        return;
                }

                if ("format".equals(action)) {
                        Object variableValue = getVariableValue(theNameAttribut);
                        String theResult = formatTime(format, variableValue);
                        setVariableValue(theNameAttribut, theResult);
                        return;
                }
        }

        private String formatTime(final String format, Object variableValue) throws Exception {
                final String[] theTime;
                if (variableValue instanceof String[]) {
                        theTime = (String[]) variableValue;
                } else {
                        theTime = new String[] { "", "0", (String) variableValue };
                }

                if (ArrayUtils.getLength(theTime) < 2) {
                        throw new Exception("Timer is not defined.");
                }

                if (ArrayUtils.getLength(theTime) < 3) {
                        throw new Exception("Timer is not stoped.");
                }

                String theResult = null;
                if (format == null) {
                        theResult = String.valueOf(Long.parseLong(theTime[2]) - Long.parseLong(theTime[1]));
                } else {
                        final DateFormat dateFormat = new SimpleDateFormat(format);
                        dateFormat.setTimeZone(TimeZone.getTimeZone("UTC"));
                        long date = Long.parseLong(theTime[2]) - Long.parseLong(theTime[1]);
                        theResult = dateFormat.format(new Date(date));
                }
                return theResult;
        }

        @CommandDescription("The ArrayElement command is used to get an element from an array by element ID (elementId).")
        @CommandExamples({ "<ArrayElement name='type:property' array='type:property' elementId='type:number'/>" })
        public void runCommandArrayElement(final Node aCurrentVar) throws Throwable {
                final String name = replaceProperties(aCurrentVar.getAttribute("name"));
                final String arrayName = replaceProperties(aCurrentVar.getAttribute("array"));
                if (arrayName == null) {
                        throw new IllegalArgumentException("'array' attribute required.");
                }

                final String theElementAttribut = replaceProperties(aCurrentVar.getAttribute("elementId"));
                if (theElementAttribut == null) {
                        throw new IllegalArgumentException("'elementId' attribute required.");
                }

                final String type = replaceProperties(aCurrentVar.getAttribute("type"));
                Object theValue = getVariableValue(arrayName);

                final int theElementId = Integer.parseInt(theElementAttribut);

                theValue = convert(theValue, type);

                Object theResult = null;
                if (theValue instanceof JSONArray) {
                        JSONArray jsonArray = (JSONArray) theValue;
                        theResult = jsonArray.get(theElementId);
                } else if (theValue instanceof String[]) {
                        theResult = ((String[]) theValue)[theElementId];
                } else if (theValue instanceof List) {
                        theResult = ((List) theValue).get(theElementId);
                } else if (theValue instanceof String) {
                        if ("string".equalsIgnoreCase(type)) {
                                theResult = new String(new char[] { ((String) theValue).charAt(theElementId) });
                        } else if (theElementId == 0) {
                                theResult = theValue;
                        }
                } else if (theElementId == 0) {
                        theResult = theValue;
                }

                setVariableValue(name, theResult);
        }

        @CommandDescription("The Calculate command is implemented in the Java Expression Language (JEXL), "
                        + "for more information see: https://commons.apache.org/proper/commons-jexl. "
                        + "The value of the expression will be stored in the variable with the name specified in the `name` attribute.")
        @CommandExamples({ "<Calculate name='type:property' expressions='type:string'/>",
                        "<Calculate name='type:property'>...</Calculate>" })
        public void runCommandCalculate(final Node command) throws Throwable {
                final String name = replaceProperties(command.getAttribute("name"));
                String expressions = replaceProperties(command.getAttribute("expressions"));
                if (expressions == null) {
                        expressions = replaceProperties(command.getInnerText());
                }

                Map<String, Object> namespaces = new HashMap<>();
                namespaces.put("Math", Math.class);
                JexlEngine jexl = new JexlBuilder().namespaces(namespaces).create();

                JexlExpression expr_c = jexl.createExpression(expressions);
                JexlContext context = new MapContext();

                Map<String, String> attributes = command.getAttributes();
                for (Map.Entry<String, String> entry : attributes.entrySet()) {
                        String key = entry.getKey();
                        String val = entry.getValue();

                        Object variableValue = getVariableValue(val);
                        if (variableValue instanceof String) {
                                try {
                                        variableValue = Double.parseDouble((String) variableValue);
                                } catch (NumberFormatException e) {
                                        // DO NOTHING
                                }
                        }

                        context.set(key, variableValue);
                }

                if (expr_c != null) {
                        Object result = expr_c.evaluate(context);

                        if (result != null) {
                                setVariableValue(name, result);
                        } else {
                                setVariableValue(name, null);
                        }
                }
        }

        @CommandExamples({
                        "<Parse name='type:property' source='type:property' type='enum:array|json|csv|fixed-length-line'/>",
                        "<Parse name='type:property' source='type:property' type='fixed-length-line' length='type:integer'/>" })
        public void runCommandParse(final Node command) throws Throwable {
                Object source = attrValue(command, "source");
                final String theNameAttribut = replaceProperties(command.getAttribute("name"));
                final String type = replaceProperties(command.getAttribute("type"));

                if ("json".equalsIgnoreCase(type)) {
                        String theValue = ObjectUtils.toString(source);
                        if (StringUtils.isNotBlank(theValue)) {
                                Object obj = new JSONObject(theValue);
                                if (obj instanceof JSONObject) {
                                        JSONObject result = new JSONObject(theValue);
                                        setVariableValue(theNameAttribut, result);
                                } else if (obj instanceof JSONArray) {
                                        JSONArray result = new JSONArray(theValue);
                                        String[] array = new String[result.length()];
                                        for (int i = 0; i < result.length(); i++) {
                                                array[i] = ObjectUtils.toString(result.get(i));
                                        }
                                        setVariableValue(theNameAttribut, array);
                                }
                        } else {
                                setVariableValue(theNameAttribut, theValue);
                        }

                } else if ("array".equalsIgnoreCase(type)) {
                        String theValue = ObjectUtils.toString(source);

                        String[] array = StringUtils.split(theValue, "\r\n");
                        setVariableValue(theNameAttribut, array);
                } else if ("csv".equalsIgnoreCase(type)) {
                        String theValue = ObjectUtils.toString(source);

                        CSVReader reader = new CSVReader(new StringReader(theValue));
                        List<String[]> r = reader.readAll();

                        setVariableValue(theNameAttribut, r);
                } else if ("fixed-length-line".equalsIgnoreCase(type)) {
                        if (source instanceof String) {
                                String input = (String) source;
                                int lineLength = Integer.parseInt(attr(command, "length"));
                                List<Object> result = IntStream.range(0, (input.length() + lineLength - 1) / lineLength)
                                                .mapToObj(i -> input.substring(i * lineLength, Math.min((i + 1) * lineLength, input.length())))
                                                .collect(Collectors.toList());
                                setVariableValue(theNameAttribut, result);
                        }
                }
        }

        @CommandExamples({ "<FindObject name='type:property' source='type:property' withValue='type:string'/>" })
        public void runCommandFindObject(final Node aCurrentNode) throws Throwable {
                Object json = getVariableValue(replaceProperties(aCurrentNode.getAttribute("source")));
                String withValue = replaceProperties(aCurrentNode.getAttribute("withValue"));

                if (json instanceof String) {
                        String jsonStr = (String) json;
                        if (StringUtils.startsWith(jsonStr, "{")) {
                                json = new JSONObject(jsonStr);
                        } else if (StringUtils.startsWith(jsonStr, "[")) {
                                json = new JSONArray(jsonStr);
                        }
                } else if (json instanceof String[]) {
                        String[] jsonStrArray = (String[]) json;
                        JSONArray array = new JSONArray();
                        for (int i = 0; i < jsonStrArray.length; i++) {
                                String jsonStr = jsonStrArray[i];
                                array.put(new JSONObject(jsonStr));
                        }
                        json = array;
                }

                Object value = find(json, withValue);

                final String name = replaceProperties(aCurrentNode.getAttribute("name"));
                applyResult(aCurrentNode, name, value);
        }

        private JSONObject find(Object obj, String withValue) throws JSONException {
                if (obj instanceof JSONObject) {
                        JSONObject json = (JSONObject) obj;

                        JSONArray names = json.names();
                        if (names != null) {
                                for (int i = 0; i < names.length(); i++) {
                                        String name = names.getString(i);
                                        Object object = json.get(name);
                                        if (object instanceof String) {
                                                if (ObjectUtils.equals(object, withValue)) {
                                                        return json;
                                                }
                                        } else {
                                                JSONObject find = find(object, withValue);
                                                if (find != null) {
                                                        return find;
                                                }
                                        }
                                }
                        }
                } else if (obj instanceof JSONArray) {
                        JSONArray array = (JSONArray) obj;

                        for (int j = 0; j < array.length(); j++) {
                                Object item = array.get(j);

                                JSONObject find = find(item, withValue);
                                if (find != null) {
                                        return find;
                                }
                        }
                }
                return null;
        }

        @CommandDescription("`Var` command is used to define or update a variable.\r\n"
                        + "Attribute `init` defines how variable will be set. This attribute is optional; if it is not defined,\r\n"
                        + "the variable will be initialized by `value` attribute or inner data. It can be set to the following values:\r\n"
                        + "- `default` is used to initialize the variable's value if it is not defined,\r\n"
                        + "- `console` is used for input data by the user,\r\n"
                        + "- `mandatory` is used for show the dialog if the variable is not defined  and raises an error if the user select the 'Skip' input action.\r\n"
                        + "- `file` is used for loadind variables from property file.\r\n"
                        + "Attribute `type` defines a type of variable. It is used to define the variable type and special rules for the input dialog:\r\n"
                        + "The `string` parameter is the default and is not required to define a string property, it should only be used to convert the variable's value to a string type.;\r\n"
                        + "- `array` is used for create the value of the array type;\r\n"
                        + "- `map` is used for create the value of the map type;\r\n"
                        + "- `json` is used for create the property of the json type. Json should be defined as a inner text, don't use `value` attribute;\r\n"
                        + "- `password` the user dialog text field will be masked;\r\n"
                        + "- `path` a dialog for a dir opening will be shown; \r\n"
                        + "- `text` type is used only for large text values, and the value is not saved in the preferences.")
        @CommandExamples({
                        "<Var name='type:property' init='enum:console|mandatory|default' type='enum:text|password|path'/>",
                        "<Var name='type:property' type='enum:array|number|map|json|string' />",
                        "<Var name='type:property' source='type:property' start='type:string' end='type:string'/>",
                        "<Var name='type:property'><item>...</item></Var>",
                        "<Var name='type:property' type='map'><item key='type:string'>...</item></Var>",
                        "<Var name='type:property' type='enum:array|number' file='type:path'/>",
                        "<Var init='file' file='type:path'/>", "<Var name='type:property' source='type:property' />" })
        public void runCommandVar(final Node action) throws Throwable {
                final String name = attr(action, "name");
                String description = attr(action, "description");
                String theInit = attr(action, "init");

                Object theOldValue = getVariableValue(name);
                if ("default".equals(theInit) && theOldValue != null) {
                        if (theOldValue instanceof String) {
                                if (StringUtils.isNotBlank((String) theOldValue)) {
                                        return;
                                }
                        } else if (theOldValue instanceof String[] && ((String[]) theOldValue).length > 0) {
                                return;
                        }
                }

                String file = attr(action, "file");
                if ("file".equals(theInit)) {
                        File propertiesFile = getFile(file);
                        loadProperties(propertiesFile, this.variables, true);
                        return;
                }

                String source = replaceProperties(action.getAttribute("source"), true);
                Object theValue = getVariableValue(name);
                if (source != null) {
                        String sourceVarName = replaceProperties(source);
                        theValue = getVariableValue(sourceVarName);
                        theOldValue = theValue;
                        setVariableValue(name, theValue);
                }

                String value = action.getAttribute("value");
                if (value != null) {
                        theValue = replaceProperties(value);
                }

                // Item setting
                String type = StringUtils.defaultIfEmpty(action.getAttribute("type"), "");
                if (action.size() > 0) {
                        if (Node.TEXT_TEAG_NAME.equals(action.getNode(0).getTag())) {
                                final Node theTextNode = action.getNode(0);
                                theValue = replaceProperties(theTextNode.getText());

                        } else {
                                switch (type) {
                                case "map":
                                        Node[] nodes = action.getNodes("item");
                                        theValue = new LinkedHashMap<String, String>();
                                        for (Node node : nodes) {
                                                ((Map) theValue).put(node.getAttribute("key"), replaceProperties(node.getInnerText()));
                                        }
                                        break;

                                default:
                                        List<Object> theItemArray = new ArrayList<>();
                                        for (int i = 0; i < action.size(); i++) {
                                                final Node theCurrentAction = (Node) action.get(i);
                                                Node[] theItemNodes = theCurrentAction.getTextNodes();
                                                if (theItemNodes != null && theItemNodes.length == 1) {
                                                        final String replaceProperties = replaceProperties(theItemNodes[0].getText(), true);
                                                        theItemArray.add(replaceProperties);
                                                } else {
                                                        if (theCurrentAction.size() == 1) {
                                                                Node node = theCurrentAction.get(0);
                                                                EasyUtils.removeAllAttributes(node, Node.TAG_ID);
                                                                theItemArray.add(replaceProperties(node.getXMLText(), true));
                                                        } else {
                                                                theItemArray = null;
                                                        }
                                                        break;
                                                }
                                        }
                                        theValue = theItemArray;
                                }
                        }
                }

                boolean contains = StringUtils.contains(theInit, "mandatory");
                boolean isConsoleInput = StringUtils.contains(theInit, "console");
                boolean mandatory = StringUtils.contains(theInit, "mandatory");
                if (mandatory) {
                        if (!isEmpty(theOldValue)) {
                                setVariableValue(name, theValue);
                        } else {
                                isConsoleInput = true;
                        }
                }

                final boolean theIntegerType = "number".equals(type);
                if (theIntegerType) {
                        String string = ObjectUtils.toString(theValue);
                        if (StringUtils.isNotBlank(string) && !NumberUtils.isNumber(string)) {
                                setVariableValue(name, null);
                                throw new NumberFormatException(string);
                        }
                }

                final boolean theArrayType = "array".equals(type);
                if (name != null && !(theValue == null && theArrayType == false)) {
                        if (theArrayType) {
                                char separatorChar = ',';
                                if (theValue instanceof String) {
                                        String[] split = StringUtils.split((String) theValue, separatorChar);
                                        theValue = split != null ? Arrays.asList(split) : null;
                                }
                        }
                        if (theArrayType && theValue == null) {
                                theValue = new String[0];
                        }

                        if (theArrayType && file != null) {
                                ArrayList<String> buffer = new ArrayList<String>();

                                if (theValue instanceof String[]) {
                                        for (String string : (String[]) theValue) {
                                                buffer.add(string);
                                        }
                                } else if (theValue instanceof Collection) {
                                        buffer = new ArrayList<String>((Collection<String>) theValue);
                                }

                                try (InputStream inputStream = AEUtils.getInputStream(file, getBaseDir())) {
                                        String encoding = replaceProperties(action.getAttribute("charset"));
                                        if (encoding == null) {
                                                encoding = "UTF-8";
                                        }
                                        final BufferedReader theFileReader = new BufferedReader(
                                                        new InputStreamReader(inputStream, encoding));
                                        String readLine;
                                        while ((readLine = theFileReader.readLine()) != null) {
                                                buffer.add(readLine);
                                        }
                                }
                                theValue = buffer;
                        }

                        theValue = convert(theValue, type);
                        setVariableValue(name, theValue);
                }

                if (isConsoleInput) {

                        if (theOldValue instanceof List && CollectionUtils.size(theOldValue) == 1) {
                                theOldValue = ((List) theOldValue).get(0);
                        }

                        if ((action.size() == 0 || !action.getInnerText().isEmpty())
                                        && (isEmpty(theOldValue) || theOldValue instanceof String)) {
                                Object theInitialSelectionValue = null;
                                final Object o = getVariableValue(name);
                                if (o instanceof String) {
                                        theInitialSelectionValue = o;
                                }
                                if (o instanceof String[] && ((String[]) o).length > 0) {
                                        if (this.random == null) {
                                                this.random = SecureRandom.getInstance("SHA1PRNG");
                                        }
                                        theInitialSelectionValue = ((String[]) o)[this.random.nextInt(((String[]) o).length)];
                                }

                                String defaultValue = AEWorkspace.getInstance().getDefaultUserConfiguration(".inputValue." + name,
                                                (String) theInitialSelectionValue);
                                if (this.recipeListener.getManager().isConsoleDefaultInput(name, description)
                                                && !(mandatory && defaultValue == null)) {

                                        if ((o instanceof String[] && ArrayUtils.contains((String[]) o, defaultValue)) || o == null) {
                                                theInitialSelectionValue = defaultValue;
                                        }

                                        setVariableValue(name, theInitialSelectionValue);
                                } else {
                                        boolean notifyMe = this.recipeListener.isNotifyMe();
                                        Object inputValue;

                                        inputValue = this.recipeListener.getManager().inputValue(name, description, defaultValue, log, type,
                                                        notifyMe, this);

                                        setVariableValue(name, inputValue);
                                }

                        } else {
                                List<Object> possibleValues = null;
                                if (theOldValue instanceof List) {
                                        @SuppressWarnings("unchecked")
                                        final List<Object> theStringArray = (List<Object>) theOldValue;
                                        possibleValues = theStringArray;
                                } else if (theOldValue instanceof String[]) {
                                        possibleValues = new ArrayList<>();
                                        String[] array = (String[]) theOldValue;
                                        for (String item : array) {
                                                possibleValues.add(item);
                                        }
                                } else {
                                        possibleValues = new ArrayList<>();
                                        for (int i = 0; i < action.size(); i++) {
                                                final Node theCurrentAction = (Node) action.get(i);
                                                possibleValues.add(theCurrentAction.getInnerText());
                                        }
                                }

                                if (this.recipeListener.getManager().isConsoleDefaultInput(name, null)) {
                                        String theInitialSelectionValue = randomSelect(possibleValues);
                                        if (!randomSelect) {
                                                theInitialSelectionValue = AEWorkspace.getInstance()
                                                                .getDefaultUserConfiguration(".choiceValue." + name, theInitialSelectionValue);

                                        }
                                        setVariableValue(name, theInitialSelectionValue);
                                } else {
                                        boolean notifyMe = this.recipeListener.isNotifyMe();
                                        final Object theValueOut = this.recipeListener.getManager().choiceValue(name, description,
                                                        possibleValues.toArray(), log, notifyMe, this);
                                        setVariableValue(name, theValueOut);
                                }
                        }
                }

                theValue = getVariableValue(name);

                String start = replaceProperties(action.getAttribute("start"));
                String end = replaceProperties(action.getAttribute("end"));

                if (StringUtils.isNotEmpty(start)) {
                        if (theValue instanceof byte[]) {
                                theValue = new String((byte[]) theValue);
                        }
                        theValue = StringUtils.substringAfter(ObjectUtils.toString(theValue), start);
                        if (StringUtils.isBlank((String) theValue)) {
                                theValue = null;
                        }
                }
                if (StringUtils.isNotEmpty(end)) {
                        theValue = StringUtils.substringBefore((String) theValue, end);
                        if (StringUtils.isBlank((String) theValue)) {
                                theValue = null;
                        }
                }

                applyResult(action, name, theValue);

                if (contains && theValue == null) {
                        stop();
                }
        }

        private Object convert(Object theValue, String type) throws JSONException {
                if ("json".equals(type)) {
                        Object parse = theValue;
                        if (theValue instanceof String[]) {
                                String[] array = (String[]) theValue;
                                List<String> asList = Arrays.asList(array);
                                theValue = new JSONArray(asList);
                        } else if (theValue instanceof String) {
                                if (StringUtils.startsWith((String) theValue, "{")) {
                                        parse = new JSONObject(theValue.toString());
                                } else if (StringUtils.startsWith((String) theValue, "[")) {
                                        parse = new JSONArray(theValue.toString());
                                }
                        }
                        theValue = parse;
                } else if ("string".equals(type) && theValue instanceof String[]) {
                        theValue = StringUtils.join((String[]) theValue);
                }

                return theValue;
        }

        private String randomSelect(List possibleValues) throws NoSuchAlgorithmException {
                final String theInitialSelectionValue;
                if (this.random == null) {
                        this.random = SecureRandom.getInstance("SHA1PRNG");
                }
                theInitialSelectionValue = (String) possibleValues.get(this.random.nextInt(possibleValues.size()));
                return theInitialSelectionValue;
        }

        @CommandExamples({ "<Note name='type:string' connection='type:string'>...</Note>" })
        public void runCommandNote(final Node aCurrentAction) throws Throwable {
        }

        @CommandExamples({ "<!-- ... -->" })
        public void runCommandComment(final Node aCurrentAction) throws Throwable {
        }

        @CommandExamples({ "<Extern class='type:processor'>\n...\n</Extern>" })
        public void runCommandExtern(final Node command) throws Throwable {
                final Processor newInstance = makeProcessor(command);
                boolean success = false;
                try {
                        this.externProcessor = newInstance;
                        externProcessor.setTestName(getTestName());
                        newInstance.init(this, command);
                        boolean rootRecipe = isRootRecipe();
                        newInstance.setRootContext(rootRecipe);
                        newInstance.stackTask.addAll(this.stackTask);
                        newInstance.taskNode(command, false);

                        this.variables = newInstance.variables;
                        success = true;
                } finally {
                        externProcessor.complete(success);
                        externProcessor = null;
                }
        }

        @CommandDescription("The Confirm command is used to confirm the user's decision to continue a "
                        + "task or execute internal code. The name attribute is used as the dialog box title "
                        + "and as a variable name if confirmation is required without displaying a dialog box "
                        + "to the user. If the variable exists, confirmation is automatically applied if the "
                        + "value is true, or rejected if the value is not true.")
        @CommandExamples({ "<Confirm message='type:string' name='type:string'/>",
                        "<Confirm message='type:string' name='type:string'>...</Confirm>" })
        public void runCommandConfirm(final Node aCurrentAction) throws Throwable {
                final String message = attr(aCurrentAction, "message");
                final String name = attr(aCurrentAction, "name");
                final Object nameVar = getVariableValue(name);

                boolean confirmed = false;
                if (nameVar != null && nameVar instanceof String) {
                        confirmed = BooleanUtils.toBoolean((String) nameVar);
                } else {
                        AEManager manager = this.recipeListener.getManager();
                        confirmed = manager.confirmation(name, message, this, this.recipeListener.isNotifyMe());
                }

                if (aCurrentAction.size() > 0) {
                        if (confirmed) {
                                taskNode(aCurrentAction, false);
                        }
                } else {
                        if (!confirmed) {
                                stop();
                        }
                }
        }

        @CommandDescription("The WhileRun command is used to notify the user that a process has started. "
                        + "The user can close the WhileRun dialog box without affecting the process's execution. "
                        + "The dialog box closes after the code within the WhileRun tag completes execution. "
                        + "The name attribute is used as the dialog box title and variable name. "
                        + "If the dialog box should not be opened, a variable with a name corresponding to "
                        + "the dialog box name should be assigned a value other than `true`.")
        @CommandExamples({ "<WhileRun name='type:string' message='type:string'>...</WhileRun>" })
        public void runCommandWhileRun(final Node aCurrentAction) throws Throwable {
                final String message = attr(aCurrentAction, "message");
                final String name = attr(aCurrentAction, "name");
                final Object nameVar = getVariableValue(name);

                if (!(nameVar instanceof String) || BooleanUtils.toBoolean((String) nameVar)) {
                        AEManager manager = this.recipeListener.getManager();
                        MessageHandler handler = manager.message(this, name, message, this.recipeListener.isNotifyMe());
                        taskNode(aCurrentAction, false);
                        handler.close();
                }
        };

        @CommandDescription("The `Server` command initializes and starts a server socket listener, "
                        + "operating as a blocking command that prevents the execution of subsequent commands until it completes.")
        @CommandExamples({ "<Server port='type:integer' request='type:property' response='type:property' > ... </Server>",
                        "<Server port='type:integer' numbers='type:integer' request='type:property' response='type:property' > ... </Server>" })
        public void runCommandServer(final Node aCurrentAction) throws Throwable {

                String encoding = replaceProperties(aCurrentAction.getAttribute("charset"));
                if (encoding == null) {
                        encoding = "UTF-8";
                }

                final int thePort = Integer.parseInt(replaceProperties(aCurrentAction.getAttribute("port")));
                int maxNumber = 0;

                final String theMaxNumbers = replaceProperties(aCurrentAction.getAttribute("numbers"));
                if (theMaxNumbers != null) {
                        maxNumber = Integer.parseInt(theMaxNumbers);
                }
                final String request = attr(aCurrentAction, "request");
                final String response = attr(aCurrentAction, "response");

                ServerAction server = new ServerAction(this, aCurrentAction, thePort, request, response, encoding, maxNumber);
                server.perform();
        }

        @CommandExamples({ "<Restore/>", "<Restore name='type:property'> ... </Restore>",
                        "<Restore except='type:property'> ... </Restore>" })
        public void runCommandRestore(final Node command) throws Throwable {
                String name = attr(command, "name");
                String except = attr(command, "except");

                if (CollectionUtils.isEmpty(command)) {
                        final Map<String, Object> systemVariables = getListener().getManager().getSystemVariables();
                        this.variables.clear();
                        this.variables.putAll(systemVariables);
                        debug("Task variables has been restored.");
                } else if (name != null) {
                        Object savedVariable = getVariableValue(name);
                        taskNode(command, false);
                        setVariableValue(name, savedVariable);

                } else if (except != null) {
                        Map<String, Object> savedVariables = this.variables;
                        this.variables = new HashMap<String, Object>(this.variables);

                        taskNode(command, false);

                        Object object = getVariableValue(except);
                        this.variables.clear();
                        this.variables = savedVariables;
                        setVariableValue(except, object);
                }

        }

        @CommandDescription("Use the Finally command tag before protected code to ensure it is executed "
                        + "before exiting the current parent tag, as usual Finally is defined as a first executable command.\n"
                        + "Example: `<Recipe><Finally> ...finally code... </Finally> ...some code... </Recipe>`")
        @CommandExamples({ "<Finally> ... </Finally>" })
        public void runCommandFinally(final Node aCurrentAction) throws Throwable {
        }

        @CommandExamples({ "<Break/>" })
        public void runCommandBreak(final Node aCurrentAction) throws Throwable {
        }

        @CommandExamples({ "<Stop/>", "<Stop ifNull='type:property'/>" })
        public void runCommandStop(final Node aCurrentAction) throws Throwable {
        }

        private boolean isEmpty(Object theOldValue) {
                boolean result = false;
                if (theOldValue == null) {
                        result = true;
                } else if (theOldValue instanceof String[] && ((String[]) theOldValue).length == 0) {
                        result = true;
                } else if (theOldValue instanceof Map && ((Map) theOldValue).size() == 0) {
                        result = true;
                }
                return result;
        }

        public void setVariableValue(String name, final Object value) {
                if (name != null) {
                        super.setVariableValue(name, value);
                        if (this.recipeListener != null && name.startsWith("!") == false) {
                                this.recipeListener.changeVariable(name, value);
                        }
                }
        }

}