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


#define C_TESTLUCY_TESTREVERSETYPE
#define TESTLUCY_USE_SHORT_NAMES
#include "Lucy/Util/ToolSet.h"
#include <stdio.h>
#include <stdlib.h>

#include "charmony.h"

#include "Clownfish/TestHarness/TestBatchRunner.h"
#include "Clownfish/TestHarness/TestUtils.h"
#include "Lucy/Test.h"
#include "Lucy/Test/Search/TestSortSpec.h"
#include "Lucy/Test/TestUtils.h"
#include "Lucy/Search/SortSpec.h"

#include "Clownfish/CharBuf.h"
#include "Clownfish/Num.h"
#include "Lucy/Analysis/StandardTokenizer.h"
#include "Lucy/Document/Doc.h"
#include "Lucy/Document/HitDoc.h"
#include "Lucy/Index/Indexer.h"
#include "Lucy/Plan/FullTextType.h"
#include "Lucy/Plan/NumericType.h"
#include "Lucy/Plan/Schema.h"
#include "Lucy/Plan/StringType.h"
#include "Lucy/Search/Hits.h"
#include "Lucy/Search/IndexSearcher.h"
#include "Lucy/Search/SortRule.h"
#include "Lucy/Store/RAMFolder.h"

static String *air_str;
static String *airplane_str;
static String *bike_str;
static String *car_str;
static String *carrot_str;
static String *cat_str;
static String *float32_str;
static String *float64_str;
static String *food_str;
static String *home_str;
static String *int32_str;
static String *int64_str;
static String *land_str;
static String *name_str;
static String *nope_str;
static String *num_str;
static String *random_str;
static String *sloth_str;
static String *speed_str;
static String *unknown_str;
static String *unused_str;
static String *vehicle_str;
static String *weight_str;

static String *random_float32s_str;
static String *random_float64s_str;
static String *random_int32s_str;
static String *random_int64s_str;

TestSortSpec*
TestSortSpec_new() {
    return (TestSortSpec*)Class_Make_Obj(TESTSORTSPEC);
}

static void
S_init_strings() {
    air_str      = Str_newf("air");
    airplane_str = Str_newf("airplane");
    bike_str     = Str_newf("bike");
    car_str      = Str_newf("car");
    carrot_str   = Str_newf("carrot");
    cat_str      = Str_newf("cat");
    float32_str  = Str_newf("float32");
    float64_str  = Str_newf("float64");
    food_str     = Str_newf("food");
    home_str     = Str_newf("home");
    int32_str    = Str_newf("int32");
    int64_str    = Str_newf("int64");
    land_str     = Str_newf("land");
    name_str     = Str_newf("name");
    nope_str     = Str_newf("nope");
    num_str      = Str_newf("num");
    random_str   = Str_newf("random");
    sloth_str    = Str_newf("sloth");
    speed_str    = Str_newf("speed");
    unknown_str  = Str_newf("unknown");
    unused_str   = Str_newf("unused");
    vehicle_str  = Str_newf("vehicle");
    weight_str   = Str_newf("weight");

    random_float32s_str = Str_newf("random_float32s");
    random_float64s_str = Str_newf("random_float64s");
    random_int32s_str   = Str_newf("random_int32s");
    random_int64s_str   = Str_newf("random_int64s");
}

static void
S_destroy_strings() {
    DECREF(air_str);
    DECREF(airplane_str);
    DECREF(bike_str);
    DECREF(car_str);
    DECREF(carrot_str);
    DECREF(cat_str);
    DECREF(float32_str);
    DECREF(float64_str);
    DECREF(food_str);
    DECREF(home_str);
    DECREF(int32_str);
    DECREF(int64_str);
    DECREF(land_str);
    DECREF(name_str);
    DECREF(nope_str);
    DECREF(num_str);
    DECREF(random_str);
    DECREF(sloth_str);
    DECREF(speed_str);
    DECREF(unknown_str);
    DECREF(unused_str);
    DECREF(vehicle_str);
    DECREF(weight_str);

    DECREF(random_float32s_str);
    DECREF(random_float64s_str);
    DECREF(random_int32s_str);
    DECREF(random_int64s_str);
}

TestReverseType*
TestReverseType_new() {
    TestReverseType *self = (TestReverseType*)Class_Make_Obj(TESTREVERSETYPE);
    return TestReverseType_init(self);
}

TestReverseType*
TestReverseType_init(TestReverseType *self) {
    return TestReverseType_init2(self, 1.0, false, true, true);
}

TestReverseType*
TestReverseType_init2(TestReverseType *self, float boost, bool indexed,
                      bool stored, bool sortable) {
    Int32Type_init2((Int32Type*)self, boost, indexed, stored, sortable);
    return self;
}

int32_t
TestReverseType_Compare_Values_IMP(TestReverseType *self, Obj *a, Obj *b) {
    UNUSED_VAR(self);
    return Obj_Compare_To(b, a);
}

static Schema*
S_create_schema() {
    Schema *schema = Schema_new();

    StandardTokenizer *tokenizer = StandardTokenizer_new();
    FullTextType *unsortable = FullTextType_new((Analyzer*)tokenizer);
    DECREF(tokenizer);

    StringType *string_type = StringType_new();
    StringType_Set_Sortable(string_type, true);

    Int32Type *int32_type = Int32Type_new();
    Int32Type_Set_Indexed(int32_type, false);
    Int32Type_Set_Sortable(int32_type, true);

    Int64Type *int64_type = Int64Type_new();
    Int64Type_Set_Indexed(int64_type, false);
    Int64Type_Set_Sortable(int64_type, true);

    Float32Type *float32_type = Float32Type_new();
    Float32Type_Set_Indexed(float32_type, false);
    Float32Type_Set_Sortable(float32_type, true);

    Float64Type *float64_type = Float64Type_new();
    Float64Type_Set_Indexed(float64_type, false);
    Float64Type_Set_Sortable(float64_type, true);

    TestReverseType *reverse_type = TestReverseType_new();

    Schema_Spec_Field(schema, name_str,    (FieldType*)string_type);
    Schema_Spec_Field(schema, speed_str,   (FieldType*)int32_type);
    Schema_Spec_Field(schema, sloth_str,   (FieldType*)reverse_type);
    Schema_Spec_Field(schema, weight_str,  (FieldType*)int32_type);
    Schema_Spec_Field(schema, int32_str,   (FieldType*)int32_type);
    Schema_Spec_Field(schema, int64_str,   (FieldType*)int64_type);
    Schema_Spec_Field(schema, float32_str, (FieldType*)float32_type);
    Schema_Spec_Field(schema, float64_str, (FieldType*)float64_type);
    Schema_Spec_Field(schema, home_str,    (FieldType*)string_type);
    Schema_Spec_Field(schema, cat_str,     (FieldType*)string_type);
    Schema_Spec_Field(schema, unused_str,  (FieldType*)string_type);
    Schema_Spec_Field(schema, nope_str,    (FieldType*)unsortable);

    DECREF(reverse_type);
    DECREF(float64_type);
    DECREF(float32_type);
    DECREF(int64_type);
    DECREF(int32_type);
    DECREF(string_type);
    DECREF(unsortable);

    return schema;
}

static void
S_refresh_indexer(Indexer **indexer, Schema *schema, RAMFolder *folder) {
    if (*indexer) {
        Indexer_Commit(*indexer);
        DECREF(*indexer);
    }
    *indexer = Indexer_new(schema, (Obj*)folder, NULL, 0);
}

static void
S_add_vehicle(Indexer *indexer, String *name, int32_t speed, int32_t sloth,
              int32_t weight, String *home, String *cat) {
    Doc       *doc   = Doc_new(NULL, 0);

    Doc_Store(doc, name_str, (Obj*)name);
    Doc_Store(doc, home_str, (Obj*)home);
    Doc_Store(doc, cat_str,  (Obj*)cat);

    Integer *speed_obj = Int_new(speed);
    Doc_Store(doc, speed_str, (Obj*)speed_obj);
    DECREF(speed_obj);
    Integer *sloth_obj = Int_new(sloth);
    Doc_Store(doc, sloth_str, (Obj*)sloth_obj);
    DECREF(sloth_obj);
    Integer *weight_obj = Int_new(weight);
    Doc_Store(doc, weight_str, (Obj*)weight_obj);
    DECREF(weight_obj);

    Indexer_Add_Doc(indexer, doc, 1.0f);

    DECREF(doc);
}

static void
S_add_doc(Indexer *indexer, Obj *value, String *cat, String *field_name) {
    Doc *doc = Doc_new(NULL, 0);
    String *name = Obj_To_String(value);
    Doc_Store(doc, name_str, (Obj*)name);
    Doc_Store(doc, cat_str,  (Obj*)cat);
    if (field_name) {
        Doc_Store(doc, field_name, value);
    }
    Indexer_Add_Doc(indexer, doc, 1.0f);
    DECREF(name);
    DECREF(doc);
}

typedef Obj* (*random_generator_t)();

static Obj*
S_random_string() {
    size_t length = 1 + rand() % 10;
    CharBuf *buf = CB_new(length);
    while (length--) {
        int32_t code_point = 'a' + rand() % ('z' - 'a' + 1);
        CB_Cat_Char(buf, code_point);
    }
    String *string = CB_Yield_String(buf);
    DECREF(buf);
    return (Obj*)string;
}

static Obj*
S_random_int32() {
    uint64_t num = TestUtils_random_u64();
    return (Obj*)Int_new(num & 0x7FFFFFFF);
}

static Obj*
S_random_int64() {
    uint64_t num = TestUtils_random_u64();
    return (Obj*)Int_new(num & INT64_C(0x7FFFFFFFFFFFFFFF));
}

static Obj*
S_random_float32() {
    uint64_t num = TestUtils_random_u64();
    double d = CHY_U64_TO_DOUBLE(num) * (10.0 / UINT64_MAX);
    return (Obj*)Float_new((float)d);
}

static Obj*
S_random_float64() {
    uint64_t num = TestUtils_random_u64();
    return (Obj*)Float_new(CHY_U64_TO_DOUBLE(num) * (10.0 / UINT64_MAX));
}

static Vector*
S_add_random_objects(Indexer **indexer, Schema *schema, RAMFolder *folder,
                     random_generator_t rng, String *field_name,
                     String *cat) {
    Vector *objects = Vec_new(100);

    for (int i = 0; i < 100; ++i) {
        Obj *object = rng();
        S_add_doc(*indexer, object, cat, field_name);
        Vec_Push(objects, object);
        if (i % 10 == 0) {
            S_refresh_indexer(indexer, schema, folder);
        }
    }

    Vec_Sort(objects);

    for (size_t i = 0; i < 100; ++i) {
        Obj *obj = Vec_Fetch(objects, i);
        String *string = Obj_To_String(obj);
        Vec_Store(objects, i, (Obj*)string);
    }

    return objects;
}

static Vector*
S_test_sorted_search(IndexSearcher *searcher, String *query,
                     uint32_t num_wanted, ...) {
    Vector  *rules = Vec_new(2);
    String *field;
    va_list  args;

    va_start(args, num_wanted);
    while (NULL != (field = va_arg(args, String*))) {
        int       reverse = va_arg(args, int);
        SortRule *rule    = SortRule_new(SortRule_FIELD, field, !!reverse);
        Vec_Push(rules, (Obj*)rule);
    }
    va_end(args);
    SortRule *rule = SortRule_new(SortRule_DOC_ID, NULL, 0);
    Vec_Push(rules, (Obj*)rule);
    SortSpec *spec = SortSpec_new(rules);

    Hits *hits = IxSearcher_Hits(searcher, (Obj*)query, 0, num_wanted, spec);

    Vector *results = Vec_new(10);
    HitDoc *hit_doc;
    while (NULL != (hit_doc = Hits_Next(hits))) {
        String *name = (String*)HitDoc_Extract(hit_doc, name_str);
        Vec_Push(results, (Obj*)Str_Clone((String*)name));
        DECREF(name);
        DECREF(hit_doc);
    }

    DECREF(hits);
    DECREF(spec);
    DECREF(rules);

    return results;
}

typedef struct SortContext {
    IndexSearcher *searcher;
    String        *sort_field;
} SortContext;

static void
S_attempt_sorted_search(void *context) {
    SortContext *sort_ctx = (SortContext*)context;
    Vector *results = S_test_sorted_search(sort_ctx->searcher, vehicle_str, 100,
                                           sort_ctx->sort_field, false, NULL);
    DECREF(results);
}

static void
test_sort_spec(TestBatchRunner *runner) {
    RAMFolder *folder  = RAMFolder_new(NULL);
    Schema    *schema  = S_create_schema();
    Indexer   *indexer = NULL;
    Vector    *wanted  = Vec_new(10);
    Vector    *results;
    Vector    *results2;

    // First, add vehicles.
    S_refresh_indexer(&indexer, schema, folder);
    S_add_vehicle(indexer, airplane_str, 200, 200, 8000, air_str,  vehicle_str);
    S_add_vehicle(indexer, bike_str,      15,  15,   25, land_str, vehicle_str);
    S_add_vehicle(indexer, car_str,       70,  70, 3000, land_str, vehicle_str);

    // Add random objects.
    Vector *random_strings =
        S_add_random_objects(&indexer, schema, folder, S_random_string,
                             NULL, random_str);
    Vector *random_int32s =
        S_add_random_objects(&indexer, schema, folder, S_random_int32,
                             int32_str, random_int32s_str);
    Vector *random_int64s =
        S_add_random_objects(&indexer, schema, folder, S_random_int64,
                             int64_str, random_int64s_str);
    Vector *random_float32s =
        S_add_random_objects(&indexer, schema, folder, S_random_float32,
                             float32_str, random_float32s_str);
    Vector *random_float64s =
        S_add_random_objects(&indexer, schema, folder, S_random_float64,
                             float64_str, random_float64s_str);

    // Add numbers to verify consistent ordering.
    int32_t *nums = (int32_t*)MALLOCATE(100 * sizeof(int32_t));
    for (int i = 0; i < 100; ++i) {
        nums[i] = i;
    }
    // Shuffle
    for (int i = 99; i > 0; --i) {
        int r = rand() % (i + 1);
        if (r != i) {
            // Swap
            int32_t tmp = nums[i];
            nums[i] = nums[r];
            nums[r] = tmp;
        }
    }
    for (int i = 0; i < 100; ++i) {
        char name_buf[3];
        sprintf(name_buf, "%02d", nums[i]);
        String *name = SSTR_WRAP_UTF8(name_buf, 2);
        S_add_doc(indexer, (Obj*)name, num_str, NULL);
        if (i % 10 == 0) {
            S_refresh_indexer(&indexer, schema, folder);
        }
    }
    FREEMEM(nums);

    Indexer_Commit(indexer);
    DECREF(indexer);

    // Start tests

    IndexSearcher *searcher = IxSearcher_new((Obj*)folder);

    results = S_test_sorted_search(searcher, vehicle_str, 100,
                                   name_str, false, NULL);
    Vec_Clear(wanted);
    Vec_Push(wanted, INCREF(airplane_str));
    Vec_Push(wanted, INCREF(bike_str));
    Vec_Push(wanted, INCREF(car_str));
    TEST_TRUE(runner, Vec_Equals(results, (Obj*)wanted), "sort by one criteria");
    DECREF(results);

#ifdef LUCY_VALGRIND
    SKIP(runner, 2, "known leaks");
#else
    Err *error;
    SortContext sort_ctx;
    sort_ctx.searcher = searcher;

    sort_ctx.sort_field = nope_str;
    error = Err_trap(S_attempt_sorted_search, &sort_ctx);
    TEST_TRUE(runner, error != NULL
              && Err_is_a(error, ERR)
              && Str_Contains_Utf8(Err_Get_Mess(error), "sortable", 8),
              "sorting on a non-sortable field throws an error");
    DECREF(error);

    sort_ctx.sort_field = unknown_str;
    error = Err_trap(S_attempt_sorted_search, &sort_ctx);
    TEST_TRUE(runner, error != NULL
              && Err_is_a(error, ERR)
              && Str_Contains_Utf8(Err_Get_Mess(error), "sortable", 8),
              "sorting on an unknown field throws an error");
    DECREF(error);
#endif

    results = S_test_sorted_search(searcher, vehicle_str, 100,
                                   weight_str, false, NULL);
    Vec_Clear(wanted);
    Vec_Push(wanted, INCREF(bike_str));
    Vec_Push(wanted, INCREF(car_str));
    Vec_Push(wanted, INCREF(airplane_str));
    TEST_TRUE(runner, Vec_Equals(results, (Obj*)wanted), "sort by one criteria");
    DECREF(results);

    results = S_test_sorted_search(searcher, vehicle_str, 100,
                                   name_str, true, NULL);
    Vec_Clear(wanted);
    Vec_Push(wanted, INCREF(car_str));
    Vec_Push(wanted, INCREF(bike_str));
    Vec_Push(wanted, INCREF(airplane_str));
    TEST_TRUE(runner, Vec_Equals(results, (Obj*)wanted), "reverse sort");
    DECREF(results);

    results = S_test_sorted_search(searcher, vehicle_str, 100,
                                   home_str, false, name_str, false, NULL);
    Vec_Clear(wanted);
    Vec_Push(wanted, INCREF(airplane_str));
    Vec_Push(wanted, INCREF(bike_str));
    Vec_Push(wanted, INCREF(car_str));
    TEST_TRUE(runner, Vec_Equals(results, (Obj*)wanted), "multiple criteria");
    DECREF(results);

    results = S_test_sorted_search(searcher, vehicle_str, 100,
                                   home_str, false, name_str, true, NULL);
    Vec_Clear(wanted);
    Vec_Push(wanted, INCREF(airplane_str));
    Vec_Push(wanted, INCREF(car_str));
    Vec_Push(wanted, INCREF(bike_str));
    TEST_TRUE(runner, Vec_Equals(results, (Obj*)wanted),
              "multiple criteria with reverse");
    DECREF(results);

    results = S_test_sorted_search(searcher, vehicle_str, 100,
                                   speed_str, true, NULL);
    results2 = S_test_sorted_search(searcher, vehicle_str, 100,
                                    sloth_str, false, NULL);
    TEST_TRUE(runner, Vec_Equals(results, (Obj*)results2),
              "FieldType_Compare_Values");
    DECREF(results2);
    DECREF(results);

    results = S_test_sorted_search(searcher, random_str, 100,
                                   name_str, false, NULL);
    TEST_TRUE(runner, Vec_Equals(results, (Obj*)random_strings),
              "random strings");
    DECREF(results);

    results = S_test_sorted_search(searcher, random_int32s_str, 100,
                                   int32_str, false, NULL);
    TEST_TRUE(runner, Vec_Equals(results, (Obj*)random_int32s),
              "int32");
    DECREF(results);

    results = S_test_sorted_search(searcher, random_int64s_str, 100,
                                   int64_str, false, NULL);
    TEST_TRUE(runner, Vec_Equals(results, (Obj*)random_int64s),
              "int64");
    DECREF(results);

    results = S_test_sorted_search(searcher, random_float32s_str, 100,
                                   float32_str, false, NULL);
    TEST_TRUE(runner, Vec_Equals(results, (Obj*)random_float32s),
              "float32");
    DECREF(results);

    results = S_test_sorted_search(searcher, random_float64s_str, 100,
                                   float64_str, false, NULL);
    TEST_TRUE(runner, Vec_Equals(results, (Obj*)random_float64s),
              "float64");
    DECREF(results);

    String *bbbcca_str = Str_newf("bike bike bike car car airplane");
    results = S_test_sorted_search(searcher, bbbcca_str, 100,
                                   unused_str, false, NULL);
    Vec_Clear(wanted);
    Vec_Push(wanted, INCREF(airplane_str));
    Vec_Push(wanted, INCREF(bike_str));
    Vec_Push(wanted, INCREF(car_str));
    TEST_TRUE(runner, Vec_Equals(results, (Obj*)wanted),
              "sorting on field with no values sorts by doc id");
    DECREF(results);
    DECREF(bbbcca_str);

    String *nn_str        = Str_newf("99");
    String *nn_or_car_str = Str_newf("99 OR car");
    results = S_test_sorted_search(searcher, nn_or_car_str, 10,
                                   speed_str, false, NULL);
    Vec_Clear(wanted);
    Vec_Push(wanted, INCREF(car_str));
    Vec_Push(wanted, INCREF(nn_str));
    TEST_TRUE(runner, Vec_Equals(results, (Obj*)wanted),
              "doc with NULL value sorts last");
    DECREF(results);
    DECREF(nn_str);
    DECREF(nn_or_car_str);

    results = S_test_sorted_search(searcher, num_str, 10,
                                   name_str, false, NULL);
    results2 = S_test_sorted_search(searcher, num_str, 30,
                                    name_str, false, NULL);
    Vec_Resize(results2, 10);
    TEST_TRUE(runner, Vec_Equals(results, (Obj*)results2),
              "same order regardless of queue size");
    DECREF(results2);
    DECREF(results);

    results = S_test_sorted_search(searcher, num_str, 10,
                                   name_str, true, NULL);
    results2 = S_test_sorted_search(searcher, num_str, 30,
                                    name_str, true, NULL);
    Vec_Resize(results2, 10);
    TEST_TRUE(runner, Vec_Equals(results, (Obj*)results2),
              "same order regardless of queue size (reverse sort)");
    DECREF(results2);
    DECREF(results);

    DECREF(searcher);

    // Add another seg to index.
    indexer = Indexer_new(schema, (Obj*)folder, NULL, 0);
    S_add_vehicle(indexer, carrot_str, 0, 0, 1, land_str, food_str);
    Indexer_Commit(indexer);
    DECREF(indexer);

    searcher = IxSearcher_new((Obj*)folder);
    results = S_test_sorted_search(searcher, vehicle_str, 100,
                                   name_str, false, NULL);
    Vec_Clear(wanted);
    Vec_Push(wanted, INCREF(airplane_str));
    Vec_Push(wanted, INCREF(bike_str));
    Vec_Push(wanted, INCREF(car_str));
    TEST_TRUE(runner, Vec_Equals(results, (Obj*)wanted), "Multi-segment sort");
    DECREF(results);
    DECREF(searcher);

    DECREF(random_strings);
    DECREF(random_int32s);
    DECREF(random_int64s);
    DECREF(random_float32s);
    DECREF(random_float64s);

    DECREF(wanted);
    DECREF(schema);
    DECREF(folder);
}

void
TestSortSpec_Run_IMP(TestSortSpec *self, TestBatchRunner *runner) {
    TestBatchRunner_Plan(runner, (TestBatch*)self, 18);
    S_init_strings();
    test_sort_spec(runner);
    S_destroy_strings();
}