#include <fuzzer/FuzzedDataProvider.h>
#include <string>

#include "jq.h"
#include "jv.h"


const char *jq_progs[] = {
    ". / \", \"",
    ".[]",
    "$ENV.PAGER",
    ".[0]",
    ". < 0.12345678901234567890123456788",
    ".[] == 1",
    ".[] | (1 / .)?",
    "10 / . * 3",
    "[1,2,empty,3]",
    "1, empty, 2",
    "[.,1]|until(.[0] < 1; [.[0] - 1, .[1] * .[0]])|.[1]",
    ".[-2:]",
    ".[-2]",
    ".[2]",
    "[ .[] | . * 2]",
    ".[2:4]",
    "(. + 2) * 5",
    ".[:3]",
    ".[4,2]",
    "42 and \"a string\"",
    "4 - .a",
    ". < 5",
    ".. | .a?",
    "[.[] | .a?]",
    ".a + 1",
    "{a: 1} + {b: 2} + {c: 3} + {a: 42}",
    ".a + .b",
    ".a = .b",
    ".a |= .b",
    "add",
    "all",
    ".a + null",
    "any",
    ".[] as [$a, $b] | {a: $a, b: $b}",
    ". as [$a, $b, {c: $c}] | $a + $b + $c",
    ".[] as {$a, $b, c: {$d}} ?// {$a, $b, c: [{$e}]} | {$a, $b, $d, $e}",
    ".[] as {$a, $b, c: {$d, $e}} ?// {$a, $b, c: [{$d, $e}]} | {$a, $b, "
    "$d, $e}",
    ".[] as [$a] ?// [$b] | if $a != null then error(\"err: \\($a)\") else "
    "{$a,$b} end",
    ". as $big | [$big, $big + 1] | map(. > "
    "10000000000000000000000000000000)",
    ". as $dot|fromstream($dot|tostream)|.==$dot",
    ". as $i|[(.*2|. as $i| $i), $i]",
    "ascii_upcase",
    ".bar as $x | .foo | . + $x",
    "@base64",
    "@base64d",
    ". == {\"b\": {\"d\": (4 + 1e-20), \"c\": 3}, \"a\":1}",
    "bsearch(0)",
    "bsearch(4) as $ix | if $ix < 0 then .[-(1+$ix)] = 4 else . end",
    "capture(\"(?<a>[a-z]+)-(?<n>[0-9]+)\")",
    "capture(\"(?<a>[a-z]+)-(?<n>[0-9]+)\")",
    "combinations",
    "combinations(2)",
    "contains(\"bar\")",
    "contains([\"baz\", \"bar\"])",
    "contains([\"bazzzzz\", \"bar\"])",
    "contains({foo: 12, bar: [{barp: 15}]})",
    "def addvalue(f): f as $x | map(. + $x); addvalue(.[0])",
    "def addvalue(f): . + [f]; map(addvalue(.[0]))",
    "def while(cond; update): def _while: if cond then ., (update | "
    "_while) else empty end; _while; [while(.<100; .*2)]",
    "del(.[1, 2])",
    "del(.foo)",
    "delpaths([[\"a\",\"b\"]])",
    "empty // 42",
    "[.[]|endswith(\"foo\")]",
    "env.PAGER",
    "explode",
    ". == false",
    "(false, null, 1) // 42",
    "(false, null, 1) | . // 42",
    "flatten",
    "flatten(1)",
    "floor",
    ".[\"foo\"]",
    ".[\"foo\"]?",
    ".foo",
    ".foo?",
    ".foo[]",
    "[.foo?]",
    ".foo += 1",
    ".foo // 42",
    ".foo, .bar",
    "foreach .[] as $item (0; . + $item)",
    "foreach .[] as $item (0; . + $item; [$item, . * 2])",
    "foreach .[] as $item (0; . + 1; {index: ., $item})",
    "fromdate",
    "from_entries",
    "fromstream(1|truncate_stream([[0],1],[[1,0],2],[[1,0]],[[1]]))",
    "getpath([\"a\",\"b\"])",
    "[getpath([\"a\",\"b\"], [\"a\",\"c\"])]",
    "group_by(.foo)",
    "[.[] | gsub(\", \"; \":\")]",
    "gsub(\"$\"; \"a\"; \"g\")",
    "gsub(\"^\"; \"a\")",
    "[gsub(\"(?<a>.)\"; \"\\(.a|ascii_upcase)\", \"\\(.a|ascii_downcase)\", "
    "\"c\")]",
    "gsub(\"^.*?a\"; \"b\")",
    "gsub(\"^.*a\"; \"b\")",
    "gsub(\"a\";\"b\")",
    "gsub(\"\"; \"a\"; \"g\")",
    "gsub(\"\"; \"a\"; \"g\")",
    "gsub(\"[^a-z]*(?<x>[a-z]*)\"; \"Z\\(.x)\")",
    "gsub(\"\\b(?<x>.)\"; \"\\(.x|ascii_downcase)\")",
    "gsub(\"(?<d>\\d)\"; \":\\(.d);\")",
    "gsub(\"^\"; \"\"; \"g\")",
    "[gsub(\"p\"; \"a\", \"b\")]",
    "gsub(\"(?=u)\"; \"u\")",
    "gsub(\"(.*)\"; \"\"; \"x\")",
    "gsub(\"(?<x>.)[^a]*\"; \"+\\(.x)-\")",
    "gsub(\"(?<x>.)(?<y>[0-9])\"; \"\\(.x|ascii_downcase)\\(.y)\")",
    "@html",
    "if . == 0 then   \"zero\" elif . == 1 then   \"one\" else   \"many\" "
    "end",
    "implode",
    "index(\", \")",
    "index(1)",
    "index([1,2])",
    "indices(\", \")",
    "indices(1)",
    "indices([1,2])",
    ".[] | (infinite * .) < 0",
    "infinite, nan | type",
    ".[] | in({\"foo\": 42})",
    "inside({\"foo\": 12, \"bar\":[1,2,{\"barp\":12, \"blip\":13}]})",
    "inside({\"foo\": 12, \"bar\":[1,2,{\"barp\":12, \"blip\":13}]})",
    "inside(\"foobar\")",
    "inside([\"foobar\", \"foobaz\", \"blarp\"])",
    "inside([\"foobar\", \"foobaz\", \"blarp\"])",
    "isempty(.[])",
    "isempty(.[])",
    "isempty(empty)",
    "join(\" \")",
    "join(\", \")",
    "keys",
    "keys",
    ".[] | length",
    "[limit(3;.[])]",
    "[.[]|ltrimstr(\"foo\")]",
    "map(., .)",
    "map(.+1)",
    "map([., . == 1]) | tojson",
    "map(abs)",
    "map(has(2))",
    "map(has(\"foo\"))",
    "map(in([0,1]))",
    "map(select(. >= 2))",
    "map(type)",
    "map_values(.+1)",
    "map_values(. // empty)",
    "match(\"(abc)+\"; \"g\")",
    "[match(\"a\"; \"gi\")]",
    "[match(\".+?\\b\")]",
    "[match([\"(bar)\"])]",
    "match(\"foo\")",
    "[match([\"foo (?<bar123>bar)? foo\", \"ig\"])]",
    "match(\"foo (?<bar123>bar)? foo\"; \"ig\")",
    "match([\"foo\", \"ig\"])",
    "[match(\"\"; \"g\")]",
    "[ match(\".\"; \"g\")] | length",
    "[match(\"( )*\"; \"gn\")]",
    "max_by(.foo)",
    "min",
    ".[] | .name",
    ".[]|numbers",
    "[path(..)]",
    "path(.a[0].b)",
    "[paths]",
    "[paths(type == \"number\")]",
    "pick(.[2], .[0], .[0])",
    "pick(.a, .b.c, .x)",
    "[range(0; 10; -1)]",
    "[range(0; 10; 3)]",
    "[range(0; -5; -1)]",
    "[range(2; 4)]",
    "range(2; 4)",
    "[range(4)]",
    "[range(.)]|[first, last, nth(5)]",
    "recurse",
    "recurse(. * .; . < 20)",
    "recurse(.foo[])",
    "reduce .[] as [$i,$j] (0; . + $i * $j)",
    "reduce .[] as $item (0; . + $item)",
    "reduce .[] as {$x,$y} (null; .x += $x | .y += [$y])",
    "[repeat(.*2, error)?]",
    "reverse",
    "rindex(\", \")",
    "rindex(1)",
    "rindex([1,2])",
    "[.[]|rtrimstr(\"foo\")]",
    "[.[] | scan(\", \")]",
    "[.[] | scan(\"b+\"; \"i\")]",
    "scan(\"c\")",
    ".[] | select(.id == \"second\")",
    "(..|select(type==\"boolean\")) |= if . then 1 else 0 end",
    "setpath([0,\"a\"]; 1)",
    "setpath([\"a\",\"b\"]; 1)",
    "setpath([\"a\",\"b\"]; 1)",
    "@sh \"echo \\(.)\"",
    "sort",
    "sort_by(.foo)",
    "sort_by(.foo, .bar)",
    "split(\", *\"; null)",
    "splits(\", *\")",
    "sqrt",
    "[.[]|startswith(\"foo\")]",
    "strptime(\"%Y-%m-%dT%H:%M:%SZ\")",
    "strptime(\"%Y-%m-%dT%H:%M:%SZ\")|mktime",
    "[sub(\"(?<a>.)\"; \"\\(.a|ascii_upcase)\", \"\\(.a|ascii_downcase)\")]",
    "[sub(\"(?<a>.)\"; \"\\(.a|ascii_upcase)\", \"\\(.a|ascii_downcase)\", "
    "\"c\")]",
    "[sub(\"a\"; \"b\", \"c\")]",
    "sub(\"[^a-z]*(?<x>[a-z]+)\"; \"Z\\(.x)\"; \"g\")",
    "[.[]|[[sub(\", *\";\":\")], [gsub(\", *\";\":\")], [scan(\", *\")]]]",
    "[.[]|[[sub(\", +\";\":\")], [gsub(\", +\";\":\")], [scan(\", +\")]]]",
    "sub(\"^(?<head>.)\"; \"Head=\\(.head) Tail=\")",
    "[test(\"ā\")]",
    ".[] | test(\"a b c # spaces are ignored\"; \"ix\")",
    "test(\"foo\")",
    "to_entries",
    "[., tojson]",
    "[.[]|tojson]",
    "[.[]|tojson|fromjson]",
    ".[] | tonumber",
    "[.[] | tonumber?]",
    ".[] | tostring",
    "[.[]|tostring]",
    "transpose",
    "[true, false | not]",
    "(true, false) or false",
    "(true, true) and (true, false)",
    "truncate_stream([[0],1],[[1,0],2],[[1,0]],[[1]])",
    "[.[]|try .a]",
    "unique",
    "unique_by(.foo)",
    "unique_by(length)",
    ".user, .projects[]",
    "[.user, .projects[]]",
    "{(.user): .titles}",
    "{user, title: .titles[]}",
    "utf8bytelength",
    "walk(if type == \"array\" then sort else . end)",
    "walk( if type == \"object\" then with_entries( .key |= sub( \"^_+\"; "
    "\"\") ) else . end )",
    "[while(.<100; .*2)]",
    "with_entries(.key |= \"KEY_\" + .)",
    ". - [\"xml\", \"yaml\"]",
};

// Fuzzer inspired by /src/jq_test.c
// The goal is to have the fuzzer execute the functions:
// jq_compile -> jv_parse -> jq_next.
extern "C" int LLVMFuzzerTestOneInput(uint8_t *data, size_t size) {
  FuzzedDataProvider fdp(data, size);
  std::string parse_payload1 = fdp.ConsumeRandomLengthString();
  std::string parse_payload2 = fdp.ConsumeRandomLengthString();

  int idx = fdp.ConsumeIntegralInRange<int>(
      0, (sizeof(jq_progs) / sizeof(char *)) - 1);

  jq_state *jq = NULL;
  jq = jq_init();
  if (jq != NULL) {
    jq_set_attr(jq, jv_string("JQ_ORIGIN"), jv_string("/tmp/"));

    if (jq_compile(jq, jq_progs[idx])) {
      // Process to jv_parse and then jv_next
      jv input = jv_parse(parse_payload1.c_str());
      if (jv_is_valid(input)) {
        jq_start(jq, input, 0);
        jv next = jv_parse(parse_payload2.c_str());
        if (jv_is_valid(next)) {
          jv actual = jq_next(jq);
          jv_free(actual);
        }
        jv_free(next);
      } else {
        // Only free if input is invalid as otherwise jq_teardown
        // frees it.
        jv_free(input);
      }
    }
  }
  jq_teardown(&jq);

  return 0;
}