// 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.

// This file is copied from

// https://github.com/apache/impala/blob/branch-2.9.0/be/src/exprs/string-functions.cpp

// and modified by Doris

#include "exprs/string_functions.h"

#include <re2/re2.h>

#include <re2/stringpiece.h>

#include <sstream>

#include "util/string_util.h"

// NOTE: be careful not to use string::append.  It is not performant.

namespace doris {

// This function sets options in the RE2 library before pattern matching.

bool StringFunctions::set_re2_options(const StringRef& match_parameter, std::string* error_str,

                                      re2::RE2::Options* opts) {

    for (int i = 0; i < match_parameter.size; i++) {

        char match = match_parameter.data[i];

        switch (match) {

        case 'i':

            opts->set_case_sensitive(false);

            break;

        case 'c':

            opts->set_case_sensitive(true);

            break;

        case 'm':

            opts->set_posix_syntax(true);

            opts->set_one_line(false);

            break;

        case 'n':

            opts->set_never_nl(false);

            opts->set_dot_nl(true);

            break;

        default:

            std::stringstream error;

            error << "Illegal match parameter " << match;

            *error_str = error.str();

            return false;

        }

    }

    return true;

}

// The caller owns the returned regex. Returns nullptr if the pattern could not be compiled.

bool StringFunctions::compile_regex(const StringRef& pattern, std::string* error_str,

                                    const StringRef& match_parameter,

                                    const StringRef& options_value, std::unique_ptr<re2::RE2>& re) {

    re2::StringPiece pattern_sp(pattern.data, pattern.size);

    re2::RE2::Options options;

    // Disable error logging in case e.g. every row causes an error

    options.set_log_errors(false);

    // ATTN(cmy): no set it, or the lazy mode of regex won't work. See Doris #6587

    // Return the leftmost longest match (rather than the first match).

    // options.set_longest_match(true);

    options.set_dot_nl(true);

    if ((options_value.data != nullptr) && (options_value.size > 0)) {

        auto options_split = split(options_value.to_string(), ",");

        for (const auto& option : options_split) {

            if (iequal("ignore_invalid_escape", option)) {

                options.set_ignore_replace_escape(true);

            } else {

                // "none" do nothing, and could add more options for future extensibility.

            }

        }

    }

    if (match_parameter.size > 0 &&

        !StringFunctions::set_re2_options(match_parameter, error_str, &options)) {

        return false;

    }

    re.reset(new re2::RE2(pattern_sp, options));

    if (!re->ok()) {

        std::stringstream ss;

        ss << "Could not compile regexp pattern: " << std::string(pattern.data, pattern.size)

           << std::endl

           << "Error: " << re->error();

        *error_str = ss.str();

        re.reset();

        return false;

    }

    return true;

}

} // namespace doris