/** ALOE headers
 */
#include <phal_sw_api.h>
#include <swapi_utils.h>

#include "typetools.h"

#include "itf_types.h"
#include "inputs.h"
#include "outputs.h"
#include "stats.h"

int configured;
int totalinputbits,totaloutputbits;

int rcv[MAX_INPUT_CHANNELS];

extern int currentInterfaceIdx;

int temp[MAX_INPUT_CHANNELS*INPUT_MAX_DATA];

int offsets_r[MAX_INPUT_CHANNELS],offsets_w[MAX_INPUT_CHANNELS];


int process_input(int len)
{
    int offset;
    int i;
    int ch;

    if (!configured)
        return 1;

    ch=currentInterfaceIdx-1;

    if (ch>MAX_INPUT_CHANNELS) {
        Log("ChMux: Invalid receiving interface (%d)\n",currentInterfaceIdx);
        return 0;
    }

    if (len<typeSizeArray(datatype,ctrlpkt.input_channel_length[ch])) {
        Log("ChMux: Invalid input length: bitsxch=%d, len=%d\n",ctrlpkt.input_channel_length[ch],len);
        return 0;
    }

    if (rcv[ch]) {
        Log("ChMux: Caution packet in ch %d not yet processed\n",ch);
    }

    rcv[ch]=1;

    type2int(input_data[ch],&temp[offsets_r[ch]],ctrlpkt.input_channel_length[ch],datatype);

    return 1;
}

int process_control(int len) {
    int i;
    int rpm,wpm;
    configured=1;
    totalinputbits=0;
    rpm=0;
    for (i=0;i<ctrlpkt.nof_input_channels;i++) {
        if (typeSizeArray(datatype,ctrlpkt.input_channel_length[i])>INPUT_MAX_DATA) {
            Log("ChMux: Invalid control packet: Input data exceeds input buffer (%d>%d)\n",ctrlpkt.input_channel_length[i],INPUT_MAX_DATA);
            return 0;
        }
        input_itfs[i+1].buffer = input_data[i];
        input_itfs[i+1].max_buffer_len = typeSizeArray(datatype,ctrlpkt.input_channel_length[i]);
        rpm+=typeSizeArray(datatype,ctrlpkt.input_channel_length[i]);
        offsets_r[i] = totalinputbits;
        totalinputbits+=ctrlpkt.input_channel_length[i];
    }
    totaloutputbits=0;
    wpm=0;
    for (i=0;i<ctrlpkt.nof_output_channels;i++) {
        if (typeSizeArray(datatype,ctrlpkt.output_channel_length[i])>INPUT_MAX_DATA) {
            Log("ChMux: Invalid control packet: Output data exceeds output buffer (%d>%d)\n",ctrlpkt.output_channel_length[i],INPUT_MAX_DATA);
            return 0;
        }
        output_itfs[i].buffer = output_data[i];
        output_itfs[i].max_buffer_len = typeSizeArray(datatype,ctrlpkt.output_channel_length[i]);
        wpm+=typeSizeArray(datatype,ctrlpkt.output_channel_length[i]);
        offsets_w[i] = totaloutputbits;
        totaloutputbits+=ctrlpkt.output_channel_length[i];
    }
    
    if (totalinputbits!=totaloutputbits) {
        Log("ChMux: Invalid control packet: Input and output lengths are not equal (%d!=%d)\n",totalinputbits,totaloutputbits);
        return 0;
    }

    Log("ChMux: input_channels=%d, output_channels=%d, length=%d\n",ctrlpkt.nof_input_channels,ctrlpkt.nof_output_channels,totalinputbits);
    return 1;
}

/** Run function.
 * @return 1 if ok, 0 if error
 */
int RunCustom()
{
    int i,j;
    if (configured) {
        for (i=0;i<ctrlpkt.nof_input_channels;i++) {
            if (!rcv[i])
                return 1;
        }
        memset(rcv,0,ctrlpkt.nof_input_channels*sizeof(int));


        for(i=0;i<ctrlpkt.nof_output_channels;i++) {
            int2type(&temp[offsets_w[i]],output_data[i],ctrlpkt.output_channel_length[i],datatype);
            SendItf(i,typeSizeArray(datatype,ctrlpkt.output_channel_length[i]));
        }
    }
    return 1;
}

int InitCustom()
{
    configured=0;
    return 1;
}


char inputitfname[MAX_INPUT_CHANNELS][32];
char outputitfname[MAX_OUTPUT_CHANNELS][32];

void ConfigInterfaces(void)
{
    int i;

    input_itfs[0].name ="control";
    input_itfs[0].sample_sz = sizeof(struct chmux_h);
    input_itfs[0].max_buffer_len = 1;
    input_itfs[0].buffer = &ctrlpkt;
    input_itfs[0].get_block_sz = NULL;
    input_itfs[0].process_fnc = process_control;

    if (input_channels>MAX_INPUT_CHANNELS) {
        Log("Caution exceed maximum input chanels (%d>%d)\n",input_channels,MAX_INPUT_CHANNELS);
        input_channels=MAX_INPUT_CHANNELS;
    }

    if (output_channels>MAX_OUTPUT_CHANNELS) {
        Log("Caution exceed maximum output chanels (%d>%d)\n",output_channels,MAX_OUTPUT_CHANNELS);
        output_channels=MAX_OUTPUT_CHANNELS;
    }

    for (i=1;i<input_channels+1;i++) {
        sprintf(inputitfname[i-1],"input%d",i-1);
        input_itfs[i].name = inputitfname[i-1];
        input_itfs[i].sample_sz = typeSize(datatype);
        input_itfs[i].max_buffer_len = typeSizeArray(datatype,INPUT_MAX_DATA*input_channels);
        input_itfs[i].buffer = input_data[i-1];
        input_itfs[i].get_block_sz = NULL;
        input_itfs[i].process_fnc = process_input;
    }
    input_itfs[i].name = NULL;

    for (i=0;i<output_channels;i++) {
        sprintf(outputitfname[i],"output%d",i);
        output_itfs[i].name = outputitfname[i];
        output_itfs[i].sample_sz = sizeof(input1_t);
        output_itfs[i].max_buffer_len = typeSizeArray(datatype,INPUT_MAX_DATA*input_channels);
        output_itfs[i].buffer = output_data[i];
        output_itfs[i].get_block_sz = NULL;
        output_itfs[i].process_fnc = NULL;
    }
    output_itfs[i].name = NULL;
}