#include "configm.h"
#include "rpc.h"
#include "parsefile.h"
#include "LTE_config.h"


int g_action = 0;

ret_code compare(char *result)
{
    if(NULL == result)
    {
         return RET_NULL_INPUT_ERR;
	}

	if(strstr(result,"lte no match") != NULL)
	{
        return RET_LTE_NO_MATCH_ERR;
	}

	else if(strstr(result,"no found lte module") != NULL)
	{
        return RET_NO_LTE_MODULE_ERR;
	}

	else if(strstr(result,"4g init done") != NULL)
	{
        return RET_OK; 
	}

	else 
	{
        return RET_UNKNOWN;
	}
}


ret_code LTE_config_init()
{
     ret_code ret = RET_OK;
	 char result[RESULT_LENGTH] = {0};
	 FILE *f = NULL;
	 f = popen("/etc/ppp/ppp-4g init","r");

	 if (NULL == f)
	 {
        rpc_log_info("execuate cmd fail\n");
		return RET_EXEC_SHELL_ERR;
	 }

     fseek(f,0,SEEK_SET);
	 
	 while(fgets(result,sizeof(result),f) != NULL)
	 {
	 	 rpc_log_info("%s\n",result);
         ret = compare(result);
		 memset(result,sizeof(result),0);
		 fseek(f,0,SEEK_CUR);
	 }

	 pclose(f);

     return ret;
}

/*
{
   "operate":"set",
   "action":"start"
}

{
   "operate":"getall"
}
*/

ret_code LTE_json_parse(pointer input, uint *conf_type, int action)
{
  ret_code ret = RET_OK;
  if(NULL == input)
    {
        return RET_NULL_INPUT_ERR;
	}

   cJSON *json_obj = cJSON_Parse(input);
	
   if(NULL == json_obj)
    {
        rpc_log_info("json obj is NULL \n");
		return RET_EMPTY_STRING;
    }

    rpc_json_print(json_obj);

	cJSON *operate = cJSON_GetObjectItem(json_obj,"operate");
	if((NULL == operate) || (NULL == (operate->valuestring)))
		{
          cJSON_Delete(json_obj);
		  return RET_EMPTY_STRING;
	   }
	
    rpc_log_info("operate is %s\n",operate->valuestring);
	
	if(strcmp(operate->valuestring,"set") == 0)
	   {
         *conf_type = CM_CONFIG_SET;
	   }
	else if(strcmp(operate->valuestring,"getall") == 0)
	  {
         *conf_type = CM_CONFIG_GET_ALL;
		 cJSON_Delete(json_obj);
		 return RET_OK;
	   }
	else
	   {
	   	  cJSON_Delete(json_obj);
          return RET_INPUTERR;
	   }

    rpc_log_info("config type is %d\n",*conf_type);
    cJSON *action_type;
	action_type = cJSON_GetObjectItem(json_obj,"action");
	if((NULL == action_type) || (NULL == (action_type->valuestring)))
	  {
	     cJSON_Delete(json_obj);
         return RET_NULL_INPUT_ERR;         
	   }
	else
	  {
	  	  rpc_log_info("action is %s\n",action_type->valuestring);
          if(strcmp(action_type->valuestring,"start") == 0)
            {
                g_action = START;
		     }
		  else if(strcmp(action_type->valuestring,"restart") == 0)
		    {
               g_action = RESTART;
		    }
		  else if(strcmp(action_type->valuestring,"stop") == 0)
		    {
                g_action = STOP;
		    }
		  else if(strcmp(action_type->valuestring,"init") == 0)
		    {
                g_action = INIT;
		    }
		  else
		    {
                cJSON_Delete(json_obj);
                return RET_INPUTERR; 
		    }
	  }

    rpc_log_info("action type is %d\n",g_action);
	cJSON_Delete(json_obj);
	return ret;
}

/*void killpid()
{
    char pid[10] = 
{0};
	char cmd[20] = {0};
	int pid_int;
	FILE *fp = NULL;
	fp = popen(GETPID,"r");
	if(NULL == fp)
	  {
		 rpc_log_info("can not get pid\n");
		 return;
	  }
	fgets(pid,sizeof(pid),fp);
	sscanf(pid,"%d",&pid_int);
	sprintf(cmd,"kill %d",pid_int);
	system(cmd);
	pclose(fp);
}*/

ret_code start_lte()
{
    char result[RESULT_LENGTH] = {0};
	int i = 0;
	
	FILE *f = NULL;

	f = popen("/etc/ppp/ppp-4g start","r");

	if (NULL == f)
	 {
        rpc_log_info("execuate cmd fail\n");
		return RET_EXEC_SHELL_ERR;
	 }

    fseek(f,0,SEEK_SET);

	fgets(result,sizeof(result),f);

	rpc_log_info("%s\n",result);

	if(strstr(result,"not install lte") != NULL )
       {
	   	 pclose(f);
         return RET_NO_LTE_MODULE_ERR; 
	   }

	else if(strstr(result,"pppd apparently already active") 
!= NULL)
	   {
          pclose(f);
		  return RET_ALREADY_START_ERR;
	   }
	else if(strstr(result,"start pppd ppp0") != NULL)
	   {
	   	  pclose(f);
          return RET_OK;
/*	   	while(i < 120)
	   	{
	   	  if(access(file_path,0) != -1)
	   	  {
             sleep(1000);
			 i
++;
		  }
		  else
		  {
		  	 pclose(f);
             return RET_OK;
		  }
	   }
		
		pclose(f);
		//杀死进程
		killpid();
		rpc_log_info("please check the sim card\n");
        return RET_EXEC_SHELL_ERR;*/
	 }
    else
       {
           pclose(f);
		   return RET_EXEC_SHELL_ERR;
	   }
}

ret_code stop_lte()
{
    char result[RESULT_LENGTH] = {0};
	
	FILE *f = NULL;
	f = popen("/etc/ppp/ppp-4g stop","r");

	if (NULL == f)
	 {
        rpc_log_info("execuate cmd fail\n");
		return RET_EXEC_SHELL_ERR;
	 }

    fseek(f,0,SEEK_SET);

	fgets(result,sizeof(result),f);

	rpc_log_info("%s\n",result);

	if(strstr(result,"pppd may be sotped already") != NULL)
       {
	   	 pclose(f);
         return RET_ALREADY_STOP_ERR; 
	   }

	else if((strstr(result,"stop pppd ppp0") != NULL) && access(file_path,0) != -1)
	   {
          pclose(f);
		  return RET_OK;
	   }
	else
	  {
          pclose(f);
		  return RET_EXEC_SHELL_ERR;
	   }
	
}

ret_code restart_lte()
{
     char result[RESULT_LENGTH] = {0};
	 int i = 0;
	 
	 FILE *f = NULL;
	 f = popen("/etc/ppp/ppp-4g restart","r");

	 if (NULL == f)
		  {
			 rpc_log_info("execuate cmd fail\n");
			 return RET_EXEC_SHELL_ERR;
		  }

	fseek(f,0,SEEK_SET);
	fgets(result,sizeof(result),f);
	memset(result,0,sizeof(result));
	fseek(f,0,SEEK_CUR);
	fgets(result,sizeof(result),f);

	rpc_log_info("%s\n",result);

	if(strstr(result,"not install lte! ") != NULL)
       {
	   	 pclose(f);
         return RET_NO_LTE_MODULE_ERR; 
	   }

	else if(strstr(result,"pppd apparently already active") != NULL)
	   {
          pclose(f);
		  return RET_ALREADY_START_ERR;
	   }
	else if(strstr(result,"start pppd ppp0") != NULL) 
	   {
	   	 pclose(f);
         return RET_OK;
/*	   	while(i < 120)
	   	{
	   	  if(access(file_path,0) != -1)
	   	  {
             sleep(1000);
			 i
++;
		  }
		  else
		  {
		  	 pclose(f);
             return RET_OK;
		  }
	     }		
		pclose(f);
		//杀死进程
		killpid();
		rpc_log_info("please check the sim card\n");
        return RET_EXEC_SHELL_ERR;*/
	 }	 
	
    else
      {
         pclose(f);
	     return RET_EXEC_SHELL_ERR;
	   }
    
}

ret_code lte_to_json(char *status, int connect_time, pointer output, int *output_len)
{
    if(NULL == status || NULL ==  output || NULL == output_len)
     {
        return RET_NULL_INPUT_ERR;
	 }

	ret_code ret = RET_OK;
	cJSON *ret_root = cJSON_CreateObject();
	if(ret_root == NULL)
       {
            cJSON_Delete(ret_root);
            return RET_EMPTY_STRING;
       }

	cJSON_AddStringToObject(ret_root,"status", status);

	if(connect_time != 0)
	{
       cJSON_AddNumberToObject(ret_root,"connect_time",connect_time);
	}

	rpc_json_print(ret_root);

	char *status_info = cJSON_PrintUnformatted(ret_root);
	*output_len = strlen(status_info) + 1;
    memcpy(output, status_info, *output_len);
    
    free(status_info);
    cJSON_Delete(ret_root); 

	return ret;
}

ret_code status_lte(pointer output, int *output_len)
{
    if((NULL == output) || (NULL == output_len))
	  {
		return RET_INPUTERR;
	  }

	char result[RESULT_LENGTH] = {0};
	char status[STATUS_LENGTH] = {0};
	int connect_time = 0;
	ret_code ret = RET_OK;
	
    FILE *f = NULL;
    f = popen("/etc/ppp/ppp-4g status","r");
    if(NULL == f)
       {
			 rpc_log_info("execuate cmd fail\n");
			 return RET_EXEC_SHELL_ERR;
		  }
    
	fgets(result,sizeof(result),f);
	rpc_log_info("%s\n",result);
	if(strstr(result,"off") != NULL)
	  {
        strcpy(status,"off");
		//封装json
		ret = lte_to_json(status,connect_time,output,output_len);
		pclose(f);
		return ret;
	  }
	else if(strstr(result,"on") != NULL)
	  {
        strcpy(status,"on");
		memset(result,0,sizeof(result));
		fgets(result,sizeof(result),f);
		rpc_log_info("%s\n",result);
		sscanf(result,"ppp_keep_time=%d",&connect_time);
		ret = lte_to_json(status,connect_time,output,output_len);
		pclose(f);
		return ret;
	  }
	else
	  {
	  	pclose(f);
        return RET_UNKNOWN;
	  }
}

ret_code LTE_config_chk(uint source, uint *config_type,
                        pointer input, int *input_len,
                        pointer output, int *output_len)
{
    if((NULL == config_type) || (NULL == input) || (NULL == input_len) || (NULL == output_len))
	 {
          return RET_NULL_INPUT_ERR;
	 }

	 ret_code ret = RET_OK;
     //int action = 0;
	 
	 ret = LTE_json_parse(input,config_type,g_action);

	 return ret;
}

ret_code LTE_config_proc(uint source, uint config_type,
						pointer input, int input_len,
					    pointer output, int *output_len)
{
	 ret_code ret = RET_OK;

	 if(config_type == CM_CONFIG_SET)
	 {
	   switch(g_action){
         case START:
			ret = start_lte();
			break;
		 case RESTART:
			ret = restart_lte();
			break;
	     case STOP:
			ret = stop_lte();
			break;
		 case INIT:
			ret = LTE_config_init();
			break;
		 default:
			ret = RET_INPUTERR;
			break;
	   }
	 }

	  else
	    {
           ret = RET_INPUTERR;
	     }

	 return ret;
}


ret_code LTE_config_get_all(uint source, 
			              pointer output, int *output_len)
{
       if((NULL == output) || (NULL == output_len))
		{
			return RET_INPUTERR;
		}

	   ret_code ret = RET_OK;

       *output_len = 0;
	   ret = status_lte(output, output_len);
	   
	   rpc_log_info("status is %s\n",(char *)output);
       return ret;
      
}