#include <cstdio>
#include <cstdlib>
#include "svm.h"


#define Malloc(type,n) (type *)malloc((n)*sizeof(type))

// structure for handling model *and* training examples //////////////////////
//
struct persist_model {
    struct svm_model * mod;     // svmlibs model
    struct svm_node * x_space;  // field of sparse training vectors
};

// global parameter struct with default  values  /////////////////////////////
// 

int wl[] = { +1, -1 };
double w[] = { 1.0 , 1.0 };

struct svm_parameter param =  { 
    C_SVC,    // svm_type
    LINEAR,   // kernel type
    3,        // degree
    0.0,      // gamma
    0.0,      // coef0
    100.0,    // cache size in mb
    1e-3,     // eps
    1.0,      // C
    2,        // nr_weight
    wl,       // weight_label
    w,        // weight
    0.5,      // nu
    0.1,      // p
    1,        // shrinking
    0,        // propability
};

                                
// new global parameters for svm training  ///////////////////////////////////
//
int verbose=1;
int maxiter=1000;

// setter functions  for global parameters ///////////////////////////////////
//
extern "C" void set_verbose(int v) { verbose = v; }
extern "C" void set_maxiter(int v) { maxiter = v; }

// setter functions for setting fields of global parameter structure /////////
//
extern "C" void set_linear_kernel(void) { param.kernel_type = LINEAR; }
extern "C" void set_radial_kernel(void) { param.kernel_type = RBF; }
extern "C" void set_polynomial_kernel(void) { param.kernel_type = POLY; }

extern "C" void set_degree(int v)  { param.degree = v; }
extern "C" void set_gamma(double v)  { param.gamma = v; }
extern "C" void set_coef0(double v)  { param.coef0 = v; }
extern "C" void set_cache_size(double v) { param.cache_size = v; }
extern "C" void set_eps(double v) { param.eps = v; }
extern "C" void set_shrinking(int v) { param.shrinking = v; }

extern "C" void set_C(double v) { param.weight[0] = param.weight[1] = v; }
extern "C" void set_Cpm(double cp, double cm) { param.weight[0] = cp; param.weight[1] = cm; }

// wrapper for svm_train: converts numpy matrices to sparse vectors, /////////
// and calls svm_train()                                                  ////
extern "C" long int wrap_train(int ngood, int nbad, int features, double *mgood,
                               double*mbad)
{
    // setup svm_problem 
    struct svm_problem prob;        // set by read_problem
    prob.l = ngood+nbad;
    int elements = (features +1)*prob.l;


    prob.y = Malloc(double,prob.l);
    prob.x = Malloc(struct svm_node *,prob.l);
    struct svm_node * x_space = Malloc(struct svm_node,elements);

    // convert input matrices to array of sparse vectors
    int cc=0;
    int ze, sp;
    for (ze=0; ze<ngood; ++ze)
    {
        prob.y[ze] = +1;
        prob.x[ze] = &x_space[cc];

        for (sp=0; sp<features; ++sp)
        {
            x_space[cc].index =  sp;
            x_space[cc].value =  mgood[sp+features*ze];
            cc++;
        }
        x_space[cc++].index = -1;
    }
    for (ze=0; ze<nbad; ++ze)
    {
        prob.y[ze+ngood] = -1;
        prob.x[ze+ngood] = &x_space[cc];

        for (sp=0; sp<features; ++sp)
        {
            x_space[cc].index =  sp;
            x_space[cc].value =  mbad[sp+features*ze];
            cc++;
        }
        x_space[cc++].index = -1;
    }

    // learn model 
    struct svm_model * model = svm_train(&prob, &::param);

    struct persist_model * rv = Malloc(struct persist_model, 1);
    rv->mod = model;

    //TODO: compress x_space to support vectors !
    rv->x_space = x_space;

    free(prob.x);
    free(prob.y);

    /*
    for (int ll=0; ll<model->l; ++ll)
    {
        printf ("alpha: l=%d %f\n", ll, model->sv_coef[0][ll]);

    }
    */


    // pointer is converted to int value as handle for further acces to 
    // svm model
    return (long int)(void*)rv;

}

extern "C" void get_sv(int handle, int i, int f, double sv[])
{
    struct persist_model * model = (struct persist_model *)handle;
    for (int ii=0; ii<f; ++ii)
        sv[ii] = 0.0;

    for (svm_node *p=(model->mod->SV)[i]; p->index>=0; p++)
        sv[p->index] = p->value;
}

extern "C" int get_num_sv(int handle)
{
    struct persist_model * model = (struct persist_model *)handle;
    return model->mod->l;
}

extern "C" double get_bias(int handle)
{
    struct persist_model * model = (struct persist_model *)handle;
    return model->mod->rho[0]; // 0 as 2 class model
}

extern "C" void set_bias(int handle, double bias)
{
    struct persist_model * model = (struct persist_model *)handle;
    model->mod->rho[0] = bias; // 0 as 2 class model
}

extern "C" double get_alpha(int handle, int i)
{
    struct persist_model * model = (struct persist_model *)handle;
    return model->mod->sv_coef[0][i];
}


// wrapper for svm_save_model ////////////////////////////////////////////////
//
extern "C" void wrap_savemodel(int handle, char *path)
{
    struct persist_model * model = (struct persist_model *)handle;
    svm_save_model(path, model->mod);

}

extern "C" int get_num_iter(int handle)
{
    struct persist_model * model = (struct persist_model *)handle;
    return model->mod->num_iter;
}


// destroy model and free training vectors ///////////////////////////////////
// this was tested for  memory leaks but nothing bad happened :-)     ////////
// 
extern "C" void wrap_free(int handle)
{
    struct persist_model * model = (struct persist_model *)handle;
    svm_destroy_model(model->mod); 
    free(model->x_space);
    free(model);

}

// classify vector ///////////////////////////////////////////////////////////
//
extern "C" double wrap_classify(int handle, double *vec, int n)
{
    // convert handle to pointer to svm model 
    struct persist_model * model = (struct persist_model *)handle;

    // convert vector to sparse vector
    struct svm_node *temp_vec = Malloc(struct svm_node, n+1);
    for (int i=0; i<n; ++i)
    {
        temp_vec[i].index = i;
        temp_vec[i].value = vec[i];
    }
    temp_vec[n].index=-1; // mark end of sparse vector

    // apply model to vector
    double v = svm_predict(model->mod, temp_vec);

    free(temp_vec);
    return v;
}


// classify matrix ///////////////////////////////////////////////////////////
//
extern "C" void wrap_classify_matrix(int handle, double *mat, int ze, int sp, char *result)
{
    // convert handle to pointer to svm model 
    struct persist_model * model = (struct persist_model *)handle;

    // convert vector to sparse vector
    struct svm_node *temp_vec = Malloc(struct svm_node, sp+1);

    for (int zz=0; zz<ze; ++zz)
    {

        for (int ss=0; ss < sp; ++ss)
        {
            temp_vec[ss].index = ss;
            temp_vec[ss].value = mat[zz*sp + ss];
        }
        temp_vec[sp].index=-1; // mark end of sparse vector

        // apply model to vector
        result[zz] = svm_predict(model->mod, temp_vec) > 0 ? 1 : -1;
    }
    free(temp_vec);
}