#include <stdio.h>
#include <stdlib.h>

#include <llapi.h>
#include <unistd.h>
#include <fcntl.h>
#include <time.h>
#include <string.h>
#include <errno.h>

#include <sys/types.h>
#include <sys/stat.h>

#define CHAR_BUFFER 256
#define FILE_LENGTH 1024

void getStatus(char* jobid)
{
char * name=NULL;
	enum StepState step_state;
	int rc;
	int  obj_count,err_code;
	LL_element * job=NULL,*data=NULL,*step=NULL;
	char **host_list;
	
	
	job = ll_query(JOBS);
	if (!job) {
      		printf("Query JOBS: ll_query() returns NULL.\n"); exit(1);
  	}
	
	host_list = (char **)malloc(2*sizeof(char *));
	host_list[0] = jobid;
	host_list[1] = NULL;

	rc = ll_set_request(job,QUERY_JOBID,host_list,ALL_DATA);
	if (rc) {
      		printf("Query JOBS: ll_set_request() return code is non-zero.\n"); exit(1);
  	}
	

	data = ll_get_objs(job, LL_SCHEDD, NULL, &obj_count, &err_code);
  	if (data == NULL) {
      		printf("Query JOBS: ll_get_objs() returns NULL. Error code = %d\n", err_code);
   	}
	//printf("Number of jobs objects returned = %d\n", obj_count);

	name=(char*)malloc(256*sizeof(char *));

      ll_get_data(data, LL_JobGetFirstStep, &step);
    

	while(data) {

     		rc = ll_get_data(data, LL_JobName,&name);

      		if (!rc) {
         		printf("Job name: %s\n",name);
			free(name);
      		}
		//free(step_state);
      		rc = ll_get_data(step, LL_StepState,&step_state);
      		if (rc) {
         		printf("Query MACHINES: ll_get_data() return code is non-zero.\n"); 
			exit(1);
      		}
		
		if(!rc) {
    			printf("State: %d\n",step_state);
			
		}		

      		data = ll_next_obj(job);
   	}

	ll_free_objs(job);
    	ll_deallocate(job);

}

void changeStatus(char *jobid,char *state)
{
	int st = atoi(state);
	
	int rt;
	char **job_list;
			job_list = (char **)malloc(2*sizeof(char*));
			job_list[0] = jobid;
			job_list[1] = NULL;
			
	LL_element *errObj;
	LL_preempt_param  *param_struct;		
	
	LL_terminate_job_info *cancel_info;
	char *rest; 
    char *token; 
    char *ptr = jobid;	
	int n,i;
	switch(st)
	{
		case 0:			
			param_struct->type=PREEMPT_STEP;
			param_struct->method=LL_PREEMPT_SUSPEND; //?
			param_struct->user_list=NULL;
			param_struct->host_list=NULL;
			param_struct->job_list=job_list;
			printf("DRMAA_CONTROL_SUSPEND\n");
			rt = ll_preempt_jobs(LL_API_VERSION,errObj,&param_struct);
			printf("ll_preempt_jobs - PREEMPT_STEP returned: %d\n",rt);
			break;

		case 1:
			param_struct->type=RESUME_STEP;
			param_struct->method=LL_PREEMPT_SUSPEND; //?
			param_struct->user_list=NULL;
			param_struct->host_list=NULL;
			param_struct->job_list=job_list;
			printf("DRMAA_CONTROL_RESUME\n");
			rt = ll_preempt_jobs(LL_API_VERSION,errObj,&param_struct);
			printf("ll_preempt_jobs - RESUME_STEP returned: %d\n",rt);
			break;

		case 2:
			printf("DRMAA_CONTROL_HOLD\n");
			rt = ll_control(LL_CONTROL_VERSION, LL_CONTROL_HOLD_USER, NULL,NULL,job_list,NULL,0);
			printf("LL_control - LL_CONTROL_HOLD_USER returned: %d, jobid %s\n",rt,jobid);
			break;

		case 3:
			printf("DRMAA_CONTROL_RELEASE\n");
			rt = ll_control(LL_CONTROL_VERSION, LL_CONTROL_HOLD_RELEASE, NULL,NULL,job_list,NULL,0);
			printf("LL_control - LL_CONTROL_HOLD_RELEASE returned: %d, jobid %s\n",rt,jobid);
			break;

		case 4:
			cancel_info = (LL_terminate_job_info *)malloc(sizeof(LL_terminate_job_info));
			if (!cancel_info) {
				fprintf(stderr, "Out of memory.\n");
				exit(1);
			}
			
			cancel_info->version_num=LL_PROC_VERSION;
			
			/*cancel_info->StepId.from_host="l4f1n03";
			cancel_info->StepId.cluster=16651;
			cancel_info->StepId.proc = 0;*/
			token = strtok_r(ptr, ".", &rest);
			cancel_info->StepId.from_host =  strdup(token);
			ptr = rest; 
			token = strtok_r(ptr, ".", &rest);
   			ptr = rest; 
			
				cancel_info->StepId.cluster = atoi(token);
			token = strtok_r(ptr, ".", &rest);
	/*  			  ptr = rest; 		*/
			if(token!=NULL)
			{
				cancel_info->StepId.proc = atoi(token);
			}
			else
			{
				enum StepState step_state;
				int rc;
				int  obj_count,err_code;
				LL_element * job=NULL,*data=NULL,*step=NULL;
				char **host_list;
				char * temp = (char *)malloc(30*sizeof(char *));
				printf("tu3\n");
				job = ll_query(JOBS);
				if (!job) {
     		 		printf("Query JOBS: ll_query() returns NULL.\n"); exit(1);
  				}	
				
				sprintf(temp,"%s.%d",cancel_info->StepId.from_host,cancel_info->StepId.cluster);
				printf("tu2\n");	
				host_list = (char **)malloc(2*sizeof(char *));
				host_list[0] = temp;
				host_list[1] = NULL;
				
				
				rc = ll_set_request(job,QUERY_JOBID,host_list,ALL_DATA);
				if (rc) {
  		    		printf("Query JOBS: ll_set_request() return code is non-zero.\n"); exit(1);
  				}
				
				data = ll_get_objs(job, LL_SCHEDD, NULL, &obj_count, &err_code);
  				if (data == NULL) {
  			    		printf("Query JOBS: ll_get_objs() returns NULL. Error code = %d\n", err_code);
  			 	}
				printf("obj_c %d\n",obj_count);
				  ll_get_data(data, LL_JobGetFirstStep, &step);  
			
				rc = ll_get_data(data, LL_JobStepCount, &n);
				printf("Job count: %d\n",n);
			
			
				
			
				}
			/**/
					
			printf("Cancel Job Step %s.%d.%d \n\n",
	        cancel_info->StepId.from_host,
	        cancel_info->StepId.cluster,
	        cancel_info->StepId.proc);
			
			cancel_info->msg=NULL;
			printf("DRMAA_CONTROL_TERMINATE\n");
			for(i = 0; i<n;i++)
			{
				cancel_info->StepId.proc = i;
				rt = ll_terminate_job(cancel_info);
			}
			printf("LL_terminate_job returned: %d\n",rt);
			
			free(cancel_info->StepId.from_host);
			free(cancel_info);
			
			break;

		default:
			printf("Wrong state value\n");
			break;

	}
	sleep(1);
}

int main(int argc, char *argv[])
{
	if(argc<3)
	{
		printf("./a <job_id> <change_to_state>\n");
		exit(1);
	}

	getStatus(argv[1]);
	printf("\n");
	changeStatus(argv[1],argv[2]);
	printf("\n");
	getStatus(argv[1]);
	return 0;
}