#include <vector>
#include <cmath>
#include <algorithm>
#include <iostream>

extern "C" {

    // --- Production Data Structures ---
    struct NodeMetadata {
        float centrality;
        float recency;
        float weight;
    };

    // --- The Parallel Graph Walk Kernel ---
    // Inputs:
    // query_ptr: Pointer to query vector (Size D)
    // db_ptr: Pointer to ALL document vectors (Size N * D)
    // meta_ptr: Pointer to ALL metadata structs (Size N * 3)
    // n: Number of documents
    // d: Vector dimension
    // Output:
    // best_idx: Index of the winning document
    // best_score: The priority score of the winner
    
    void ov_hybrid_search(
        const float* query_ptr, 
        const float* db_ptr, 
        const float* meta_ptr, 
        int n, 
        int d, 
        int* best_idx, 
        float* best_score
    ) {
        float max_p = -1.0f;
        int winner = -1;

        // OpenMP pragma would go here for multi-core parallelism
        // #pragma omp parallel for
        for (int i = 0; i < n; ++i) {
            float dot = 0.0f;
            float norm_q = 0.0f;
            float norm_d = 0.0f;

            // Vector Dot Product
            const float* doc_vec = &db_ptr[i * d];
            for (int j = 0; j < d; ++j) {
                dot += query_ptr[j] * doc_vec[j];
                norm_q += query_ptr[j] * query_ptr[j];
                norm_d += doc_vec[j] * doc_vec[j];
            }

            // Cosine Similarity
            float similarity = dot / (std::sqrt(norm_q) * std::sqrt(norm_d) + 1e-9f);

            // Metadata Access
            // Structure layout: [C, R, W, C, R, W...]
            float C = meta_ptr[i * 3 + 0];
            float R = meta_ptr[i * 3 + 1];
            float W = meta_ptr[i * 3 + 2];

            // Priority Formula
            float P = similarity * C * R * W;

            if (P > max_p) {
                max_p = P;
                winner = i;
            }
        }

        *best_idx = winner;
        *best_score = max_p;
    }
}