#include <stdlib.h>
#include "sys/time.h"
#include "mb.h"
#include "lock.h"
#include "list.h"
#include "power.h"
#include "cascade.h"
#include "breaker.h"

#define RETRY_TIMES         3
#define TIMEOUT             200

#define BREAKER_INFO_REG    2200


typedef struct {
    int8_t        data;
    uint32_t      time;
}breaker_ori_t;

typedef struct {
    lock_t        lck;
    
    uint8_t       cur_idx;
    breaker_ori_t ori[BREAKER_BOARD_MAX];
}breaker_handle_t;
static breaker_handle_t brHandle={0};


static int read_reg(uint8_t addr, uint16_t reg, uint16_t *data, int cnt)
{
    int i,r=0;
    
    cascade_lock(1);
    for(i=0; i<RETRY_TIMES; i++) {
        r = mb_read(MB_ID_POWER, addr, reg, data, cnt, TIMEOUT);
        if(r==cnt) {
            break;
        }
    }
    cascade_lock(0);
    
    return (r==cnt)?0:-1;
}


int breaker_init(void)
{
    int i;
    breaker_handle_t *h=&brHandle;
    
    h->lck = lock_init();
    for(i=0; i<BREAKER_BOARD_MAX; i++) {
        h->ori[i].data = -1;
    }
    
    return 0;
}


int breaker_deinit(void)
{
    breaker_handle_t *h=&brHandle;
    
    lock_deinit(h->lck);
    
    return 0;
}

static int read_board(breaker_handle_t *h, uint8_t addr, int8_t *sw)
{
    int i,r;
    uint16_t tmp[BREAKER_CH_MAX];

    r = read_reg(addr, BREAKER_INFO_REG+1, tmp, BREAKER_CH_MAX);
    if(r==0) {
        for(i=0; i<BREAKER_CH_MAX; i++) {
            *sw |= BIT(i);
        }
    }
    else {
        *sw = -1;
    }
    
    return r;
}
static breaker_all_t brk_get(breaker_handle_t *h)
{
    int i,j,idx=0;
    breaker_all_t all={0};
    
    for(i=0; i<BREAKER_BOARD_MAX; i++) {
        if(h->ori[i].data>=0) {
            all.cnt += BREAKER_CH_MAX;
        }
    }
    if(all.cnt>0) {
        all.data = (breaker_data_t*)malloc(sizeof(breaker_data_t*)*all.cnt);
        if(all.data) {
            for(i=0; i<BREAKER_BOARD_MAX; i++) {
                if(h->ori[i].data>=0) {
                    for(j=0; j<BREAKER_CH_MAX; j++) {
                        all.data[idx].info.addr = BREAKER_BOARD_ADDR_START+i;
                        all.data[idx].samp.sw   = (h->ori[i].data&BIT(j))?1:0;
                        idx++;
                    }
                }
            }
        }
        else {
            all.cnt = 0;
        }
    }
    
    return all;
}


int breaker_query(void)
{
    int i,r;
    uint8_t addr;
    breaker_handle_t *h=&brHandle;
    
    lock_on(h->lck);
    if(h->cur_idx>=BREAKER_BOARD_MAX) {
        h->cur_idx = 0;
    }
    
    addr = BREAKER_BOARD_ADDR_START+h->cur_idx;
    r = read_board(h, addr, &h->ori[h->cur_idx].data);
    if(r) {
        h->ori[h->cur_idx].data = -1;
    }
    h->ori[h->cur_idx].time = mktime(localtime(NULL));
    lock_off(h->lck);
    
    return r;
}


int breaker_set(breaker_data_t *data)
{
    breaker_handle_t *h=&brHandle;
    
    if(!data) {
        return -1;
    }
    lock_on(h->lck);
    
    lock_off(h->lck);
    
    return 0;
}


int breaker_data_get(breaker_all_t *all)
{
    int i,cnt;
    char *p=NULL;
    breaker_all_t brk={0};
    breaker_handle_t *h=&brHandle;
    
    if(!all) {
        return -1;
    }
    
    lock_on(h->lck);
    power_breaker_get(all);
    brk = brk_get(h);
    if(brk.cnt) {
        cnt = all->cnt+brk.cnt;
        p = (char*)realloc(all->data, sizeof(breaker_data_t)*cnt);
        if(p) {
            memcpy(p+sizeof(breaker_data_t)*cnt, brk.data, sizeof(breaker_data_t)*brk.cnt);
            all->data = (breaker_data_t*)p;
            all->cnt = cnt;
        }
    }
    breaker_data_free(&brk);
    
    for(i=0; i<all->cnt; i++) {
        sprintf(all->data[i].info.name, "SW%d", i);
        all->data[i].samp.id = i;
        all->data[i].samp.nid = 0;
    }
    lock_off(h->lck);
    
    return 0;
}


int breaker_data_free(breaker_all_t *all)
{
    if(!all) {
        return -1;
    }
    
    if(all->data) {
        free(all->data);
        all->data = NULL;
    }
    all->cnt = 0;
    return 0;
}