* ++ Make data availible for other apps to parse

 * Server<==>Client Communication

 * Upload while rendering

 */

/* XML notes --

 *

 * First off, is XML in our build environment?

 * Next, what files are we going to have?:

 *  - XML file sent with (.blend/.pov/.lux(xml)/whatever) by distren telling the server what to do

 *  	+ Includes submitter name, filename, emailaddress, etc

 *  - XML file on server storing info on current and finished jobs

 *  - XML file sent by distren when submitting a render to the server

 *

 *  Overall, we could use XML to make our client/server communication load

 *  a lot lighter, especially if clients are sent customized xml files telling

 *  them what frame(s) to render... although that would be inefficient if rendering

 *  single frames. Maybe not tell it what frames to render in the xml file, the server

 *  can spit out that info.

 *

 *  Please edit my ramblings if you please,

 *  --ethanzonca

 *

 */

#include "execio.h"

#include "options.h"

#include "blendjob.h"

#include "protocol.h"

#include <confuse.h>

#include <stdio.h>

#include <stdlib.h>

#include <malloc.h>

#include <unistd.h> /* getopt */

#include <time.h>

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

// Stores config info? editmycomment

struct distrend_config

{

  cfg_t *mycfg;

  struct options_common *options;

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

};

/*

 frame[frame] Status Assignments:

  "NULL" - don't render me

  "0" - canceled

  "1" - unassigned

  "2" - assigned to slave

  "3" - completed by slave and uploaded

 Have a script crawl through each job in the arrays, priority-biased, and assign a frame to each slave.

 Then we will need some sort of watchdog to monitor slaves on the main server to check for stales. Maybe not worry about this for now.

*/

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; //

} general_info;

/*

  internally defined funcs's prototypes

*/

void status_report_generator(struct blendjob **blendjobs_head);

void blendjob_remove(struct blendjob **head, struct blendjob *bj);

struct blendjob *blendjob_get(struct blendjob *head, jobnum_t jobnum);

/* Global Vars, try to cut down on these */

jobnum_t jobnum = 0; // The next job number to create in the queue

int hcfjob; // Highest consecutively finished job

int highest_jobnum; // The job number of the most recently created job, this is used when creating new jobs

/* ********************** Functions ************************* */

/* Functions to stubify */

int distrend_do(){

}

void distrend_accept(){

}

void distrend_action_free(){

}

void distrend_listen(){

}

void distrend_unlisten(){

}

void remotio_send_to_client(){

	// I am futile!

}

void start_data(){

	if(1 == 0){

		// retrieve total_finished_jobs and total_finished_frames from xml file

	}

	else{

		general_info.total_finished_jobs = 0;

		general_info.total_frames_rendered = 0;

	}

}

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

void finish_frame(struct blendjob *blendjob, int frame){

  blendjob->frameset[frame].status = 2;

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

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

}

// **** Queuer: Adds files to the queue

void queue(struct blendjob *blendjob, int type, char *name, char *submitter, char *email, int priority, int mode, int spp, struct frameset *frameset) {

	// Type: 1 = blender, add more types later

	// jobnum is the next available job number

	if(type == 1){

    blendjob->name = name;

    blendjob->submitter = submitter;

    blendjob->email = email;

    blendjob->priority = priority;

    blendjob->frameset = frameset;

  }

  else{

    // Throw error.

  }

jobnum++; // Advance the jobnumber for the next queued job

}

/**

  Status Report Generator:

  -figures out how much of the job is done, where jobnum corresponds to the job number

  -removes finished jobs

  @param blendjobs_head a pointer to a pointer because the head of the blendjobs linked list may need to be changed by blendjob_remove

*/

void status_report_generator(struct blendjob **blendjobs_head)

{

  struct blendjob *blendjob_ptr;

  unsigned short workers_working; /*< used to count the total number of workers working */

  unsigned int numjobs; /*< used to track number of jobs */

  blendjob_ptr = *blendjobs_head;

  workers_working = 0;

  numjobs = 0;

  while(blendjob_ptr)

    {

      if(blendjob_ptr->priority != 0)

	/* If the job is not done, scan it */

	{

	  unsigned int framecounter;  /*< to scan through frames */

	  unsigned long finished_frames; /*< variable that counts the completed frames */

	  unsigned int pending_frames; /*< variable that counts the assigned frames */

	  float percent_frames_finished;  /*< variable that stores the percent done of the blendjob */

	  unsigned int total_time;  /*< total time taken to render all the completed frames for a job */

	  framecounter = 0;

	  finished_frames = 0;

	  pending_frames = 0;

	  percent_frames_finished = 0;

	  total_time = 0;

	  while(framecounter < blendjob_ptr->total_frames)

	    /* scans through frames, based on their status it runs a statement(s) */

	    {

	      if(blendjob_ptr->frameset[framecounter].status == 2)

		/* If the frame is done */

		{

		  finished_frames ++;

		  total_time += blendjob_ptr->frameset[framecounter].time_to_render;

		}

	      if(blendjob_ptr->frameset[framecounter].status == 1)

		/* If the frame is assigned */

		{

		  pending_frames ++;

		  workers_working ++;

		}

	      framecounter ++;

	    } /* while(framecounter < blendjob_ptr->total_frames) */

	  // find the percent of completed frames

	  percent_frames_finished = (finished_frames / blendjob_ptr->total_frames) * 100; /*< @LordofWar: extraneous parentheses! */

	  /* updates values in the blendjob struct */