// Copyright 2021 The Tint Authors.
//
// Licensed 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.

#include "fuzzers/tint_regex_fuzzer/wgsl_mutator.h"

#include <cassert>
#include <cstring>
#include <iostream>
#include <map>
#include <random>
#include <regex>
#include <string>
#include <utility>
#include <vector>

namespace tint {
namespace fuzzers {
namespace regex_fuzzer {

namespace {

size_t GetRandomIntFromRange(size_t lower_bound,
                             size_t upper_bound,
                             std::mt19937& generator) {
  std::uniform_int_distribution<size_t> dist(lower_bound, upper_bound);
  return dist(generator);
}

}  //  namespace

std::vector<size_t> FindDelimiterIndices(const std::string& delimiter,
                                         const std::string& wgsl_code) {
  std::vector<size_t> result;
  for (size_t pos = wgsl_code.find(delimiter, 0); pos != std::string::npos;
       pos = wgsl_code.find(delimiter, pos + 1)) {
    result.push_back(pos);
  }

  return result;
}

void SwapIntervals(size_t idx1,
                   size_t idx2,
                   size_t idx3,
                   size_t idx4,
                   std::string& wgsl_code) {
  std::string region_1 = wgsl_code.substr(idx1, idx2 - idx1 + 1);

  std::string region_2 = wgsl_code.substr(idx3, idx4 - idx3 + 1);

  // The second transformation is done first as it doesn't affect ind1 and ind2
  wgsl_code.replace(idx3, region_2.size(), region_1);

  wgsl_code.replace(idx1, region_1.size(), region_2);
}

void DeleteInterval(size_t idx1, size_t idx2, std::string& wgsl_code) {
  wgsl_code.erase(idx1, idx2 - idx1 + 1);
}

void DuplicateInterval(size_t idx1,
                       size_t idx2,
                       size_t idx3,
                       std::string& wgsl_code) {
  std::string region = wgsl_code.substr(idx1, idx2 - idx1 + 1);
  wgsl_code.insert(idx3 + 1, region);
}

bool SwapRandomIntervals(const std::string& delimiter,
                         std::string& wgsl_code,
                         std::mt19937& generator) {
  std::vector<size_t> delimiter_positions =
      FindDelimiterIndices(delimiter, wgsl_code);

  // Need to have at least 3 indices
  if (delimiter_positions.size() < 3) {
    return false;
  }

  // When generating the i-th random number, we should make sure that there are
  // at least (3-i) numbers greater than this number.
  size_t ind1 =
      GetRandomIntFromRange(0, delimiter_positions.size() - 3U, generator);
  size_t ind2 = GetRandomIntFromRange(
      ind1 + 1U, delimiter_positions.size() - 2U, generator);
  size_t ind3 =
      GetRandomIntFromRange(ind2, delimiter_positions.size() - 2U, generator);
  size_t ind4 = GetRandomIntFromRange(
      ind3 + 1U, delimiter_positions.size() - 1U, generator);

  SwapIntervals(delimiter_positions[ind1], delimiter_positions[ind2],
                delimiter_positions[ind3], delimiter_positions[ind4],
                wgsl_code);

  return true;
}

bool DeleteRandomInterval(const std::string& delimiter,
                          std::string& wgsl_code,
                          std::mt19937& generator) {
  std::vector<size_t> delimiter_positions =
      FindDelimiterIndices(delimiter, wgsl_code);

  // Need to have at least 2 indices
  if (delimiter_positions.size() < 2) {
    return false;
  }

  size_t ind1 =
      GetRandomIntFromRange(0, delimiter_positions.size() - 2U, generator);
  size_t ind2 = GetRandomIntFromRange(
      ind1 + 1U, delimiter_positions.size() - 1U, generator);

  DeleteInterval(delimiter_positions[ind1], delimiter_positions[ind2],
                 wgsl_code);

  return true;
}

bool DuplicateRandomInterval(const std::string& delimiter,
                             std::string& wgsl_code,
                             std::mt19937& generator) {
  std::vector<size_t> delimiter_positions =
      FindDelimiterIndices(delimiter, wgsl_code);

  // Need to have at least 2 indices
  if (delimiter_positions.size() < 2) {
    return false;
  }

  size_t ind1 =
      GetRandomIntFromRange(0, delimiter_positions.size() - 2U, generator);
  size_t ind2 = GetRandomIntFromRange(
      ind1 + 1U, delimiter_positions.size() - 1U, generator);

  size_t ind3 =
      GetRandomIntFromRange(0, delimiter_positions.size() - 1U, generator);

  DuplicateInterval(delimiter_positions[ind1], delimiter_positions[ind2],
                    delimiter_positions[ind3] + 1, wgsl_code);

  return true;
}

}  // namespace regex_fuzzer
}  // namespace fuzzers
}  // namespace tint