#include "plt.h"

static struct state_t e3ks_states[] = {
    { SMST_LAUNCH, "launch" },
    { SMST_READY, "ready" },
    { SMST_ERR, "err" },
};

static struct err_t e3ks_errs[] = {
    { E3KSERR_NONE, "none" },

    // launch
    { E3KSERR_LAUNCH_COMMER, "launch, comm err" },

    // err
    { E3KSERR_ERR_COMMERR, "err, comm err" }, 

    // ready
    { E3KSERR_READY_COMMERR, "ready, comm err" },   
    { E3KSERR_READY_LINEFAULT_DETECTED, "ready, line fault detected" },
    { E3KSERR_READY_UPSFAULT_DETECTED, "ready, ups fault detected" },      
};

static void e3ks_sm_launch( int idx )
{
	struct e3ks_t* dev = &e3ks[idx];
    struct comm_t* comm = &dev->comm;
    struct statemachine_t* sm = &dev->sm;

    if( sm_get_step(sm) == 0 ){ // entry
        log_dbg("%s, idx:%d, state:%s, step:%d, entry", __func__, idx, sm_get_szstate(sm), sm_get_step(sm));       
        e3ks_reset_cmd(idx);
        e3ks_s_comm_reset(idx);
        sm_set_step(sm, 20);
    }
    /*
    if( sm_get_step(sm) == 0 ){ // entry
        log_dbg("%s, idx:%d, state:%s, step:%d, entry", __func__, idx, sm_get_szstate(sm), sm_get_step(sm));       
        e3ks_reset_cmd(idx);
        sm_set_step(sm, 10);
    }else if( sm_get_step(sm) == 10){ // wait cmd
        if( e3ks_get_cmd(idx) == CMD_SM_READY){
            log_dbg("%s, idx:%d, state:%s, step:%d, get ready cmd, try to comm",
                            __func__, idx, sm_get_szstate(sm), sm_get_step(sm));            
            e3ks_reset_cmd(idx);
            e3ks_s_comm_reset(idx);
            sm_set_step(sm, 20);
        }
    }*/else if( sm_get_step(sm) == 20){ // chk comm state
        if( comm_get_state(comm) == COMMST_NORMAL){
            log_dbg("%s, idx:%d, state:%s, step:%d, comm ok, goto ready",
                            __func__, idx, sm_get_szstate(sm), sm_get_step(sm));            
            sm_set_state(sm, SMST_READY, E3KSERR_NONE);
        }else{
            log_dbg("%s, idx:%d, state:%s, step:%d, comm err, stay err",
                            __func__, idx, sm_get_szstate(sm), sm_get_step(sm));            
            sm_set_state(sm, SMST_ERR, E3KSERR_LAUNCH_COMMER);
        }
    }
}

static void e3ks_sm_err( int idx )
{
	struct e3ks_t* dev = &e3ks[idx];
    struct comm_t* comm = &dev->comm;
    struct statemachine_t* sm = &dev->sm;
    static double ts_last_try;
    double ts;

    if( sm_get_step(sm) == 0 ){ // entry
        log_dbg("%s, idx:%d, state:%s, step:%d, entry", __func__, idx, sm_get_szstate(sm), sm_get_step(sm));   
        e3ks_reset_cmd(idx);
        sm_set_step(sm, 10);
        ts_last_try = sm_get_timeofday();
    }else if( sm_get_step(sm) == 10){ // wait cmd
        ts = sm_get_timeofday();
        if( e3ks_get_cmd(idx) == CMD_SM_READY){
            log_dbg("%s, idx:%d, state:%s, step:%d, get ready cmd, try to comm",
                            __func__, idx, sm_get_szstate(sm), sm_get_step(sm));            
            e3ks_reset_cmd(idx);
            e3ks_s_comm_reset(idx);
            sm_set_step(sm, 20);
        }else if( ts - ts_last_try > 60000 ){ // 60s
            ts_last_try = ts;
            e3ks_s_comm_reset(idx);
            sm_set_step(sm, 20);
        }
    }else if( sm_get_step(sm) == 20){ // chk comm state
        if( comm_get_state(comm) == COMMST_NORMAL){
            log_dbg("%s, idx:%d, state:%s, step:%d, comm ok, goto ready",
                            __func__, idx, sm_get_szstate(sm), sm_get_step(sm));            
            sm_set_state(sm, SMST_READY, E3KSERR_NONE);
        }else{
            log_dbg("%s, idx:%d, state:%s, step:%d, comm err, stay err",
                            __func__, idx, sm_get_szstate(sm), sm_get_step(sm));            
            sm_set_state(sm, SMST_ERR, E3KSERR_ERR_COMMERR);
        }
    }
}

static void e3ks_sm_ready( int idx )
{
	struct e3ks_t* dev = &e3ks[idx];
    struct comm_t* comm = &dev->comm;
    struct statemachine_t* sm = &dev->sm;  

    /* chk comm state */ 
    if( comm_get_state(comm) != COMMST_NORMAL){ 
        log_dbg("%s, idx:%d, state:%s, step:%d, comm err detected, goto err",
                                __func__, idx, sm_get_szstate(sm), sm_get_step(sm));
        sm_set_state(sm, SMST_ERR, E3KSERR_READY_COMMERR);
        return;
    }

    if( sm_get_step(sm) == 0 ){ // entry
        log_dbg("%s, idx:%d, state:%s, step:%d, entry", __func__, idx, sm_get_szstate(sm), sm_get_step(sm));   
        e3ks_reset_cmd(idx);
        sm_set_step(sm, 10);
    }else if(  sm_get_step(sm) == 10 ){ // wait and chk
        if( e3ks_get_line_fault(idx) == 1 ){
            log_dbg("%s, idx:%d, state:%s, step:%d, line fault detected, goto err", __func__, idx, sm_get_szstate(sm), sm_get_step(sm));   
            sm_set_state(sm, SMST_ERR, E3KSERR_READY_LINEFAULT_DETECTED);            
        }else if( e3ks_get_ups_fault(idx) == 1 ){
            log_dbg("%s, idx:%d, state:%s, step:%d, ups fault detected, goto err", __func__, idx, sm_get_szstate(sm), sm_get_step(sm));   
            sm_set_state(sm, SMST_ERR, E3KSERR_READY_UPSFAULT_DETECTED);            
        }
    }
}

void e3ks_sm( int idx )
{
    struct e3ks_t* dev = &e3ks[idx];
    struct statemachine_t* sm = &dev->sm;

    sm_cal_timing(sm);
       
	switch(sm_get_state( sm ))
	{
		case SMST_LAUNCH:
			e3ks_sm_launch( idx );
			break;

		case SMST_READY:
			e3ks_sm_ready( idx );
			break;

		case SMST_ERR:
			e3ks_sm_err( idx );
			break;            

		default:
			log_dbg("%s, never reach here",__func__);
			break;
	}
}

int e3ks_sm_init(int idx)
{
    struct statemachine_t* sm = &e3ks[idx].sm;

    sm_reset_timing(sm, 100, 100);
    sm->states = e3ks_states;
    sm->state_nbr = sizeof(e3ks_states)/sizeof(struct state_t);
    sm->errs = e3ks_errs;
    sm->err_nbr = sizeof(e3ks_errs)/sizeof(struct err_t);
    sm_set_state( sm, SMST_LAUNCH, E3KSERR_NONE );
    
    return 0;
}