*/

#include <stdio.h>

#include "execio.h"

// needs to be implemented

#include "options.h"

#include <confuse.h>

#define max 100

// maximum number of stored jobs in memory, per job type (lux/blend). Eventually we can dump this data to disk, or atleast the remainder not in memory...

int jobnum = 0;

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

// Structures for storing job information

// OOOOOOkay so we really need a struct for frameset rather than just an array, because we should track who each frame was sent out to. Please do this, someone! :D

struct {

  char *name;

  char *submitter;

  char *email;

  int priority;  // 1 is lowest, 10 is highest, 0 is done

  int percent_done;

  int completed_frames; // number of completed frames

  int assigned_frames; // number of assigned frames (that are not yet completed)

  int total_frames; // how many frames are in the animation

  struct frameset **frameset; // What exactly is this now? hehe

  // For secondary upload location...

  char url;

  char login_name;

  char login_pass;

} blendjob[max];

// -- Matthew's handywork --

// struct for storing informaiton on each frame for a particular blender job

struct {

	int frame_num; // frame number to render

	char slave_name; // user that frame is assigned to

	int frame_status; // status of frame, 0= unassigned, 1= taken, 2= done

                         // Using this method to save memory, because if animation starts on a high frame number, it would waste a lot of RAM on empty structures

// -- end of Matthew's handywork --

struct {

  char *name;

  char *submitter;

  char *email;

  int priority;

  int mode; // 0 = Static Render, stop at Spp, or infinity if spp is null. Framerange is ignored || 1 = animation, stop at Spp and stay in framerange.

  int spp;

  struct frameset ** frameset;

} luxjob[max];

int main(int argc, char *argv[])

{

// I'm assuming this is a non-working framework :)

	int distrend_do_config(int argc, char *argv[], struct distrend_config *config)

	{

	  cfg_opt_t myopts =

	    {

	      CFG_SEC("listen",  /* this must be imported into struct listens (which must still be declared) */

	    {

	      CFG_SIMPLE_STR("type", NULL),

		CFG_SIMPLE_STR("path", NULL),

		CFG_SIMPLE_INT("port", NULL)

		},

		      CFGF_MULTI),

	      CFG_END

	    };

	  config = malloc(sizeof(struct distrend_config));

	  options_init(argc, argv, &config->mycfg, &myopts, "server", &config->options);

	  return 0;

	}

	int distrend_config_free(struct distrend_config *config)

	{

	  options_free(config->options);

	  free(config);

	  return 0;

	}

    fprintf(stderr, "read \"%s\"\n", buf);

    }

  execio_close(testrem);

}

/*

 frame[frame] Assignments:

  "0" - cancelled

  "1" - unassigned

  "2" - assigned to slave

  "3" - completed by slave and uploaded

 Have a script crawl through each job in the arrays, ordered by priority?, and assign a certain number of frames to each slave.

 Then we will need some sort of watchdog to monitor slaves on the main server to check for stales.

*/

/* This function creates frame array based on the total number of frames to be rendered, which will then be parsed by function frame_farmer. */

void frame_num_struct_builder(int sframe, int eframe) {

	int jobnum_new = highest_jobnum + 1;

	int total = (sframe - eframe) +1;  // total number of frames

	int fcount = sframe; // Used to create all the frames in the structure from sframe to eframe

	int x = 0;

	blendjob[jobnum_new].total_frames = total; // sets the total number of frames in animation for status purposes

	while(x < total){

		blendjob[jobnum_new].frameset[x].frame_num = fcount;

		x++;

		fcount++;

	}

	highest_jobnum++;

}

// matches your computer up with a lovely frame to render

int frame_finder(){

	int your_frame = NULL;  // your_frame is an interger value that will be given to the client as the frame number to render

	int finder_jobnum = 0;

	int frameset_count = 0; // the frameset number, note* frames in an animation don't start at zero

	short int done = 0;

		finder_jobnum = hcfjob + 1; // reset it to start scanning at first uncompleted job for the pass at each priority level

		while(finder_jobnum <= highest_jobnum){

			if(blendjob[finder_jobnum].priority = priority){  // looks for a job with the current priority value

				done = 1;									  // notice it starts by looking at the oldest job first

				break;

			}

			if(done = 1)  // If it has found a job with the current priority value, it will break out of the loop

				break;    // If none is found it goes to the next job to see if it is of the current priority value

			else

				finder_jobnum++;

		}

		if(done = 1) // if job has been found, it lets it out of the priority changer loop

			break;

	}

	while(your_frame < blendjob[finder_jobnum].total_frames){ // Finds the frameset number with a frame that needs to be rendered

		if (blendjob[finder_jobnum].frameset[frameset_count].frame_status = 0)  // If frame that is not assigned has been found, frameset_count is not changed

			break;																// and frameset_count is used to give the frame number later in this funciton

		x++;  // If frame is assigned or done, it goes to next frame

	}

blendjob[jobnum].frameset[x].frame_status++; // sets the value of the frame to 2, which means its taken

your_frame = blendjob[jobnum].frameset[x].frame_num; //  Takes the frameset found in the while statement above, and extracts the frame number from it and assigns it to the int your_frame

if(your_frame = null)  // If that job had no open frames for some reason, run the status report generator so that

	status_report_generator();  //the job priority can be changed to 0

return your_frame; // your_frame is returned as the frame to be rendered

}

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

// This uses pointers, so when it is run it updates certain values in memory

void status_report_generator(){

	while(blendjob[(hcfjob+1)].priority = 0)  //If the job after the highest consecutively finished job is finished

		hcfjob+1;  // adds 1 to the highest consecutively finished job and checks the next one, till the job after the hcfjob is not done

	int num1 = hcfjob+1; // to scan through jobs

	int num2 = 0;		 // to scan through frames

	while(num1 <= highest_jobnum){

			if(blendjob[num1].frameset[num2].priority != 0){ // If the job is not done, scan it