/* 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_LUCY_COMPILER
#include "Lucy/Util/ToolSet.h"

#include "Lucy/Search/Compiler.h"

#include "Clownfish/CharBuf.h"
#include "Lucy/Index/SegReader.h"
#include "Lucy/Index/DocVector.h"
#include "Lucy/Index/Similarity.h"
#include "Lucy/Plan/Schema.h"
#include "Lucy/Search/Matcher.h"
#include "Lucy/Search/Query.h"
#include "Lucy/Search/Searcher.h"
#include "Lucy/Store/InStream.h"
#include "Lucy/Store/OutStream.h"
#include "Lucy/Util/Freezer.h"

Compiler*
Compiler_init(Compiler *self, Query *parent, Searcher *searcher,
              Similarity *sim, float boost) {
    CompilerIVARS *const ivars = Compiler_IVARS(self);
    Query_init((Query*)self, boost);
    if (!sim) {
        Schema *schema = Searcher_Get_Schema(searcher);
        sim = Schema_Get_Similarity(schema);
    }
    ivars->parent  = (Query*)INCREF(parent);
    ivars->sim     = (Similarity*)INCREF(sim);
    ABSTRACT_CLASS_CHECK(self, COMPILER);
    return self;
}

void
Compiler_Destroy_IMP(Compiler *self) {
    CompilerIVARS *const ivars = Compiler_IVARS(self);
    DECREF(ivars->parent);
    DECREF(ivars->sim);
    SUPER_DESTROY(self, COMPILER);
}

float
Compiler_Get_Weight_IMP(Compiler *self) {
    return Compiler_Get_Boost(self);
}

Similarity*
Compiler_Get_Similarity_IMP(Compiler *self) {
    return Compiler_IVARS(self)->sim;
}

Query*
Compiler_Get_Parent_IMP(Compiler *self) {
    return Compiler_IVARS(self)->parent;
}

float
Compiler_Sum_Of_Squared_Weights_IMP(Compiler *self) {
    UNUSED_VAR(self);
    return 1.0f;
}

void
Compiler_Apply_Norm_Factor_IMP(Compiler *self, float factor) {
    UNUSED_VAR(self);
    UNUSED_VAR(factor);
}

void
Compiler_Normalize_IMP(Compiler *self) {
    CompilerIVARS *const ivars = Compiler_IVARS(self);

    // factor = (tf_q * idf_t)
    float factor = Compiler_Sum_Of_Squared_Weights(self);

    // factor /= norm_q
    factor = Sim_Query_Norm(ivars->sim, factor);

    // weight *= factor
    Compiler_Apply_Norm_Factor(self, factor);
}

Vector*
Compiler_Highlight_Spans_IMP(Compiler *self, Searcher *searcher,
                             DocVector *doc_vec, String *field) {
    UNUSED_VAR(self);
    UNUSED_VAR(searcher);
    UNUSED_VAR(doc_vec);
    UNUSED_VAR(field);
    return Vec_new(0);
}

String*
Compiler_To_String_IMP(Compiler *self) {
    CompilerIVARS *const ivars = Compiler_IVARS(self);
    String *stringified_query = Query_To_String(ivars->parent);
    CharBuf *buf = CB_new(0);
    CB_Cat_Trusted_Utf8(buf, "compiler(", 9);
    CB_Cat(buf, stringified_query);
    CB_Cat_Trusted_Utf8(buf, ")", 1);
    String *string = CB_Yield_String(buf);
    DECREF(buf);
    DECREF(stringified_query);
    return string;
}

bool
Compiler_Equals_IMP(Compiler *self, Obj *other) {
    if ((Compiler*)other == self)                          { return true; }
    if (!Obj_is_a(other, COMPILER))                        { return false; }
    CompilerIVARS *const ivars = Compiler_IVARS(self);
    CompilerIVARS *const ovars = Compiler_IVARS((Compiler*)other);
    if (ivars->boost != ovars->boost)                      { return false; }
    if (!Query_Equals(ivars->parent, (Obj*)ovars->parent)) { return false; }
    if (!Sim_Equals(ivars->sim, (Obj*)ovars->sim))         { return false; }
    return true;
}

void
Compiler_Serialize_IMP(Compiler *self, OutStream *outstream) {
    CompilerIVARS *const ivars = Compiler_IVARS(self);
    ABSTRACT_CLASS_CHECK(self, COMPILER);
    OutStream_Write_F32(outstream, ivars->boost);
    FREEZE(ivars->parent, outstream);
    FREEZE(ivars->sim, outstream);
}

Compiler*
Compiler_Deserialize_IMP(Compiler *self, InStream *instream) {
    CompilerIVARS *const ivars = Compiler_IVARS(self);
    ivars->boost  = InStream_Read_F32(instream);
    ivars->parent = (Query*)THAW(instream);
    ivars->sim    = (Similarity*)THAW(instream);
    return self;
}