#include "plt.h"

struct pws1_t pws1[PWS1_NBR_MAX + 1];

int pws1_reset_bsytikchk(int idx)
{
    pws1[idx].bsytik.timer = 0;
    pws1[idx].bsytik.timeout = 0;
    pws1[idx].bsytik.chkcnt = 0;
    return 0;
}

// 0 : not timeout
// 1 : timeout
int pws1_is_bsytikchk_timeout(int idx)
{
    struct pws1_t* dev = &pws1[1];
    if( dev->bsytik.chken == 1 ){
        return pws1[idx].bsytik.timeout;
    }else{
        return 0;
    }
    
}

int pws1_set_bsytik(int idx)
{
    pws1[idx].bsytik.from_host++;
    return 0;
}

int pws1_get_bsytikchk_from_host(int idx)
{
    pws1[idx].bsytik.from_host++;
    return 0;
}

int pws1_get_bsytikchk_en(int idx)
{
   return pws1[idx].bsytik.chken;
}

int pws1_set_bsytikchk_en(int idx, int val)
{
    pws1[idx].bsytik.chken = val;
    return 0;
}

int pws1_set_dac_param_en(int idx, int val)
{
    struct pws1_t* dev = &pws1[1];
    struct comm_t* comm = &dev->comm;
    comm_set_dac_param_en(comm, val);
    return 0;
}

static int pws1_dbcb_0(void *para,int ncolumn,char ** columnvalue,char *columnname[])
{
    int i;
    struct dbcbparam_t* pcbparam = (struct dbcbparam_t*)para;
    struct pws1_t* dev = &pws1[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 pws1_get_cmd( int idx )
{
    return pws1[idx].cmd;
}

int pws1_get_comm_st(int idx)
{
    struct pws1_t* dev = &pws1[idx];
    struct comm_t* comm = &dev->comm;
    return comm_get_state(comm);
}

void pws1_reset_cmd(int idx)
{
    pws1[idx].cmd = CMD_SM_DONE;
}

int pws1_get_state( int idx )
{
    return pws1[idx].sm.state;
}

char* pws1_get_state_str( int idx )
{
    return pws1[idx].sm.szState;
}

int pws1_get_step( int idx )
{
    return pws1[idx].sm.step;
}

int pws1_get_tick( int idx )
{
    return pws1[idx].sm.tick;
}

double pws1_get_tick_ave( int idx )
{
    return pws1[idx].sm.timing_ave;
}

double pws1_get_tick_cur( int idx )
{
    return pws1[idx].sm.timing_cur;
}

double pws1_get_tick_max( int idx )
{
    return pws1[idx].sm.timing_max;
}

char* pws1_get_err_str( int idx )
{
    return pws1[idx].sm.szerr;
}

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

int pws1_get_ap( int idx )
{
    return pws1[idx].pow.ap;
}

int pws1_get_dcp( int idx )
{
    return (int)pws1[idx].Pdc;
}

int pws1_get_dev_aps( int idx )
{
    return (int)pws1[idx].active_p_set;
}

int pws1_get_dcv( int idx )
{
    return (int)pws1[idx].Udc;
}

int pws1_get_dcc( int idx )
{
    return (int)pws1[idx].Idc;
}

int pws1_get_errstat( int idx )
{
    return pws1[idx].errstatus;
}

double pws1_get_grid_freq( int idx )
{
    return pws1[idx].grid_freq;
}

double pws1_get_uab( int idx )
{
    return pws1[idx].Uab;
}

double pws1_get_ubc( int idx )
{
    return pws1[idx].Ubc;
}

double pws1_get_uca( int idx )
{
    return pws1[idx].Uca;
}

double pws1_get_ia( int idx )
{
    return pws1[idx].Ia;
}
double pws1_get_ib( int idx )
{
    return pws1[idx].Ib;
}
double pws1_get_ic( int idx )
{
    return pws1[idx].Ic;
}

static void pws1_update(int idx)
{
    struct pws1_t* dev = &pws1[idx];

    dev->pow.ap = (int)(-dev->Ps);
}

static void* pws1_thrd_main(void* param)
{
    int idx = 1;
    struct pws1_t* dev = &pws1[idx];    
    log_dbg("%s, idx:%d, ++",__func__, idx);

    pws1_set_bsytikchk_en(idx, 1);
    pws1_sm_init(1);
    pws1_comm_init(1);
    while(1){
        pws1_comm_dac(1);
        pws1_sm(1);
        pws1_update(1);
        usleep(10000); /* 10ms */
    }
    log_dbg("%s, --",__func__);
}

static void* pws1_thrd_aux(void* param)
{
    int idx = 1;
    struct pws1_t* dev = &pws1[idx];
    struct statemachine_t* sm = &dev->sm;
    log_dbg("%s, ++",__func__);

    while(1){
        if( dev->bsytik.timer++ >= 10 ){ // chk every 1 second
            dev->bsytik.timer = 0;
            if( dev->bsytik.last_from_host != dev->bsytik.from_host ){ // refresh
                dev->bsytik.last_from_host = dev->bsytik.from_host;
                dev->bsytik.chkcnt = 0;
            }else{ // counting
                if( dev->bsytik.chkcnt++ >= 5){ // 5s
                    dev->bsytik.timeout = 1;
                    dev->bsytik.chkcnt = 0;
                }
            }
        } 
        usleep(100000); /* 100ms */
    }
    log_dbg("%s, --",__func__);
}

int pws1_init()
{
    pthread_t thrd;
    int ret = 0;
    int result;
    char *errmsg = NULL;
    char sql[1024];
    struct dbcbparam_t cbparam;
    sqlite3* db = NULL;
    struct pws1_t* dev = &pws1[1];

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

    plt_lock_ctndb();
    db = plt_get_ctndb();
    sprintf(sql,"select * from pws1");
    cbparam.nrow = 0;
	result = sqlite3_exec(db,sql, pws1_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{
        if(pthread_create(&thrd, NULL, pws1_thrd_main, NULL) != 0){
            log_dbg( "%s, create pws1 thrd main fail", __func__);
            ret = -1;
        }else if(pthread_create(&thrd, NULL, pws1_thrd_aux, NULL) != 0){
            log_dbg( "%s, create pws1 thrd aux fail", __func__);
            ret = -1;
        }       
	 }

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

int pws1_send_sm_cmd( int idx, int val )
{
    int ret = 0;
    struct pws1_t* dev = &pws1[idx];

    dev->cmd = val;

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

int pws1_get_runmod( int idx )
{
    return pws1[idx].grid_mode;
}

int pws1_get_runstat( int idx )
{
    return pws1[idx].runState;
}

int pws1_get_dispatch_mode( int idx)
{
    return pws1[idx].energy_dispatching_mode;
}

int pws1_get_dhg_state( int idx)
{
    return pws1[idx].status13.bits_val.string1_dhg;
}

int pws1_get_chg_state( int idx)
{
    return pws1[idx].status13.bits_val.string1_chg;
}

int pws1_get_active_power_control_mode( int idx)
{
    return pws1[idx].active_power_control_mode;
}

// char* pws1_get_runstat_str( int idx )
// {
//     return pws1[idx].szrunstatus;
// }

int pws1_set_aps(int idx, int aps)
{
    struct pws1_t* dev = &pws1[idx];
    int ret = 0;
    dev->pow.last_aps = dev->pow.aps;
    dev->pow.aps = aps;
    log_dbg( "%s, idx:%d, aps:%d, last_aps:%d", __func__, idx, dev->pow.aps, dev->pow.last_aps);
    return ret;
}

int pws1_reset_aps(int idx)
{
    struct pws1_t* dev = &pws1[idx];
    int ret = 0;
    dev->pow.last_aps = 0;
    dev->pow.aps = 0;
    //log_dbg( "%s, idx:%d, val:%d, ret:%d", __func__, idx, aps, ret);
    return ret;
}

int pws1_get_aps(int idx)
{
    return pws1[idx].pow.aps;
}

int pws1_get_last_aps(int idx)
{
    return pws1[idx].pow.last_aps;
}

int pws1_is_aps_changed(int idx)
{
    return (pws1[idx].pow.aps != pws1[idx].pow.last_aps)?1:0;
}

int pws1_get_chan_idx(int idx)
{
    return pws1[idx].comm.chanidx;
}

int pws1_get_adr(int idx)
{
    return pws1[idx].comm.adr;
}

char* pws1_get_comm_state_str(int idx)
{
    return  pws1[idx].comm.szState;
}

double pws1_get_dac_ave(int idx)
{
    return  pws1[idx].comm.dac.timing_ave;
}

double pws1_get_dac_cur(int idx)
{
    return  pws1[idx].comm.dac.timing_cur;
}

double pws1_get_dac_max(int idx)
{
    return  pws1[idx].comm.dac.timing_max;
}

// unsigned short* pws1_get_faults(int idx)
// {
//     return  pws1[idx].faults;
// }

// unsigned short* pws1_get_warns(int idx)
// {
//     return  pws1[idx].warns;
// }

int pws1_get_dac_param_en(int idx)
{
    return pws1[idx].comm.dac.param_en;
}

char* pws1_get_info_str(int idx)
{
    return pws1[idx].szinfo;
}


struct pws1_t* pws1_get_all_data_ptr()
{
    return &pws1[1];
}

int pws1_get_tool_data(int idx,char* buf)
{
    if(idx < 1 || idx > PWS1_NBR_MAX || buf == NULL){
        return -1;
    }

    struct pws1_t* dev = &pws1[idx];
    struct statemachine_t* sm = &dev->sm;
    struct comm_t* comm = &dev->comm;
    char temp_buf[8192];
    int i = 0;
    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,"bsytik_from_host:%03d timeout:%d en:%d\n",dev->bsytik.from_host, dev->bsytik.timeout, dev->bsytik.chken);  
    strcat(buf, temp_buf); 
    
    sprintf(temp_buf,"runState:"L_GREEN"%s"NONE" runMode:"L_GREEN"%s"NONE" P:"L_GREEN"%.1f"NONE" Ps:"L_GREEN"%.1f"NONE" \
DCbrokerState:%s \
grid_freq:%.1f,Uab:%.3f,Ubc:%.3f,Uca:%.3f,\
Ia:%.3f,Ib:%.3f,Ic:%.3f,\
Udc:%.1f,Idc:%.1f,Pdc:%.3f,\
chg:%d,dhg:%d,t_chg:%d,t_dhg:%d,\
module_temp:%.1f,ambient_temp:%.1f,cmd_src:%s\n",
    dev->szrunState,dev->szrunMode,dev->Ps,dev->active_p_set,
    dev->szDCbrokerState,
    dev->grid_freq,dev->Uab,dev->Ubc,dev->Uca,
    dev->Ia,dev->Ib,dev->Ic,
    dev->Udc,dev->Idc,dev->Pdc,
    dev->chg_daily_energy_ac,dev->dhg_daily_energy_ac,dev->chg_accu_energy_ac,dev->dhg_accu_energy_ac,
    dev->module_temp,dev->ambient_temp,dev->szcmdSrc);
    strcat(buf, temp_buf); 

    sprintf(temp_buf,"dispatchMode:%s,acControMode:%s,startupMode:%s,PowerChangeMode:%s\
offgrid_v_r:%.2f,offgrid_f_r:%.2f,\
%4d-%2d-%2d %2d:%2d:%2d\n",
    dev->szEnergy_dispatching_mode,dev->szActive_power_control_mode,dev->szStart_up_mode,dev->szPower_change_mode,
    dev->offgrid_ac_voltage_regulation,dev->offgrid_ac_freq_regulation,
    dev->year,dev->month,dev->day,dev->hour,dev->minute,dev->second);
    strcat(buf, temp_buf); 

    sprintf(temp_buf,"status:0x%04x,0x%04x,0x%04x,0x%04x,0x%04x,\
0x%04x,0x%04x,0x%04x,0x%04x,0x%04x,\
0x%04x,0x%04x,0x%04x\n",
    dev->status0.value,dev->status1.value,dev->status2.value,dev->status3.value,dev->status4.value,
    dev->status9.value,dev->status10.value,dev->status11.value,dev->status13.value,dev->status25.value,
    dev->status27.value,dev->status29.value,dev->status31.value);
    strcat(buf, temp_buf); 
}

int pws1_get_tbmqtt_main_data(int idx,char* buf)
{
    if(idx < 1 || idx > PWS1_NBR_MAX || buf == NULL){
        return -1;
    }
    struct pws1_t* dev = &pws1[idx];

    sprintf(buf, "'pcs_runstat':'%s','pcs_ap':%.1f'pcs_dcv':%.1f, 'pcs_dcc':%.1f,\
'pcs_dc_brk':%d,'pcs_errstat':%d,'pcs_state':'%s'", 
        dev->szrunState,dev->Ps,dev->Udc,dev->Idc,
        dev->DCbrokerState,dev->errstatus,dev->sm.szState);
}
//
int pws1_get_tbmqtt_secondy_data(int idx,char* buf)
{
    if(idx < 1 || idx > PWS1_NBR_MAX || buf == NULL){
        return -1;
    }
    struct pws1_t* dev = &pws1[idx];

    sprintf(buf, "'pcs_uab':%.1f, 'pcs_ubc':%.1f, 'pcs_uca':%.1f,\
'pcs_ia':%.1f, 'pcs_ib':%.1f, 'pcs_ic':%.1f,\
'pcs_module_temp':%.1f,'pcs_ambient_temp':%.1f", 
    dev->Uab,dev->Ubc,dev->Uca,
    dev->Ia,dev->Ib,dev->Ic,
    dev->module_temp,dev->ambient_temp);
}

int pws1_get_cloud_main_data(int cnt_idx,int idx,char* buf)
{
    if(idx < 1 || idx > PWS1_NBR_MAX || buf == NULL){
        return -1;
    }
    struct pws1_t* dev = &pws1[idx];
    sprintf(buf, "'ctn%d_pcs_state':%d, 'ctn%d_pcs_runstat':%d, 'ctn%d_pcs_dcv':%d, 'ctn%d_pcs_dcc':%d, \
'ctn%d_pcs_dc_brk':%d, 'ctn%d_pcs_errstat':%d, 'ctn%d_pcs_gf':%.1f, 'ctn%d_pcs_ap':%d", 
                cnt_idx, pws1_get_state( idx ), 
                cnt_idx, pws1_get_runstat( idx ), 
                cnt_idx, pws1_get_dcv( idx ), 
                cnt_idx, pws1_get_dcc( idx ),
                cnt_idx, dev->DCbrokerState,
                cnt_idx, pws1_get_errstat( idx ),
                cnt_idx, pws1_get_grid_freq( idx ),
                cnt_idx, pws1_get_ap( idx ));
}

int pws1_get_cloud_secondy_data(int cnt_idx,int idx,char* buf)
{
    if(idx < 1 || idx > PWS1_NBR_MAX || buf == NULL){
        return -1;
    }
    struct pws1_t* dev = &pws1[idx];
    sprintf(buf, "'ctn%d_pcs_uab':%.1f, 'ctn%d_pcs_ubc':%.1f, 'ctn%d_pcs_uca':%.1f,\
'ctn%d_pcs_ia':%.1f, 'ctn%d_pcs_ib':%.1f, 'ctn%d_pcs_ic':%.1f,'ctn%d_pcs_gf':%.1f,\
'ctn%d_pcs_module_temp':%.1f, 'ctn%d_pcs_ambient_temp':%.1f", 
                cnt_idx, pws1_get_uab( idx ), 
                cnt_idx, pws1_get_ubc( idx ), 
                cnt_idx, pws1_get_uca( idx ),
                cnt_idx, pws1_get_ia( idx ),
                cnt_idx, pws1_get_ib( idx ),
                cnt_idx, pws1_get_ic( idx ),
                cnt_idx, pws1_get_grid_freq( idx ),
                cnt_idx, dev->module_temp,
                cnt_idx, dev->ambient_temp);
}

int pws1_get_bkds_data(int idx,char* buf)
{
//     if(idx < 1 || idx > PWS1_NBR_MAX || buf == NULL){
//         return -1;
//     }
//     struct pws1_t* dev = &pws1[idx];
    
//     sprintf(buf,"\
// \"model\":\"%s\",\"info\":\"%s\",\"state\":\"%s\",\"step\":%d,\"err\":\"%s\",\
// \"ap\":%d,\"aps\":%d,\"tick\":%d,\"chan_idx\":%d,\"adr\":%d,\
// \"comm_state\":\"%s\",\"dac_param_en\":%d,\"bsytikchk_en\":%d,\"bsytikchk_from_host\":%d,\"bsytikchk_timeout\":%d,\
// \"dc_ovp\":%d,\"dc_uvp\":%d,\"dc_dfp\":%d,\"env_otp\":%d,\"reactor_otp\":%d,\
// \"igbt_otp\":%d,\"run_state\":\"%s\",\"dc_v\":%d,\"dc_c\":%d,\"grid_freq\":%.1f,\
// \"grid_v\":%.1f,\"grid_c\":%.1f,\"ua\":%.1f,\"ub\":%.1f,\"uc\":%.1f,\
// \"ia\":%.1f,\"ib\":%.1f,\"ic\":%.1f,\"ap\":%d,\"dc_p\":%d,\
// \"breaker_ac\":%d,\"breaker_dc\":%d,\"dcbuf_cont\":%d,\"emg_btn\":%d,\"igbt_a_temp\":%d,\
// \"igbt_b_temp\":%d,\"igbt_c_temp\":%d,\"reactor_temp\":%d,\"env_temp\":%d,\"err_status\":%d,\
// \"fault1\":\"0x%0x\",\"fault2\":\"0x%0x\",\"fault3\":\"0x%0x\",\"fault4\":\"0x%0x\",\"fault5\":\"0x%0x\",\
// \"fault6\":\"0x%0x\",\"warn1\":\"0x%0x\",\"warn2\":\"0x%0x\",\"warn3\":\"0x%0x\",\"warn4\":\"0x%0x\",\
// \"warn5\":\"0x%0x\",\"warn6\":\"0x%0x\"\
// ","pws1","pcs",pws1_get_state_str( idx ),pws1_get_step( idx ),pws1_get_err_str( idx ),
//     pws1_get_ap( idx ),pws1_get_aps( idx ),pws1_get_tick( idx ),pws1_get_chan_idx( idx ),pws1_get_adr( idx ),
//     pws1_get_comm_state_str( idx ),pws1_get_dac_param_en( idx ),pws1_get_bsytikchk_en( idx ),pws1_get_bsytikchk_from_host( idx ),pws1_is_bsytikchk_timeout( idx ),
//     pws1_get_dc_ovp( idx ),pws1_get_dc_uvp( idx ),pws1_get_dc_dfp( idx ),pws1_get_env_otp( idx ),pws1_get_reactor_otp( idx ),
//     pws1_get_igbt_otp( idx ),pws1_get_runstat_str( idx ),pws1_get_dcv( idx ),pws1_get_dcc( idx ),pws1_get_grid_freq( idx ),
//     pws1_get_gridv( idx ),pws1_get_gridc( idx ),pws1_get_ua( idx ),pws1_get_ub( idx ),pws1_get_uc( idx ),
//     pws1_get_ia( idx ),pws1_get_ib( idx ),pws1_get_ic( idx ),pws1_get_ap( idx ),pws1_get_dcp( idx ),
//     pws1_get_breaker_ac( idx ),pws1_get_breaker_dc( idx ),pws1_get_dcbuf_cont( idx ),pws1_get_emg_btn( idx ),pws1_get_temp_igbt_a( idx ),
//     pws1_get_temp_igbt_b( idx ),pws1_get_temp_igbt_c( idx ),pws1_get_temp_reactor( idx ),pws1_get_temp_env( idx ),pws1_get_errstat( idx ),
//     faults[0],faults[1],faults[2],faults[3],faults[4],
//     faults[5],warns[0],warns[1],warns[2],warns[3],
//     warns[4],warns[5]);
}