/* ******************* Structs ************************ */

// Gets config info from confs

struct distrend_config

{

  cfg_t *mycfg;

  struct options_common *options;

  struct distrend_listen **listens; /*< Null terminated array of structs */

  char *datadir;

};

struct general_info {

  short int jobs_in_queue; //

  unsigned short int free_clients;

  unsigned short int rendering_clients;//

  unsigned short int total_finished_jobs; //

  unsigned int total_frames_rendered; //

  unsigned int highest_jobnum;

} general_info;

/*

  }

  else{

    general_info.total_finished_jobs = 0;

    general_info.total_frames_rendered = 0;

    fprintf(stderr,"Can't find XML dump, starting up fresh.\n");

    return 2;

  }

  free(&buffer); // @TODO: Is this pointless?

}

/** Finish-Setter: Sets a frame to the "completed" status.*/

void finish_frame(struct distrenjob *head, struct distrenjob *distrenjob, int frame){

  distrenjob->frameset[frame].time_to_render = (clock() - distrenjob[jobnum].frameset[frame].start_time); // Consider changing time-to-render to time-for-frame or something?

  /* TODO: calculating the average render time like this may have a small amount of error, because the number is truncated to an integer of seconds every time... does it matter? */

  /* we could keep track of the total render time... would make calculation a lot easier and more accurate */

  distrenjob->avg_render_time = ((distrenjob->avg_render_time*(distrenjob->completed_frames)) + distrenjob->frameset[frame].time_to_render)/(distrenjob->completed_frames + 1);

  distrenjob->completed_frames++;

  distrenjob->assigned_frames--;

  general_info.total_frames_rendered++; // Increase total frames var for stats

  if(distrenjob->completed_frames == distrenjob->total_frames)

    {

      mortition(head, distrenjob);

    }

void mortition(struct distrenjob *head, struct distrenjob *job){

  short int isJobDone;

  int counter;

  char path_and_number[20];

  struct stat buffer;

  isJobDone = 1; // set isJobDone to true

  for(counter = 0; counter < job->total_frames; counter++)

    {

      sprintf(path_and_number, "stor/job%d/out/%d.%s", job->jobnum, (counter + job->frameset[0].num), job->output_format);

      if(stat(path_and_number, &buffer) != -1)

        {

          job->completed_frames--;

          isJobDone = 0; // if a missing frame is found, set isJobDone to false

        }

    }

  if(isJobDone)

    {

      distrenjob_remove(&head, job);

      general_info.jobs_in_queue--;

    }

}

  /* @TODO: should the aove be malloc(sizeof(struct frameset) * distrenjob->total_frames? */

  /*

  distrenjob->frameset = malloc(sizeof(struct frameset) * numframes);

  if(!job->frameset)

    fprintf(stderr, "Error allocating memory\n");

  */

  /* prepares all the frames by setting that status to "unassigned" */

  counter2 = start_frame;

  for(counter = 0; counter <= (end_frame- start_frame + 1); counter++){

    distrenjob->frameset[counter].num = counter2;

    counter2++;

  }

  distrenjob_enqueue(head, distrenjob);

  general_info.jobs_in_queue++;

}

/* distrenjob_enqueue: This function adds the job to the queue based on its priority */

void distrenjob_enqueue(struct distrenjob *head, struct distrenjob *job) {

  } /* for(current_job) */

}

/**

   @arg head I may end up changing the head if job == head

 */

void change_job_priority(struct distrenjob *head, struct distrenjob *job, int new_priority){

  distrenjob_remove(&head, job);

  job->priority = new_priority;

  struct distrenjob *current_job;

  struct distrenjob *prev_job = head;

    distrenjob_enqueue(head, job);

  else{ // if job has already been started then place it before the jobs with the same priority

    // iterate through linked list of jobs

    for(current_job = head; current_job != NULL; current_job = current_job->next){

      if(current_job == NULL){ // if it has reached the end of the list, add job there

        current_job = job;

        break;

      }

      else if(job->priority <= current_job->priority){ // if job's priority is less than or equal to current_job's priority, insert job

        prev_job->next = job;                        // keep in mind 1 is the highest priority given to jobs, head has a

        job->next = current_job;                     // priority of zero so it will always be before other jobs

        break;

      }

  }

}

/**

  Frame Finder: matches your computer up with a lovely frame to render

  TODO: Major issue here, the client needs to know the frame number, AND the job number!

  Notice that this function starts by looking at the oldest job first

	TODO: Link this up with the main() function to check if there are frames available or not and provide jobnum/framenum to the client

  @return 0 success, other: error

*/

{

  short int your_job_type;

  unsigned short int found;

  struct distrenjob *distrenjob_ptr;

  your_job_type = 0;

  found = 0;

  /* iterate through jobs from first to last */

  for(distrenjob_ptr = head->next; !found && !distrenjob_ptr; distrenjob_ptr = distrenjob_ptr->next)

    {

    }

  return 0;

}

/** Checks for dead, laggy, or stale slaves */

void blend_frame_watchdog(struct distrenjob *distrenjob_head)

{

  unsigned short int watchdog_forgiveness; /*< seconds to wait on a frame before re-assigning it */

  struct distrenjob *distrenjob_ptr;

  unsigned int counter;

  watchdog_forgiveness = 1; /*< hours of forgiveness before frame is re-assigned @TODO: Make this more user-configurable (maybe per-job), 3 hours is a LONG time */

  for(distrenjob_ptr = distrenjob_head; distrenjob_ptr; distrenjob_ptr = distrenjob_ptr->next)

    /* iterate through jobs */

    for(counter = 0; counter < distrenjob_ptr->total_frames; counter ++)

      /* iterate through all frames for this job*/

      {

        if((distrenjob_ptr->frameset[counter].start_time + (watchdog_forgiveness * 3600)) < clock())

          /*

            If frame is not completed within the number of hours specified by watchdog_forgiveness

            Then change the frame status to unassigned

           */

      }

}

/**

   Finds a distrenjob struct based on the jobnum

   @arg jobnum job number to search for

   @return NULL on job doesn't exist

 */

struct distrenjob *distrenjob_get(struct distrenjob *head, jobnum_t jobnum)

{

  struct distrenjob *distrenjob_ptr;

      cont = distrend_do(action);

      /* Make the following code more event-driven */

      blend_frame_watchdog(&head);

      struct frameset *frame;

      struct distrenjob *job;

      /* If the client is idle, must be modified for climbing through linked list of clients (client->clientnum) */

      if(clientstatus == CLIENTSTATUS_IDLE)

	{

	  if(returnnum)

	    {

	      fprintf(stderr,"No frames are available to render at this time. Idling...\n");

	      sleep(10);

	    }

	  else

	    /* returnnum == 0 */

	    remotio_send_to_client(frame->num, job->jobnum); // Pseudo-sends data to client

	}

      /* If the client states that they finished the frame */

      	if(clientsays == DISTREN_REQUEST_DONEFRAME){

  int watchdog_forgiveness; // how many hours till the frame is re-assigned (if client computer crashes etc);

  time_t avg_render_time; // average seconds it took to render a frame

  time_t time_remaining; /*< estimated seconds remaining till render is complete (up to 49, 710 days) */

  char *output_format; /*< currently is the file extention of the request output format. @todo make this mime-type based/not a string */

  struct frameset *frameset;

};

/**

   Frameset Structure

*/

struct frameset {

  int num; /*< frame number to render */

  char slave_name; /*< user that frame is assigned to */

  clock_t start_time; /*< time the frame was started */

  int time_to_render; /*< the total seconds it took to render the frame */

}; /* Frameset array is generated by status_report_generator() */

/*

related functions

*/

/**

   @param distrenjob the address where we will store the pointer of a malloc()ed