/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to you under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.apache.jmeter.extractor;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import org.apache.commons.lang3.StringUtils;
import org.apache.commons.text.StringEscapeUtils;
import org.apache.jmeter.processor.PostProcessor;
import org.apache.jmeter.samplers.SampleResult;
import org.apache.jmeter.testelement.AbstractScopedTestElement;
import org.apache.jmeter.testelement.property.IntegerProperty;
import org.apache.jmeter.threads.JMeterContext;
import org.apache.jmeter.threads.JMeterVariables;
import org.apache.jmeter.util.Document;
import org.apache.jmeter.util.JMeterUtils;
import org.jetbrains.annotations.VisibleForTesting;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Extracts Strings from a text response between a start and end boundary.
 */
public class BoundaryExtractor extends AbstractScopedTestElement implements PostProcessor, Serializable {

    private static final Logger log = LoggerFactory.getLogger(BoundaryExtractor.class);

    private static final long serialVersionUID = 2L;

    private static final String REFNAME = "BoundaryExtractor.refname"; // $NON-NLS-1$
    private static final String MATCH_NUMBER = "BoundaryExtractor.match_number"; // $NON-NLS-1$
    private static final String L_BOUNDARY = "BoundaryExtractor.lboundary"; // $NON-NLS-1$
    private static final String R_BOUNDARY = "BoundaryExtractor.rboundary"; // $NON-NLS-1$
    private static final String DEFAULT_EMPTY_VALUE = "BoundaryExtractor.default_empty_value"; // $NON-NLS-1$
    private static final String DEFAULT = "BoundaryExtractor.default"; // $NON-NLS-1$
    private static final String REF_MATCH_NR = "_matchNr"; // $NON-NLS-1$
    private static final char UNDERSCORE = '_';  // $NON-NLS-1$

    // What to match against. N.B. do not change the string value or test plans will break!
    private static final String MATCH_AGAINST = "BoundaryExtractor.useHeaders"; // $NON-NLS-1$
    /*
     * Permissible values:
     *  true - match against headers
     *  false or absent - match against body (this was the original default)
     *  URL - match against URL
     *  These are passed to the setUseField() method
     *
     *  Do not change these values!
     */
    private static final String USE_HDRS = "true"; // $NON-NLS-1$
    private static final String USE_REQUEST_HDRS = "request_headers"; // $NON-NLS-1$
    private static final String USE_BODY = "false"; // $NON-NLS-1$
    private static final String USE_BODY_UNESCAPED = "unescaped"; // $NON-NLS-1$
    private static final String USE_BODY_AS_DOCUMENT = "as_document"; // $NON-NLS-1$
    private static final String USE_URL = "URL"; // $NON-NLS-1$
    private static final String USE_CODE = "code"; // $NON-NLS-1$
    private static final String USE_MESSAGE = "message"; // $NON-NLS-1$

    /**
     * Parses the response data using Boundaries and saving the results
     * into variables for use later in the test.
     *
     * @see PostProcessor#process()
     */
    @Override
    public void process() {
        JMeterContext context = getThreadContext();
        SampleResult previousResult = context.getPreviousResult();
        if (previousResult == null) {
            return;
        }
        if (log.isDebugEnabled()) {
            log.debug("Boundary Extractor {}: processing result", getName());
        }
        if (StringUtils.isEmpty(getRefName())) {
            throw new IllegalArgumentException(
                    "One of the mandatory properties is missing in Boundary Extractor:" + getName());
        }

        JMeterVariables vars = context.getVariables();

        String refName = getRefName();
        final String defaultValue = getDefaultValue();

        if (StringUtils.isNotBlank(defaultValue) || isEmptyDefaultValue()) {
            vars.put(refName, defaultValue);
        }

        int matchNumber = getMatchNumber();
        int prevCount = 0;
        int matchCount = 0;
        try {
            prevCount = removePrevCount(vars, refName);
            List<String> matches = extractMatches(previousResult, vars, matchNumber);
            matchCount = saveMatches(vars, refName, matchNumber, matches);
        } catch (RuntimeException e) { // NOSONAR
            if (log.isWarnEnabled()) {
                log.warn("{}: Error while generating result. {}", getName(), e.toString()); // NOSONAR We don't want to be too verbose
            }
        } finally {
            // Remove any left-over variables
            for (int i = matchCount + 1; i <= prevCount; i++) {
                vars.remove(refName + UNDERSCORE + i);
            }
        }
    }

    private int removePrevCount(JMeterVariables vars, String refName) {
        int prevCount = 0;
        String prevString = vars.get(refName + REF_MATCH_NR);
        if (prevString != null) {
            // ensure old value is not left defined
            vars.remove(refName + REF_MATCH_NR);
            try {
                prevCount = Integer.parseInt(prevString);
            } catch (NumberFormatException nfe) {
                if (log.isWarnEnabled()) {
                    log.warn("{}: Could not parse number: '{}'.", getName(), prevString);
                }
            }
        }
        return prevCount;
    }

    private List<String> extractMatches(SampleResult previousResult, JMeterVariables vars, int matchNumber) {
        if (isScopeVariable()) {
            String inputString = vars.get(getVariableName());
            if (inputString == null && log.isWarnEnabled()) {
                log.warn("No variable '{}' found to process by Boundary Extractor '{}', skipping processing",
                        getVariableName(), getName());
            }
            return extract(getLeftBoundary(), getRightBoundary(), matchNumber, inputString);
        } else {
            Stream<String> inputs = getSampleList(previousResult).stream().map(this::getInputString);
            return extract(getLeftBoundary(), getRightBoundary(), matchNumber, inputs);
        }
    }

    /**
     * @param vars {@link JMeterVariables}
     * @param refName Var name
     * @param matchNumber number of matches
     * @param matches List of String
     * @return 0 if there is only one match, else the number of matches, this is used to remove
     */
    private static int saveMatches(JMeterVariables vars, String refName, int matchNumber, List<String> matches) {
        if (matchNumber >=0 && matches.isEmpty()) {
            return 0;
        }
        int matchCount = 0;
        if (matchNumber == 0) {
            saveRandomMatch(vars, refName, matches);
        } else if (matchNumber > 0) {
            saveOneMatch(vars, refName, matches);
        } else {
            matchCount = matches.size();
            saveAllMatches(vars, refName, matches);
        }
        return matchCount;
    }

    private static void saveRandomMatch(JMeterVariables vars, String refName, List<String> matches) {
        String match = matches.get(JMeterUtils.getRandomInt(matches.size()));
        if (match != null) {
            vars.put(refName, match);
        }
    }

    private static void saveOneMatch(JMeterVariables vars, String refName, List<String> matches) {
        if (matches.size() == 1) { // if not then invalid matchNum was likely supplied
            String match = matches.get(0);
            if (match != null) {
                vars.put(refName, match);
            }
        }
    }

    private static void saveAllMatches(JMeterVariables vars, String refName, List<String> matches) {
        vars.put(refName + REF_MATCH_NR, Integer.toString(matches.size()));
        for (int i = 0; i < matches.size(); i++) {
            String match = matches.get(i);
            if (match != null) {
                int varNum = i + 1;
                vars.put(refName + UNDERSCORE + varNum, match);
            }
        }
    }

    private String getInputString(SampleResult result) {
        String inputString = chosenInput(result);
        log.debug("Input = '{}'", inputString);
        return inputString;
    }

    private String chosenInput(SampleResult result) {
        if (useUrl()) {
            return result.getUrlAsString(); // Bug 39707;
        }
        if (useHeaders()) {
            return result.getResponseHeaders();
        }
        if (useRequestHeaders()) {
            return result.getRequestHeaders();
        }
        if (useCode()) {
            return result.getResponseCode(); // Bug 43451
        }
        if (useMessage()) {
            return result.getResponseMessage(); // Bug 43451
        }
        if (useUnescapedBody()) {
            return StringEscapeUtils.unescapeHtml4(result.getResponseDataAsString());
        }
        if (useBodyAsDocument()) {
            return Document.getTextFromDocument(result.getResponseData());
        }
        return result.getResponseDataAsString(); // Bug 36898
    }

    @VisibleForTesting
    static List<String> extract(
            String leftBoundary, String rightBoundary, int matchNumber, Stream<String> previousResults) {
        boolean allItems = matchNumber <= 0;
        return previousResults
                .flatMap(input -> extract(leftBoundary, rightBoundary, input).stream())
                .skip(allItems ? 0L : matchNumber - 1)
                .limit(allItems ? Long.MAX_VALUE : 1L)
                .collect(Collectors.toList());
    }

    /**
     * Extracts text fragments, that are between the boundaries, into {@code result}.
     * The number of extracted fragments can be controlled by {@code matchNumber}
     *
     * @param leftBoundary  fragment representing the left boundary of the searched text
     * @param rightBoundary fragment representing the right boundary of the searched text
     * @param matchNumber   if {@code <=0}, all found matches will be returned, else only
     *                      up to {@code matchNumber} matches
     * @param inputString   text in which to look for the fragments
     * @return list where the found text fragments will be placed
     */
    @VisibleForTesting
    static List<String> extract(String leftBoundary, String rightBoundary, int matchNumber, String inputString) {
        if (StringUtils.isBlank(inputString)) {
            return Collections.emptyList();
        }
        boolean isEmptyLeftBoundary = StringUtils.isEmpty(leftBoundary);
        boolean isEmptyRightBoundary = StringUtils.isEmpty(rightBoundary);
        if (isEmptyLeftBoundary && isEmptyRightBoundary) {
            return Collections.singletonList(inputString);
        }
        if (isEmptyLeftBoundary) {
            int rightBoundaryIndex = inputString.indexOf(rightBoundary);
            if (rightBoundaryIndex != -1) {
                return Collections.singletonList(inputString.substring(0, rightBoundaryIndex));
            }
        }
        if (isEmptyRightBoundary) {
            int leftBoundaryIndex = inputString.indexOf(leftBoundary);
            if (leftBoundaryIndex != -1) {
                return Collections.singletonList(inputString.substring(leftBoundaryIndex + leftBoundary.length()));
            }
        }
        List<String> matches = new ArrayList<>();
        int leftBoundaryLen = leftBoundary.length();
        boolean collectAll = matchNumber <= 0;
        int found = 0;

        for (int startIndex = 0;
             (startIndex = inputString.indexOf(leftBoundary, startIndex)) != -1;
             startIndex += leftBoundaryLen) {
            int endIndex = inputString.indexOf(rightBoundary, startIndex + leftBoundaryLen);
            if (endIndex >= 0) {
                found++;
                if (collectAll) {
                    matches.add(inputString.substring(startIndex + leftBoundaryLen, endIndex));
                } else if (found == matchNumber) {
                    return Collections.singletonList(inputString.substring(startIndex + leftBoundaryLen, endIndex));
                }
            } else {
                break;
            }
        }

        return Collections.unmodifiableList(matches);
    }

    public List<String> extractAll(
            String leftBoundary, String rightBoundary, String textToParse) {
        return extract(leftBoundary, rightBoundary, textToParse);
    }

    private static List<String> extract(
            String leftBoundary, String rightBoundary, String textToParse) {
        return extract(leftBoundary, rightBoundary, -1, textToParse);
    }

    public void setRefName(String refName) {
        setProperty(REFNAME, refName);
    }

    public String getRefName() {
        return getPropertyAsString(REFNAME);
    }

    /**
     * Set which Match to use. This can be any positive number, indicating the
     * exact match to use, or <code>0</code>, which is interpreted as meaning random.
     *
     * @param matchNumber The number of the match to be used
     */
    public void setMatchNumber(int matchNumber) {
        setProperty(new IntegerProperty(MATCH_NUMBER, matchNumber));
    }

    public void setMatchNumber(String matchNumber) {
        setProperty(MATCH_NUMBER, matchNumber);
    }

    public int getMatchNumber() {
        return getPropertyAsInt(MATCH_NUMBER);
    }

    public String getMatchNumberAsString() {
        return getPropertyAsString(MATCH_NUMBER);
    }

    public void setLeftBoundary(String leftBoundary) {
        setProperty(L_BOUNDARY, leftBoundary);
    }

    public String getLeftBoundary() {
        return getPropertyAsString(L_BOUNDARY);
    }

    public void setRightBoundary(String rightBoundary) {
        setProperty(R_BOUNDARY, rightBoundary);
    }

    public String getRightBoundary() {
        return getPropertyAsString(R_BOUNDARY);
    }

    /**
     * Sets the value of the variable if no matches are found
     *
     * @param defaultValue The default value for the variable
     */
    public void setDefaultValue(String defaultValue) {
        setProperty(DEFAULT, defaultValue);
    }

    /**
     * @param defaultEmptyValue boolean set value to "" if not found
     */
    public void setDefaultEmptyValue(boolean defaultEmptyValue) {
        setProperty(DEFAULT_EMPTY_VALUE, defaultEmptyValue);
    }

    /**
     * Get the default value for the variable if no matches are found
     *
     * @return The default value for the variable
     */
    public String getDefaultValue() {
        return getPropertyAsString(DEFAULT);
    }

    /**
     * @return boolean set value to "" if not found
     */
    public boolean isEmptyDefaultValue() {
        return getPropertyAsBoolean(DEFAULT_EMPTY_VALUE);
    }

    public boolean useHeaders() {
        return USE_HDRS.equalsIgnoreCase(getPropertyAsString(MATCH_AGAINST));
    }

    public boolean useRequestHeaders() {
        return USE_REQUEST_HDRS.equalsIgnoreCase(getPropertyAsString(MATCH_AGAINST));
    }

    public boolean useBody() {
        String prop = getPropertyAsString(MATCH_AGAINST);
        return prop.length() == 0 || USE_BODY.equalsIgnoreCase(prop);
    }

    public boolean useUnescapedBody() {
        String prop = getPropertyAsString(MATCH_AGAINST);
        return USE_BODY_UNESCAPED.equalsIgnoreCase(prop);
    }

    public boolean useBodyAsDocument() {
        String prop = getPropertyAsString(MATCH_AGAINST);
        return USE_BODY_AS_DOCUMENT.equalsIgnoreCase(prop);
    }

    public boolean useUrl() {
        String prop = getPropertyAsString(MATCH_AGAINST);
        return USE_URL.equalsIgnoreCase(prop);
    }

    public boolean useCode() {
        String prop = getPropertyAsString(MATCH_AGAINST);
        return USE_CODE.equalsIgnoreCase(prop);
    }

    public boolean useMessage() {
        String prop = getPropertyAsString(MATCH_AGAINST);
        return USE_MESSAGE.equalsIgnoreCase(prop);
    }

    public void setUseField(String actionCommand) {
        setProperty(MATCH_AGAINST, actionCommand);
    }
}
