/** Sample ALOE component implementation file
 */


/** Include SW API header and SW API utils (skeleton)
*/
#include <phal_sw_api.h>
#include <swapi_utils.h>

/** Include general data type library */
#include "typetools.h"

/** include input/output interfaces and stats.
 *  itf_types.h must be included 'before' input.h if it defines e.g. control
 *  interface packet structure
 */
#include "itf_types.h"
#include "inputs.h"
#include "outputs.h"
#include "stats.h"

#include "puncturing_code.h"

/*GLOBAL VARIABLES & BUFFERS*/
CDepunc_h ctrl;
int configured=0;
int input_temp[INPUT_MAX_DATA*8],output_temp[OUTPUT_MAX_DATA*8];

/*  PREDEFINED FUNCTIONS*/
int datainflow_bypass(int len,int numTS,int print,int numcols,int dattype);
void check_config();

/*-----------------------  SQUELETON CALLED FUNCTIONS ------------------------*/
/** INPUT INTERFACE 1: CONTROL //////////////////////////////////////////CONTROL
 *  controlin_length() Returns the maximum length (in control type words) of the 
 *  expected control flow at each time-slot
 *  Funtion activated if control flow has been received
 */
int controlin_length()
{
int length=INPUT_MAX_CONTROL;

    return(length);
}

/** Process the received control flow according to the length returned by 
 *  get_controlin_length() "len" indicates the number of control words to be 
 *  processed
 *  This is the processing function for the control interface. Here, we simply
 *  have to validate the parameters and update our internal state variables.
 */
int process_inputcontrol(int len)
{
    int i;
    
 	if(len<=0)return(1);
        configured=1;
     	//CAPTURE MODULE CONFIG
         memcpy(&ctrl,&ctrlpkt,sizeof(CDepunc_h));
 	//PRINT CONFIG VALUES
	xprintf("O---->GEN_DEPUNCT (config): CONFIG BY CONTROL ITF\n");
        xprintf("O---->GEN_DEPUNCT (config): TSLOT%d, STATUS=%d\n",\
			ctrl.time_slot,\
			ctrl.status);
	xprintf("O       NumInputdata=%d, NumOutputdata=%d\n",\
			ctrl.inputdatalength,\
			ctrl.outputdatalength);
 	xprintf("O       depuncturing rate=%4.2f pseqlength=%d\n",\
                        ctrl.punct_rate, ctrl.pseqlength);
        xprintf("O       dePuncturing Sequence=");
        for(i=0; i<ctrl.pseqlength; i++)xprintf("%d ",ctrl.punctseq[i]);
        xprintf("\n");
        xprintf("O-----------------------------------------0\n");

	if(ctrl.inputdatalength>INPUT_MAX_DATA) {
        	//sprintf(str,"MODULENAME: Invalid inputdatalength parameter. %d > %d\n",\
		//				inputdatalength,INPUT_MAX_DATA);
       		//WriteLog(1,str);
		return(0);
    	}
/*return 1 if OK; return 0 if error*/
return(1);
}
/** END INPUT INTERFACE 1: CONTROL /////////////////////////////////////CONTROL
/** INPUT INTERFACE 2: DATA ///////////////////////////////////////////////DATA
 *  datain_length() Returns the maximum length (in data type words) of the 
 *  expected data flow at each time-slot
 *  Funtion activated if data flow has been received
 */
int datain_length()
{
int length=typeSizeArray(datatypeIN, ctrl.inputdatalength);

    return(length);
}

/** Process the received data flow according to the length returned by 
 *  datain_length(). Run function. return 1 if ok, 0 if error.
 *  "len" indicates the number of data words to be processed
 *  This is the main processing function. It will be called every time
 *  data is available for process. Here you will place your signal processing
 *  code.
 */

int process_inputdata(int len)
{
    int i;
    float maxIN, escale, *temp;
    static int count2=0;

    /*Check if configured*/
    if (!configured)return(1);

    /** In general, we want to make sure we have received the expected
     *  amount of data.
     *  The function typeSizeArray() returns the expected bytes as a function
     *  of a general datatype and expected number of elements. For example, if
     *  blockLength=128 and datatype is INTEGER, it returns 128*4=512.
     *  If for example the datatype is BITSTREAM the function will
     *  return 128/8=16
     */
    /*NO LOG FILE*/
    if (len<typeSizeArray(datatypeIN,ctrl.inputdatalength)) {
        printf("GEN_DEPUNCT: ERROR: len=%d<ctrl.input_length=%d \n",\
                len, ctrl.inputdatalength);
        return 0;
    }
    /** Perform a BYPASS of data inputs to data output of 
     *  length=ctrl.input_length
     */
    if(ctrl.status==TEST_FLOW){
        datainflow_bypass(ctrl.inputdatalength,20,1,16,1);
	return(1);
    }

    /** The most flexible component should be able to work with any data type.
     *  Others, however, only have sense working with bits, e.g. CRC or FEC.
     *  In the latter case, the only possible input data type is BITSTREAM.
     *  In the former, our module should internally work with either floats or
     *  4-byte integers because these are the largest data types. The typetools
     *  library offers us a couple of functions to convert an arbitrary
     *  datatype to integers/floats to be used by the component. For example,
     *  we can convert to integers with the function:
     */

 


/*  type2int(input_data,\
                    input_temp,\
                    ctrl.inputdatalength,\
                    datatypeIN);
*/
    type2intAUTOSCALE(input_data,\
                    input_temp,\
                    ctrl.inputdatalength,\
                    datatypeIN,\
                    127);


    
    if((len/typeSize(TYPE_FLOAT)) != ctrl.inputdatalength){
        printf("ERROR: puncturing_imp: process_datainflow()\n");
        printf("length= %d!=  inputdatalength=%d\n",\
        len/typeSize(TYPE_FLOAT), ctrl.inputdatalength);
        return(0);
    }

    /** Note how we convert from a data type unknown at compile time.
     *  blockLength indicates the amount of samples we want to conver.
     *  Alternatively, we have a similar function to convert to floats:
     *  type2float(input_data,input_temp,blockLength,datatype);
     */

     if(ctrl.status==ACTIVE){
	len=depuncturing(ctrl.punctseq,\
                        ctrl.pseqlength,\
                        ctrl.inputdatalength,\
                        ctrl.outputdatalength,\
                        input_temp,\
                        output_temp);

     }
    if(len != ctrl.outputdatalength){
        printf("ERROR: puncturing_imp: process_datainflow()\n");
        printf("length= %d!=  outputdatalength=%d\n",\
        len, ctrl.outputdatalength);
        return(0);
    }
    /** Now we convert again to the variable datatype. Note that we could
     *  have two 'datatype' variables: one for input and one for output. Thus,
     *  our module will be able to convert between types.
     */
    int2type(output_temp,output_data,ctrl.outputdatalength,datatypeOUT);

    /** The skeleton will read from the output_data buffer the required
     *  amount of samples that must be sended.
     */


    /* We return 1 to indicate the processing finished correctly. If we return
     * 0 we will force the module to stop.
     */
    return 1;
}

/** OUTPUT INTERFACE 2: DATA //////////////////////////////////////////////DATA
/** get_output_length() function returns the amount of data typewords the 
 *  skeleton will send through the output interface (after all input functions
 *  finished).
 *  Note that again we are using the typetools library to convert from the
 *  desired processing data types to transport data types
 */
int get_output_length() {
    //printf("DEPUNCTURING  get_output_length() length=%d\n",\
    //        typeSizeArray(datatypeOUT,ctrl.outputdatalength));
    return typeSizeArray(datatypeOUT,ctrl.outputdatalength);
}

/** Our output process function does nothing. It can be used to make sure
 *  we have processed all data, or to generate data if there are not inputs
 */
int generate_outputdata(int len) {
    return 1;
}

/** This function is called after all interface processing functions have been
 *  called. You can place other state-update code here.
 */
int RunCustom()
{
    //check_config();
    return 1;
}

/** This function is called after all interfaces have been initialized.
 * You can place other custom initialization code here.
 */
int InitCustom()
{
    check_config();
    return 1;
}

/** This function is called after initializing parameters and before
 * creating interfaces. It is useful when the number of interfaces or buffers
 * is a function of an initialization parameter.
 */
void ConfigInterfaces()
{
    
}
/*-----------------------  SQUELETON CALLED FUNCTIONS END -------------------*/

/*Perfom a bypass input output without any data modification*/
int datainflow_bypass(int len,int numTS,int print,int numcols,int dattype){
                    /**  int len        Data lenght
                     *   int numTS      Time slot when print
                     *   int print      print (1) or no print (0)
                     *   int numcols
                     * Number of columns
                     *   int dattype    Data type to print
                     */

 int i;
 static int one=0;
 
        for(i=1; i<=len; i++)output_data[i-1]=input_data[i-1];
        type2int(input_data,input_temp,ctrl.inputdatalength,datatypeIN);
        int2type(input_temp,output_data,ctrl.outputdatalength,datatypeOUT);
        one++;

        if((one==numTS)&&(print==1)){
            printf("GEN_DEPUNCT BYPASS\n");
            for(i=1; i<=len; i++){
		if(dattype==0)printf("% d  ", (short )output_data[i-1]);
                if(dattype==1)printf("% d  ", (unsigned char)output_data[i-1]);
                if(dattype==2)printf("% d  ", (short )output_data[i-1]);
                if(dattype==3)printf("% d  ", (int)output_data[i-1]);
                if(dattype==4)printf("% d  ", (float)output_data[i-1]);
                if(i%numcols==0)printf("\n");
		}
            printf("\n");
            }
return(1);
}

/** Checks the current module status and capture the configuration defined at
 *  stats.h
 */
void check_config()
{
   static int one=-1;

    	if(statusMOD==ACTIVE){
		//printf("LTE_source: check_config() numdataOUT=%d \n",\
                                                    numdataOUT);
		ctrl.time_slot=timesLOT;
		ctrl.status=statusMOD;
		ctrl.inputdatalength=numdataIN;
		ctrl.outputdatalength=numdataOUT;
	}

        /*PRINT CONFIG VALUE*/
        if(one==ctrl.time_slot){
            xprintf("O---->GEN_DEPUNCT (config): CONFIG BY STATS.h\n");
            xprintf("O---->GEN_DEPUNCT (config): TSLOT%d, STATUS=%d\n",\
			ctrl.time_slot,\
			ctrl.status);
            xprintf("O       NumInputdata=%d, NumOutputdata=%d\n",\
			ctrl.inputdatalength,\
			ctrl.outputdatalength);
            xprintf("O---->datatypeIN=%d, datatypeOUT=%d\n",\
			datatypeIN,datatypeOUT);
            xprintf("O-----------------------------------------0\n");
        }
        if(one<=ctrl.time_slot)one++;
}