#include "mb2hal.h"

retCode create_HAL_pins()
{
    const char *fnct_name = "create_HAL_pins";
    int tx_counter;

    for (tx_counter = 0; tx_counter < gbl.tot_mb_tx; tx_counter++) {
        if (create_each_mb_tx_hal_pins(&gbl.mb_tx[tx_counter]) != retOK) {
            ERR(gbl.init_dbg, "failed to initialize hal pins in tx_num[%d] [%d] [%s]",
                tx_counter, gbl.mb_tx[tx_counter].mb_tx_fnct, gbl.mb_tx[tx_counter].mb_tx_fnct_name);
            return retERR;
        }
    }

    return retOK;
}

#define CREATE_PIN(C, T, F)\
mb_tx->C = (T **)hal_malloc(sizeof(T *));\
if (mb_tx->C == NULL) {\
    ERR(gbl.init_dbg, "[%d] [%s] NULL hal_malloc num_errors",\
        mb_tx->mb_tx_fnct, mb_tx->mb_tx_fnct_name);\
    return retERR;\
}\
memset(mb_tx->C, 0, sizeof(T *));\
snprintf(hal_pin_name, HAL_NAME_LEN, "%s.%s.%s", gbl.hal_mod_name, mb_tx->hal_tx_name, #C);\
if (0 != F(HAL_OUT, mb_tx->C, gbl.hal_mod_id, "%s", hal_pin_name)) {\
    ERR(gbl.init_dbg, "[%d] [%s] [%s] " #F " pin failed", mb_tx->mb_tx_fnct, mb_tx->mb_tx_fnct_name, hal_pin_name);\
    return retERR;\
}\
**(mb_tx->num_errors) = 0;\
DBG(gbl.init_dbg, "mb_tx_num [%d] pin_name [%s]", mb_tx->mb_tx_num, hal_pin_name);

retCode create_each_mb_tx_hal_pins(mb_tx_t *mb_tx)
{
    const char *fnct_name = "create_each_mb_tx_hal_pins";
    char hal_pin_name[HAL_NAME_LEN + 1];
    int pin_counter;

    if (mb_tx == NULL) {
        ERR(gbl.init_dbg, "NULL pointer");
        return retERR;
    }

    //num_errors hal pin
    mb_tx->num_errors = (hal_u32_t**)hal_malloc(sizeof(hal_u32_t *));
    if (mb_tx->num_errors == NULL) {
        ERR(gbl.init_dbg, "[%d] [%s] NULL hal_malloc num_errors",
            mb_tx->mb_tx_fnct, mb_tx->mb_tx_fnct_name);
        return retERR;
    }
    memset(mb_tx->num_errors, 0, sizeof(hal_u32_t *));
    snprintf(hal_pin_name, HAL_NAME_LEN, "%s.%s.num_errors", gbl.hal_mod_name, mb_tx->hal_tx_name);
    if (0 != hal_pin_u32_newf(HAL_OUT, mb_tx->num_errors, gbl.hal_mod_id, "%s", hal_pin_name)) {
        ERR(gbl.init_dbg, "[%d] [%s] [%s] hal_pin_u32_newf failed", mb_tx->mb_tx_fnct, mb_tx->mb_tx_fnct_name, hal_pin_name);
        return retERR;
    }
    **(mb_tx->num_errors) = 0;
    DBG(gbl.init_dbg, "mb_tx_num [%d] pin_name [%s]", mb_tx->mb_tx_num, hal_pin_name);

    // modbus_ok hal pin
    CREATE_PIN(modbus_ok, hal_bit_t, hal_pin_bit_newf);
    CREATE_PIN(cumul_errors, hal_s32_t, hal_pin_s32_newf);
    CREATE_PIN(cumul_transactions, hal_s32_t, hal_pin_s32_newf);

    if (!mb_tx->nb_hal_map_pin) {	// Old fashioned pin management
		switch (mb_tx->mb_tx_fnct) {

		case mbtx_02_READ_DISCRETE_INPUTS:
		case mbtx_15_WRITE_MULTIPLE_COILS:
		case mbtx_05_WRITE_SINGLE_COIL:
			mb_tx->bit = (hal_bit_t **)hal_malloc(sizeof(hal_bit_t *) * mb_tx->mb_tx_nelem);
			if (mb_tx->bit == NULL) {
				ERR(gbl.init_dbg, "[%d] [%s] NULL hal_malloc [%d] elements",
					mb_tx->mb_tx_fnct, mb_tx->mb_tx_fnct_name, mb_tx->mb_tx_nelem);
				return retERR;
			}
			memset(mb_tx->bit, 0, sizeof(hal_bit_t *) * mb_tx->mb_tx_nelem);
			break;

		case mbtx_03_READ_HOLDING_REGISTERS:
		case mbtx_04_READ_INPUT_REGISTERS:
		case mbtx_16_WRITE_MULTIPLE_REGISTERS:
			mb_tx->float_value= (hal_float_t **)hal_malloc(sizeof(hal_float_t *) * mb_tx->mb_tx_nelem);
			mb_tx->int_value  = (hal_s32_t **)hal_malloc(sizeof(hal_s32_t *) * mb_tx->mb_tx_nelem);
			//mb_tx->scale      = hal_malloc(sizeof(hal_float_t) * mb_tx->mb_tx_nelem);
			//mb_tx->offset     = hal_malloc(sizeof(hal_float_t) * mb_tx->mb_tx_nelem);
			//if (mb_tx->float_value == NULL || mb_tx->int_value == NULL
			//        || mb_tx->scale == NULL || mb_tx->offset == NULL) {
			if (mb_tx->float_value == NULL || mb_tx->int_value == NULL) {
				ERR(gbl.init_dbg, "[%d] [%s] NULL hal_malloc [%d] elements",
					mb_tx->mb_tx_fnct, mb_tx->mb_tx_fnct_name, mb_tx->mb_tx_nelem);
				return retERR;
			}
			memset(mb_tx->float_value,     0, sizeof(hal_float_t *) * mb_tx->mb_tx_nelem);
			memset(mb_tx->int_value,       0, sizeof(hal_s32_t *)   * mb_tx->mb_tx_nelem);
			//memset((void *) mb_tx->scale,  0, sizeof(hal_float_t)   * mb_tx->mb_tx_nelem);
			//memset((void *) mb_tx->offset, 0, sizeof(hal_float_t)   * mb_tx->mb_tx_nelem);
			break;

		default:
			ERR(gbl.init_dbg, "[%d] wrong mb_tx_fnct", mb_tx->mb_tx_fnct);
			return retERR;
			break;
		}

		for (pin_counter = 0; pin_counter < mb_tx->mb_tx_nelem; pin_counter++) {

			snprintf(hal_pin_name, HAL_NAME_LEN, "%s.%s.%02d", gbl.hal_mod_name, mb_tx->hal_tx_name, pin_counter);
			DBG(gbl.init_dbg, "mb_tx_num [%d] pin_name [%s]", mb_tx->mb_tx_num, hal_pin_name);

			switch (mb_tx->mb_tx_fnct) {
			case mbtx_15_WRITE_MULTIPLE_COILS:
			case mbtx_05_WRITE_SINGLE_COIL:
				if (0 != hal_pin_bit_newf(HAL_IN, mb_tx->bit + pin_counter, gbl.hal_mod_id,
										  "%s", hal_pin_name)) {
					ERR(gbl.init_dbg, "[%d] [%s] [%s] hal_pin_bit_newf failed",
						mb_tx->mb_tx_fnct, mb_tx->mb_tx_fnct_name, hal_pin_name);
					return retERR;
				}
				*mb_tx->bit[pin_counter] = 0;
				break;
			case mbtx_02_READ_DISCRETE_INPUTS:
				if (0 != hal_pin_bit_newf(HAL_OUT, mb_tx->bit + pin_counter, gbl.hal_mod_id,
										  "%s", hal_pin_name)) {
					ERR(gbl.init_dbg, "[%d] [%s] [%s] hal_pin_bit_newf failed",
						mb_tx->mb_tx_fnct, mb_tx->mb_tx_fnct_name, hal_pin_name);
					return retERR;
				}
				*mb_tx->bit[pin_counter] = 0;
				break;
			case mbtx_04_READ_INPUT_REGISTERS:
			case mbtx_03_READ_HOLDING_REGISTERS:
				if (0 != hal_pin_float_newf(HAL_OUT, mb_tx->float_value + pin_counter, gbl.hal_mod_id,
											"%s.float", hal_pin_name)) {
					ERR(gbl.init_dbg, "[%d] [%s] [%s] hal_pin_float_newf failed",
						mb_tx->mb_tx_fnct, mb_tx->mb_tx_fnct_name, hal_pin_name);
					return retERR;
				}
				if (0 != hal_pin_s32_newf(HAL_OUT, mb_tx->int_value + pin_counter, gbl.hal_mod_id,
										  "%s.int", hal_pin_name)) {
					ERR(gbl.init_dbg, "[%d] [%s] [%s] hal_pin_s32_newf failed",
						mb_tx->mb_tx_fnct, mb_tx->mb_tx_fnct_name, hal_pin_name);
					return retERR;
				}
				*mb_tx->float_value[pin_counter] = 0;
				*mb_tx->int_value[pin_counter] = 0;
				break;
			case mbtx_16_WRITE_MULTIPLE_REGISTERS:
				if (0 != hal_pin_float_newf(HAL_IN, mb_tx->float_value + pin_counter, gbl.hal_mod_id,
											"%s", hal_pin_name)) {
					ERR(gbl.init_dbg, "[%d] [%s] [%s] hal_pin_float_newf failed",
						mb_tx->mb_tx_fnct, mb_tx->mb_tx_fnct_name, hal_pin_name);
					return retERR;
				}
				*mb_tx->float_value[pin_counter] = 0;
				break;
			default:
				ERR(gbl.init_dbg, "[%d]", mb_tx->mb_tx_fnct);
				return retERR;
				break;
			}
		}
    }
    else {	// We are using enhanced pin mapping
    	hal_pin_dir_t dir;

    	switch (mb_tx->mb_tx_fnct) {
		case mbtx_15_WRITE_MULTIPLE_COILS:
		case mbtx_16_WRITE_MULTIPLE_REGISTERS:
		case mbtx_05_WRITE_SINGLE_COIL:
			dir = HAL_IN;
			break;
		case mbtx_02_READ_DISCRETE_INPUTS:
		case mbtx_04_READ_INPUT_REGISTERS:
		case mbtx_03_READ_HOLDING_REGISTERS:
			dir = HAL_OUT;
			break;
		default:
			ERR(gbl.init_dbg, "[%d]", mb_tx->mb_tx_fnct);
			return retERR;
			break;
    	}

		mb_tx->pin_value  = (hal_data_u **)hal_malloc(sizeof(hal_data_u *) * mb_tx->nb_hal_map_pin);
		if (mb_tx->pin_value == NULL) {
			ERR(gbl.init_dbg, "[%d] [%s] NULL hal_malloc [%d] pins",
				mb_tx->mb_tx_fnct, mb_tx->mb_tx_fnct_name, mb_tx->nb_hal_map_pin);
			return retERR;
		}
		memset(mb_tx->pin_value,       0, sizeof(hal_data_u *)   * mb_tx->nb_hal_map_pin);

		for (int index=0; index<mb_tx->nb_hal_map_pin; index++) {
			hal_map_pin_t *m = &mb_tx->hal_map_pin[index];
			int rc = 1;
			switch (m->type) {
			case HAL_BIT:
				rc = hal_pin_bit_newf(dir, (hal_bit_t **)mb_tx->pin_value + index, gbl.hal_mod_id,
					              "%s.%s.%s", gbl.hal_mod_name, mb_tx->hal_tx_name, m->name);
				break;
			case HAL_FLOAT:
				rc = hal_pin_float_newf(dir, (hal_float_t **)mb_tx->pin_value + index, gbl.hal_mod_id,
					              "%s.%s.%s", gbl.hal_mod_name, mb_tx->hal_tx_name, m->name);
				break;
    		case HAL_S32:
				rc = hal_pin_s32_newf(dir, (hal_s32_t **)mb_tx->pin_value + index, gbl.hal_mod_id,
					              "%s.%s.%s", gbl.hal_mod_name, mb_tx->hal_tx_name, m->name);
				break;
    		case HAL_U32:
				rc = hal_pin_u32_newf(dir, (hal_u32_t **)mb_tx->pin_value + index, gbl.hal_mod_id,
					              "%s.%s.%s", gbl.hal_mod_name, mb_tx->hal_tx_name, m->name);
				break;
			}

			if (0 != rc) {
				ERR(gbl.init_dbg, "hal_pin_xxx_newf(type=%d, name=%s.%s.%s) error", 
					m->type, gbl.hal_mod_name, mb_tx->hal_tx_name, m->name);
				return retERR;
			}
		}
    }
    return retOK;
}