#include "mb.h"
#include "lock.h"
#include "list.h"


#define MALLOC   malloc
#define FREE     free

typedef void (*thread_fn_t)(void *arg);

typedef struct {
    uint8_t    type;
    uint8_t    mode;
    mb_inst_t  *hinst;
    lock_t     lck;
}mb_inf_t;
typedef struct {
    rt_thread_t tid;
    uint8_t     quit;
    mb_inf_t    inf[MB_ID_MAX];
}mb_handle_t;
static mb_handle_t mbHandle={0};
static int mb_stop(mb_handle_t *h);


static mb_para_t mb_paras[MB_ID_MAX]={
    {   //MB_ID_POWER
        .mode = MB_MODE_MASTER,
        .type = MB_TYPE_RTU,
        .para = {
            .rtu = {
                .dev = POWER_PORT,          //端口
                .baudrate = 115200,         //波特率
                .parity = 0,                //校验位
                .pin = -1,                  //收发控制引脚, <0 表示不使用
                .lvl = 0,                   //发送控制电平
            }
        }
    },
    
    {   //MB_ID_SENSOR
        .mode = MB_MODE_MASTER,
        .type = MB_TYPE_RTU,
        .para = {
            .rtu = {
                .dev = SENSOR_PORT,         //端口
                .baudrate = 9600,         //波特率
                .parity = 0,                //校验位
                .pin = -1,                  //收发控制引脚, <0 表示不使用
                .lvl = 0,                   //发送控制电平
            }
        }
    },
    
    {   //MB_ID_CASCADE
        .mode = MB_MODE_SLAVE,
        .type = MB_TYPE_RTU,
        .para = {
            .rtu = {
                .dev = CASCADE_PORT,        //端口
                .baudrate = 115200,         //波特率
                .parity = 0,                //校验位
                .pin = -1,                  //收发控制引脚, <0 表示不使用
                .lvl = 0,                   //发送控制电平
            }
        }
    },
};


int mb_init(void)
{
    int i,r;
    mb_handle_t *h=&mbHandle;
    const char *err[MB_ID_MAX]={"power","sensor","cascade"};
    
    memset(h, 0, sizeof(mb_handle_t));
    for(i=0; i<MB_ID_MAX; i++) {
        r = mb_setup(i, &mb_paras[i]);
        if(r) {
            LOGE("___ %s mb setup failed\n", err[i]);
            continue;
        }
        h->inf[i].lck = lock_init();
    }
    
    return 0;
}

int mb_init_n(uint8_t id,mb_para_t *para)
{
	int r;
	mb_handle_t *h=&mbHandle;
	if(id<0 || id>=MB_ID_MAX || !para) {
        return -1;
  }
	r = mb_setup(id, para);
	h->inf[id].lck = lock_init();
}






int mb_setup(int id, mb_para_t *para)
{
    int r;
    mb_inf_t *pinf=NULL;
    mb_backend_param_t param={0};
    mb_handle_t *h=&mbHandle;
    
    if(id<0 || id>=MB_ID_MAX || !para) {
        return -1;
    }
    pinf = &h->inf[id];
    
    lock_on(pinf->lck);
    pinf->type = para->type;
    pinf->mode = para->mode;
    if(pinf->type==MB_TYPE_RTU) {
        if(pinf->hinst) {
            mb_disconn(pinf->hinst);
        }
        
        param.rtu = para->para.rtu;
        pinf->hinst = mb_create(pinf->type, &param);
        if(!pinf->hinst) {
            return -1;
        }
        r = mb_connect(pinf->hinst);
        if(r) {
            LOGE("___ mb_connect failed\n");
        }
    }
    else if(pinf->type==MB_TYPE_TCP) {
        
    }
    else {
        r = -1;
    }
    lock_off(pinf->lck);
    
    return r;
}



int mb_deinit_n(uint8_t id)
{
	if(id<0 || id>=MB_ID_MAX) {
        return -1;
  }
	mb_handle_t *h=&mbHandle;
	if(h->inf[id].lck)
	{
		lock_deinit(h->inf[id].lck);
	}
	if(h->inf[id].hinst)
	{
		mb_disconn(h->inf[id].hinst);
		mb_destory(h->inf[id].hinst);
	}
	h->inf[id].lck = 0;
	h->inf[id].hinst = 0;
}

int mb_deinit(void)
{
    int i;
    mb_handle_t *h=&mbHandle;
    
    for(i=0; i<MB_ID_MAX; i++) {
        lock_deinit(h->inf[i].lck);
        mb_disconn(h->inf[i].hinst);
        mb_destory(h->inf[i].hinst);
    }
    
    return 0;
}


int mb_read(int id, uint8_t addr, uint16_t reg, uint16_t *data, int cnt, int timeout)
{
    int r=-1;
    mb_inf_t *pinf=NULL;
    mb_handle_t *h=&mbHandle;
    
    if(id<0 || id>=MB_ID_MAX || !data || cnt<=0) {
        return -1;
    }
    pinf = &h->inf[id];
    
#if 0
    rt_tick_t end = rt_tick_get_millisecond()+timeout;
    while(1) {
        sz = list_size(mh->rx);
        if(sz>0) {
            break;
        }
        rt_thread_mdelay(1);
        
        if(timeout>0 && rt_tick_get_millisecond()>end) {
            sz = list_size(mh->rx);
            break;
        }
    }
    
    if(sz>0) {
        list_node_t *ln=NULL;
        r = list_take_node(mh->rx, &ln, 0);
        if(r==0) {
            node_t *nd=&ln->data;
            
            if(len>=nd->dlen) {
                memcpy(data, nd->buf, nd->dlen);
            }
            else {
                r = -1;
            }
            list_back_node(mh->rx, ln);
        }
    }
#else
    lock_on(pinf->lck);
    mb_set_tmo(pinf->hinst, timeout, 50);
    mb_set_slave(pinf->hinst, addr);
    r = mb_read_regs(pinf->hinst, reg, cnt, data);
    lock_off(pinf->lck);
#endif
    
    return r;
}


int mb_write(int id, uint8_t addr, uint16_t reg, uint16_t *data, int cnt)
{
    int r=-1;
    mb_inf_t *pinf=NULL;
    mb_handle_t *h=&mbHandle;
    
    if(id<0 || id>=MB_ID_MAX || !data || cnt<=0) {
        return -1;
    }
    pinf = &h->inf[id];

#if 0
    r = list_append(mh->tx, 0, data, len);
#else
    lock_on(pinf->lck);
    mb_set_slave(pinf->hinst, addr);
    r = mb_write_regs(pinf->hinst, reg, cnt, data);
    lock_off(pinf->lck);
#endif
    
    return r;
}


int mb_set_addr(int id, uint8_t addr)
{
    mb_inf_t *pinf=NULL;
    mb_handle_t *h=&mbHandle;
    
    if(id<0 || id>=MB_ID_MAX) {
        return -1;
    }
    pinf = &h->inf[id];
    
    lock_on(pinf->lck);
    mb_set_slave(pinf->hinst,addr);
    lock_off(pinf->lck);
    
    return 0;
}


int mb_set_cb(int id, const mb_cb_table_t *tab)
{
    mb_inf_t *pinf=NULL;
    mb_handle_t *h=&mbHandle;
    
    if(id<0 || id>=MB_ID_MAX) {
        return -1;
    }
    pinf = &h->inf[id];
    
    lock_on(pinf->lck);
    mb_set_cb_table(pinf->hinst, tab);
    lock_off(pinf->lck);
    
    return 0;
}


int mb_set_cascade_cb(int id, mb_cascade_fun_t *fn)
{
    mb_inf_t *pinf=NULL;
    mb_handle_t *h=&mbHandle;
    
    if(id<0 || id>=MB_ID_MAX) {
        return -1;
    }
    pinf = &h->inf[id];
    
    lock_on(pinf->lck);
    mb_set_cb_cascade(pinf->hinst, fn);
    lock_off(pinf->lck);
    
    return 0;
}


int mb_slave_poll(int id)
{
    mb_inf_t *pinf=NULL;
    mb_handle_t *h=&mbHandle;
    
    if(id<0 || id>=MB_ID_MAX) {
        return -1;
    }
    pinf = &h->inf[id];
    
    lock_on(pinf->lck);
    mb_slave_fsm(pinf->hinst);
    lock_off(pinf->lck);
    
    return 0;
}