#ifndef __WDONG_PSLSH__
#define __WDONG_PSLSH__

#include <cass.h>
#include <cass_file.h>
#include <cass_hash.h>
#include <cass_bitmap.h>

typedef struct {
	int a_step, b_step;
	double a_min, a_max;
	double b_min, b_max;
	double a_delta, b_delta;
	double **a_table;
	double **b_table;
} LSH_est_t;

int LSH_est_init (LSH_est_t *est, int a_step, double a_min, double a_max,
	int b_step, double b_min, double b_max, double W, int M, int L, int K);
int LSH_est_dump_file (LSH_est_t *est, char *);
int LSH_est_init_with_file (LSH_est_t *est, char *);

void LSH_est_cleanup (LSH_est_t *est);

double LSH_est (LSH_est_t *est, double a, double b, int K);

typedef struct {
	cass_size_t d_step;
	cass_size_t T;
	float d_min, d_max;
	float **table;
} LSH_recall_t;

int LSH_recall_init (LSH_recall_t *recall, int d_step, float d_min, float d_max,
		int M, int L, int T, float W);

int LSH_recall_dump (LSH_recall_t *recall, CASS_FILE *fout);

int LSH_recall_load (LSH_recall_t *recall, CASS_FILE *fin);

static inline void LSH_recall_cleanup (LSH_recall_t *recall)
{
	matrix_free(recall->table);
}

static inline float LSH_recall (LSH_recall_t *recall, float dist, int T)
{
	int d;
	if (dist < recall->d_min) return 1.0;
	if (dist > recall->d_max) return 0.0;
	d = (dist - recall->d_min) * recall->d_step / (recall->d_max - recall->d_min);
	return recall->table[T][d];
}

typedef struct
{
	cass_size_t D, M, L, H, count;
	float *W;
	float **alphas;
	float *betas;
	uint32_t **rnd;
	ohash_t *hash;

	uint32_t **tmp;	/* used as hash index, for insertion*/
	uint32_t *tmp2;	/* used as 2nd hash, for insertion */

	LSH_est_t *est;
	LSH_recall_t recall;
} LSH_t;

static inline void LSH_set_est (LSH_t *lsh, LSH_est_t *est)
{
	lsh->est = est;
}

void LSH_hash2 (LSH_t *lsh, uint32_t **hash, uint32_t *hash2);

void LSH_hash (LSH_t *lsh, const float *pnt, uint32_t **hash);

/* -------------------------------------- QUERY ----------------------------- */
#include "perturb.h"
//#define QUERY_DIRECT 1

typedef struct {
	LSH_t *lsh;
	cass_dataset_t *ds;

	cass_size_t K;
	cass_size_t L;
	cass_size_t T;

	bitmap_t *bitmap;

	uint32_t **tmp;
	uint32_t *tmp2;

	ptb_vec_t **ptb;	/* L * 2M */
#ifdef QUERY_DIRECT
	ARRAY_TYPE(ptb_vec_t) *heap;
#else
	int *ptb_step;
	ptb_vec_t *ptb_set;
	ptb_vec_t **ptb_vec;
#endif

	cass_list_entry_t *topk;
	cass_list_entry_t **_topk;

	int *C;
	int *H;
	float *S;

	int CC;
	float dist;
	float min;
	float gamma;
} LSH_query_t;

void LSH_query_init (LSH_query_t *query, LSH_t *lsh, cass_dataset_t *ds, cass_size_t K, cass_size_t L, cass_size_t T);

static inline void LSH_query_set_gamma (LSH_query_t *query, float gamma)
{
	query->gamma = gamma;
}

void LSH_query_cleanup (LSH_query_t *query);

void LSH_query (LSH_query_t *query, const float *point);

void LSH_query_recall (LSH_query_t *query, const float *point, float R);

void LSH_query_boost (LSH_query_t *query, const float *point);

void LSH_query_batch (const LSH_query_t *query, int N, const float **point, cass_list_entry_t **topk);
void LSH_query_batch_ca (const LSH_query_t *query, int N, const float **point, cass_list_entry_t **topk);

void LSH_hash_score (LSH_t *lsh, int L, const float *pnt, uint32_t **hash, ptb_vec_t **ptb);

void LSH_hash2_noperturb (LSH_t *lsh, uint32_t **hash, uint32_t *hash2, int L);

void LSH_hash2_perturb (LSH_t *lsh, uint32_t **hash, uint32_t *hash2, ptb_vec_t *ptb, int l);
		
#endif