#include "plt.h"

int e3ks_nbr;
struct e3ks_t e3ks[E3KS_NBR_MAX + 1];

static int e3ks_dbcb_0(void *para,int ncolumn,char ** columnvalue,char *columnname[])
{
    int i;
    struct dbcbparam_t* pcbparam = (struct dbcbparam_t*)para;
    struct e3ks_t* dev = &e3ks[1];

    pcbparam->nrow++;
    log_dbg("%s, ++, row:%d, col:%d", __func__,pcbparam->nrow,ncolumn);

    for( i = 0; i < ncolumn; i++){
        if( strcmp("info",columnname[i]) == 0){
            strcpy(dev->szinfo,columnvalue[i]);
        }else if( strcmp("adr",columnname[i]) == 0){
            dev->comm.adr = atoi(columnvalue[i]);
        }else if( strcmp("chan_idx",columnname[i]) == 0){
            dev->comm.chanidx = atoi(columnvalue[i]);
        }
    }

    pcbparam->ret = 0;
    log_dbg("%s, --,ret:%d",__func__,pcbparam->ret);
    return 0;
}

int e3ks_chk_state( int idx, int stat )
{
    return e3ks_get_state(idx) == stat ? 0 : -1;
}

int e3ks_get_batv( int idx )
{
    return e3ks[idx].bat_v;
}

int e3ks_get_temp( int idx )
{
    return e3ks[idx].temp;
}

/* NOTE this is the status of the device , not the state machine */
int e3ks_get_status( int idx )
{
    return e3ks[idx].status;
}

char* e3ks_get_status_str( int idx )
{
    return e3ks[idx].szstatus;
}

int e3ks_get_line( int idx )
{
    return e3ks[idx].line;
}

int e3ks_get_ups_fault( int idx )
{
    return e3ks[idx].ups_fault;
}

int e3ks_get_bat_low( int idx )
{
    return e3ks[idx].bat_low;
}

int e3ks_get_line_fault( int idx )
{
    return e3ks[idx].line_fault;
}

static void* e3ks_thrd_main(void* param)
{
    log_dbg("%s, ++",__func__);

    e3ks_s_comm_init(1);
    e3ks_sm_init(1);
    /* running */
    while( 1 ){
        e3ks_s_comm_dac(1);
        e3ks_sm( 1 );
        sleep(1); //1s
    }
    log_dbg("%s, --",__func__);
}

int e3ks_chk_stat_all( int stat)
{
    int idx;
    for( idx = 1; idx <= e3ks_nbr; idx++){
        if( e3ks_get_state(idx) != stat){
            return -1;
        }
    }
    return 0;
}

int e3ks_send_sm_cmd_all( int cmd )
{
    int ret = 0;
    int idx;
    for( idx = 1; idx <= e3ks_nbr; idx++ ){
        e3ks_send_sm_cmd( idx, cmd );
    }

    log_dbg("%s, idx:%d, cmd:%d, ret:%d",__func__, idx, cmd, ret);
    return ret;
}

int e3ks_init()
{
    pthread_t thrd;
    int ret = 0;
    int result;
    char *errmsg = NULL;
    char sql[1024];
    struct dbcbparam_t cbparam;
    sqlite3* db = NULL;
    int idx;
    struct e3ks_t* dev = &e3ks[1];

    log_dbg( "%s, ++",__func__);

    plt_lock_ctndb();
    db = plt_get_ctndb();
    sprintf(sql,"select * from e3ks");
    cbparam.nrow = 0;
	result = sqlite3_exec(db,sql, e3ks_dbcb_0,(void*)&cbparam,&errmsg);
    plt_unlock_ctndb();
	if( result != SQLITE_OK ){
        log_dbg("%s, result != SQLITE_OK, result:%d", __func__, result);
        ret = -1;
	 }else if( cbparam.ret != 0){
         log_dbg("%s, cbparam.ret != 0, %d", __func__, cbparam.ret);
        ret = -2;
	 }else if( cbparam.nrow != 1 ){
        log_dbg("%s, cbparam.nrow != 1, %d", __func__, cbparam.nrow);
        ret = -3;
     }else{
        e3ks_nbr = 1;
        if(pthread_create(&thrd, NULL, e3ks_thrd_main, NULL) != 0){
            log_dbg( "%s, create e3ks thrd main fail", __func__);
            ret = -1;
        }   
	 }

    log_dbg( "%s, --, ret:%d", __func__, ret);
    return ret;
}

int e3ks_send_sm_cmd( int idx, int val )
{
    int ret = 0;
    struct e3ks_t* dev = &e3ks[idx];

    dev->cmd = val;

leave:
    log_dbg("%s, idx:%d, cmd:%d, ret:%d",__func__, idx, val, ret);
    return ret;
}


int e3ks_get_cmd( int idx)
{
	return e3ks[idx].cmd;
}

int e3ks_set_dbg(int idx, int val)
{
    e3ks[idx].dbg = val;
    return 0;
}

void e3ks_reset_cmd( int idx)
{
	e3ks[idx].cmd = CMD_SM_DONE;
}

int e3ks_get_state(int idx)
{
    return e3ks[idx].sm.state;
}

char* e3ks_get_info_str(int idx)
{
    return e3ks[idx].szinfo;
}

int e3ks_get_chan_idx(int idx)
{
    struct e3ks_t* dev = &e3ks[idx];
    struct comm_t* comm = &dev->comm;
    return comm_get_chan_idx(comm);
}

int e3ks_get_adr(int idx)
{
    struct e3ks_t* dev = &e3ks[idx];
    struct comm_t* comm = &dev->comm;
    return comm_get_adr(comm);
}

int e3ks_get_tick(int idx)
{
    return e3ks[idx].sm.tick;
}

char* e3ks_get_state_str(int idx)
{
    return e3ks[idx].sm.szState;
}

int e3ks_get_comm_state(int idx)
{
    return e3ks[idx].comm.state;
}

char* e3ks_get_comm_state_str(int idx)
{
    return e3ks[idx].comm.szState;
}

int e3ks_get_tool_data(int idx,char* buf)
{
    struct e3ks_t* dev = &e3ks[idx];
    struct statemachine_t* sm = &dev->sm;
    struct comm_t* comm = &dev->comm;
    char temp_buf[1024];

    if(idx < 1 || idx > e3ks_nbr || buf == NULL){
        return -1;
    }

    sm_get_summary(sm, temp_buf, sizeof(temp_buf));
    sprintf(buf," %s ", temp_buf);
    
    comm_get_summary(comm, temp_buf, sizeof(temp_buf));
    strcat(buf,temp_buf);

    sprintf(temp_buf,"  dbg:%d input_voltage:%.1f output:%.1f load_occupy:%d temp:%d line_fault:%d bat_low:%d ups_fault:%d\n", 
                dev->dbg, dev->input_voltage, dev->output_voltage, dev->load_occupy, dev->temp, dev->line_fault, dev->bat_low, dev->ups_fault );
    strcat(buf,temp_buf);
    
    return 0;
}

int e3ks_get_tbmqtt_data(int idx,char* buf)
{
    sprintf(buf, "'ups_state':'%s','ups_fault':%d,\
'ups_line_fault':%d,\
'ups_bat_low':%d,\
'ups_temp':%d", 
            e3ks_get_state_str( idx ),
            e3ks_get_ups_fault( idx ), 
            e3ks_get_line_fault( idx ),
            e3ks_get_bat_low( idx ),
            e3ks_get_temp( idx ));
    return 0;
}

int e3ks_get_cloud_data(int ctn_idx,int idx,char* buf)
{
    sprintf(buf, "'id':'ups_%d', 'ups_fault':%d,\
'ups_line_fault':%d,\
'ups_bat_low':%d,\
'ups_temp':%d,\
'ups_state':%d", 
        idx, e3ks_get_ups_fault( idx ), 
        e3ks_get_line_fault( idx ),
        e3ks_get_bat_low( idx ),
        e3ks_get_temp( idx ),
        e3ks_get_state( idx ));
    return 0;   
}

int e3ks_get_bkds_data(int idx,char* buf)
{
    sprintf(buf,"\
\"info\":\"%s\",\"model\":\"%s\",\"chan_idx\":%d,\"adr\":%d,\"state\":\"%s\",\
\"tick\":%d,\"comm_state\":\"%s\",\"bat_v\":%d,\"temp\":%d,\"status\":\"%s\",\
\"line\":%d\
",
    "ac","e3ks",e3ks_get_chan_idx( idx ),e3ks_get_adr( idx ),e3ks_get_state_str( idx ),
    e3ks_get_tick( idx ),e3ks_get_comm_state_str( idx ),e3ks_get_batv( idx ),e3ks_get_temp( idx ),e3ks_get_status_str( idx ),
    e3ks_get_line( idx )
    );
}