#include "cboard.h"
#include "datadef.h"
#include "lock.h"
#include "mb.h"
#include "log.h"

typedef struct {
    int (*get_power)(power_ch_t *pch);
    int (*get_alarm)(power_ch_t *pch);
    int (*set_ch)(power_ch_t *pch);
    int (*set_open_delay)(power_ch_t *pch);
    int (*set_close_delay)(power_ch_t *pch);
    int (*set_kb_value)(power_ch_t *pch);
    int (*set_threshold)(power_ch_t *pch);
    int (*reset_consump)(power_ch_t *pch);

    int (*detect)(uint8_t addr);
    int (*get_info)(uint8_t addr, board_info_t *info);
    int (*get_board)(board_data_t *pbrd);
    int (*set_all)(uint8_t addr, uint8_t on);
}board_fn2_t;


//////////////////////////////////////////////////////////
static int get_power(power_ch_t *pch)
{
    return 0;
}
static int get_alarm(power_ch_t *pch)
{
    return 0;
}
static int set_ch(power_ch_t *pch)
{
    int r;
    power_ch_t pc;
    uint16_t offset=0,data_temp[2];
        
    offset = POWER_DC_SET_STAT + pch->info.ch;
    data_temp[0] = pch->power[0].status; data_temp[1] = 0;
    r = write_reg(pch->info.addr, offset, data_temp, 2);
    
    return r;
}
static int set_open_delay(int addr, uint16_t delay)
{
    
}
static int set_close_delay(int addr, uint16_t delay)
{
    
}
static int set_kb_value(int addr, kb_val_t *kv)
{
    
}

static int set_threshold(power_ch_t *pch)
{
    int r=-1;
    
   
    
    return r;
}
static int reset_consump(int addr)
{
    
}








int set_alarm(power_ch_t *pch)
{
    int r=-1;
    power_ch_t pc;
    uint16_t offset = 0;
    uint16_t nStatus = 0;
    
    if (pch->info.ch<0) {
        offset = POWER_DC_ALARM_CTRL_TOTAL;
    }
    else {
        offset = POWER_DC_ALARM_CTRL + pch->info.ch;
    }
    
    if(pc.thr.v_upper.act==1) nStatus |= BIT(1);
    if(pc.thr.v_lower.act==1) nStatus |= BIT(2);
    if(pc.thr.c_upper.act==1) nStatus |= BIT(0);
    if(pc.thr.p_upper.act==1) nStatus |= BIT(3);
    if(pc.thr.w_upper.act==1) nStatus |= BIT(4);
    r = write_reg(pch->info.addr, offset, &nStatus, 1);
    
    return r;
}


int set_threashold(power_ch_t *pch)
{
    int r=-1;
    uint16_t offset;
    uint16_t data_temp[4];
    uint32_t value;
            
    offset = (pch->info.ch<0)?POWER_DC_THRESHOLD_TOTAL_VOL_MAX:POWER_DC_THRESHOLD_VOL_MAX;
    value = pch->thr.v_upper.val * 1000;
    data_temp[0] = value & 0XFFFF;
    data_temp[1] = (value >> 16) & 0xFFFF;
    r = write_reg(pch->info.addr, offset, data_temp, 2);
    
    offset = (pch->info.ch<0)?POWER_DC_THRESHOLD_TOTAL_VOL_MIN:POWER_DC_THRESHOLD_VOL_MIN;
    value = pch->thr.v_lower.val * 1000;
    data_temp[0] = value & 0XFFFF;
    data_temp[1] = (value >> 16) & 0xFFFF;
    r = write_reg(pch->info.addr, offset, data_temp, 2);
    
    offset = (pch->info.ch<0)?POWER_DC_THRESHOLD_TOTAL_CUR_MAX:POWER_DC_THRESHOLD_CUR_MAX;
    value = pch->thr.c_upper.val * 1000;
    data_temp[0] = value & 0XFFFF;
    data_temp[1] = (value >> 16) & 0xFFFF;
    r = write_reg(pch->info.addr, offset, data_temp, 2);
    
    offset = (pch->info.ch<0)?POWER_DC_THRESHOLD_TOTAL_PWR_MAX:POWER_DC_THRESHOLD_POWER_MAX;
    value = pch->thr.p_upper.val * 1000;
    data_temp[0] = value & 0XFFFF;
    data_temp[1] = (value >> 16) & 0xFFFF;
    r = write_reg(pch->info.addr, offset, data_temp, 2);
    
    offset = (pch->info.ch<0)?POWER_DC_THRESHOLD_TOTAL_PWRCON_MAX:POWER_DC_THRESHOLD_POWERCON_MAX;
    value = pch->thr.w_upper.val * 1000;
    data_temp[0] = value & 0XFFFF;
    data_temp[1] = (value >> 16) & 0xFFFF;
    r = write_reg(pch->info.addr, offset, data_temp, 2);
    
    //set_alarm();
    
    return r;
}
////////////////////////
static int brd_detect(uint8_t addr)
{
    return 0;
}
static int get_info(uint8_t addr, board_info_t *info)
{
    return 0;
}

static int get_board(uint8_t addr, board_data_t *pbrd)
{
    int r,i,j;
    uint32_t val;
    uint16_t offset,tmp[144];      
            
    r = read_reg(pbrd->addr, POWER_AC_CUR_INFO_L, tmp, pbrd->chs);
    if(r==0 && pbrd->pch) {
        for (i=0; i<pbrd->chs; i++) {
            int idx = i * 12;
            // 解电压数据
            val = (tmp[1 + idx] << 16) | tmp[0 + idx];
            pbrd->pch[i].power[0].voltage = val / 1000.0;
            // 解电流数据
            val = (tmp[3 + idx] << 16) | tmp[2 + idx];
            pbrd->pch[i].power[0].current = val / 1000.0;
            // 解功率数据
            val = (tmp[5 + idx] << 16) | tmp[4 + idx];
            pbrd->pch[i].power[0].power = val / 1000.0;
            // 解频率数据
            val = (tmp[7 + idx] << 16) | tmp[6 + idx];
            pbrd->pch[i].power[0].freq = val / 1000.0;
            // 解耗电量数据
            val = (tmp[9 + idx] << 16) | tmp[8 + idx];
            pbrd->pch[i].power[0].consump = val / 1000.0;
            // 解功率因素数据
            val = (tmp[11 + idx] << 16) | tmp[10 + idx];
            pbrd->pch[i].power[0].factor = val / 1000.0;
        }
    }
    
    r = read_reg(pbrd->addr, POWER_AC_STAT_INFO_L, tmp, pbrd->chs);
    if (r < 0) {
        LOGE("get_board, addr:%d offset:%d r=%d\n", pbrd->addr, offset, r);
        return r;
    }
    
    if(pbrd->pch) {
        for (i=0; i<pbrd->chs; i++) {
            pbrd->pch[i].power[0].status = tmp[i] & (0x01);
            pbrd->pch[i].alarm.v_upper   = tmp[i] & ALARM_V_UPPER;
            pbrd->pch[i].alarm.v_lower   = tmp[i] & ALARM_V_LOWER;
            pbrd->pch[i].alarm.c_upper   = tmp[i] & ALARM_C_UPPER;
            pbrd->pch[i].alarm.p_upper   = tmp[i] & ALARM_P_UPPER;
            pbrd->pch[i].alarm.w_upper   = tmp[i] & ALARM_W_UPPER;
            pbrd->pch[i].alarm.ph_loss   = 0;
        }
    }
    
    return 0;
}
static int open_all(uint8_t addr)
{
    return 0;
}
static int close_all(uint8_t addr)
{
    return 0;
}
///////////////////////////////////////////////////////

static board_fn_t board_dc_fn={
    //
    
};