/*
  Copyright 2008 Nathan Phillip Brink, Ethan Zonca

  This file is a part of DistRen.

  DistRen is free software: you can redistribute it and/or modify
  it under the terms of the GNU Affero General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.

  DistRen is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU Affero General Public License for more details.

  You should have received a copy of the GNU Affero General Public License
  along with DistRen.  If not, see <http://www.gnu.org/licenses/>.

*/

/* This file contains the code which both processes (renders) jobs as a slave, and the code which distributes frames to slaves after receiving them from the client portion of the codebase. */

 /* Just some notes -- Ethan Zonca
 * ++ Make data availible for other apps to parse
 * Server<==>Client Communication
 * Upload while rendering
 */

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

// 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;
  struct frameset **frameset; // What exactly is this now? hehe
} blendjob[max];

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[])
{

/* !!!!!!! Important notes !!!!!!!!!!!!

So, we need a common key. Maybe. Or we need to generate a key in registeruser() and get it to the client somehow.
If we use a common key, then we'll need different passphrases for each user, which would be kinda crazy. How can
we get a key generated on the server, and transferred to the client's distrend?

*/


// We need the conf parser code from options.c here!!!
char *username = "unregistered"; // get this from conf



// Checks if the conf is left at the default username
int registered;
 error: People, this is not C++
if(username == "unregistered") {
  fprintf(stderr,"\nYou have not set your username in distrend.conf!\nIf you need to register a username, run distrend -c username email@example.com\n\n");
  registered = 0;
}
else{
  fprintf(stderr,"Logging into the DistRen server...\n");
}




// Registration on server. Needs attention. (e.g., people could make tons of accounts with the key we give them...
// Set up distrend -c username email@example.com
// We must prevent multi-user-creation abuse, too.
void registeruser(char *username, char *email){
  // Logs into sandboxed user on zserver2 and registers a user. Should eventually generate a key on the server and return it to the user.
  // All created user accounts should be sandboxed accordingly, requiring a different skel, and the default shell to be rbash. They also
  // need a custom path, which can be defined in the .bash_profile of the skel. All activity of server-side configuration should be documented
  // to ease the creation of new distren servers, or it should be automated and made much more all-inclusive, not requiring much config.
  char buf[10];
  struct execio *testrem;
  char *execargv[] =
    {
  "ssh",
  "distren_setup@protofusion.org",
  "-i",
  "setup.rsa", // We gotta figure out how we're going to do the whole keys thing... maybe grab this key via http? But have a secret password compiled in distren to prevent fraud?
  "-p",
  "23",
  "sudo /usr/sbin/useradd",
  "-M",
  "-c",
  email,
  "-d",
  "/home/distren",
  "--gid",
  "541",
  username,
  (char *)NULL
  };
  size_t readlen;
  fprintf(stderr, "Opening stream:\n", execio_open(&testrem, "ssh", execargv));
  buf[9] = '\0'; // null-terminating the array...
  while(!execio_read(testrem, buf, 9, &readlen)) // What's with the readlen stuff?
    {
      if(readlen > 9) {
	fprintf(stderr, "!!!! Something is terribly wrong!\n");
      }
      if(buf == 0) {
	fprintf(stderr, "**** Operation successful, or so we hope. We got no output. Just kidding. You will never see this. Something else should catch this though! And registration should really have some sort of password.");
      }
    buf[readlen] = '\0'; // Null-terminating the end of it again based on how large the data is?
    fprintf(stderr, "read \"%s\"\n", buf);
    }
  execio_close(testrem);
}





void loginuser(char *username, int secret){
  // Logs into sandboxed user on zserver2 and registers a user
  char buf[10];
  struct execio *testrem;
  char *execargv[] =
    {
  "ssh",
  "distren_setup@protofusion.org",
  "-i",
  "setup.rsa", // We gotta figure out how we're going to do the whole keys thing... maybe grab this key via http? But have a secret password compiled in distren to prevent fraud?
  "-p",
  "23",
  "sudo /usr/sbin/useradd",
  "-M",
  "-c",
  email,
  "-d",
  "/home/distren",
  "--gid",
  "541",
  username,
  (char *)NULL
  };
  size_t readlen;
  fprintf(stderr, "Opening stream:\n", execio_open(&testrem, "ssh", execargv));
  buf[9] = '\0'; // null-terminating the array...
  while(!execio_read(testrem, buf, 9, &readlen)) // What's with the readlen stuff?
    {
      if(readlen > 9) {
	fprintf(stderr, "!!!! Something is terribly wrong!\n");
      }
      if(buf == 0) {
	fprintf(stderr, "**** Operation successful, or so we hope. We got no output. Just kidding. You will never see this. Something else should catch this though!");
      }
    buf[readlen] = '\0'; // Null-terminating the end of it again based on how large the data is?
    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_array_builder(int sframe, int eframe) {
	int total = eframe + 1;
	int x = sframe;
	blendjob[jobnum].frameset[total];

	while(x <= eframe){
		blendjob[jobnum].frameset[x]=0;
		x++;
	}
}

// matches your computer up with a lovely frame to render
int frame_finder(){
	int your_frame = 0;  // your_frame is an interger value that will be given to the client as the frame number to render

	while(your_frame < eframe){ // this finds a frame with the value of zero, which is a frame that is ready to be rendered
		if (blendjob[jobnum].frameset[your_frame] = 0)
			break;

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

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

// This function makes the value of the frame 2, which means its completed.
void the_finisher(int frame){
	blendjob[jobnum].frameset[frame]++;
}

// Queuer: this function should add files to the queue
// Type: 0 = blender, 1 = luxrender
// jobnum is the current job number

void queue(int type, char *name, char *submitter, char *email, int priority, int mode, int spp, *frameset) {
  if(type == 1){
    blendjob[jobnum].name = name;
    blendjob[jobnum].submitter = submitter;
    blendjob[jobnum].email = email;
    blendjob[jobnum].priority = priority;
    blendjob[jobnum].frameset =  frameset;
  }
  if(type == 2){
    luxjob[jobnum].name = name;
    luxjob[jobnum].submitter = submitter;
    luxjob[jobnum].email = email;
    luxjob[jobnum].priority = priority;
    luxjob[jobnum].mode = mode;
    luxjob[jobnum].spp = spp;
    luxjob[jobnum].frameset = frameset;
    // handle lux modes somehow.
}
  else{
    // Throw error.
  }
jobnum++;
}










/*
Slave execution code lies below


Slave listens on server for a command in the format of each function...
We need if's for returns... ==> watchdog
*/


// Executors

void exec_blender(char *input, char *output, int frame) {
  int ret;
  /* SEGFAULTAGE :-D */
  char *cmd[] = { "blender", "-b", "-o", output, input, "-f", frame, (char *)0 };
  ret = execv("/usr/bin/blender", cmd);

  // OHNOBINKI! ... check this... Its supposed to send a command back to the server and run the_finisher(); function which sets the frame status to complete.
  fprintf{stdin, the_finisher(frame)};

void exec_luxrender_single(char *input, char *output) {
  int ret;
  char *cmd[] = { "luxrender", "-something", "something", "something", (char *)0 };
  ret = execv("/usr/bin/luxrender", cmd);
}

void exec_luxrender_anim(char *input, char *output, int sframe, int eframe, int spp) {
// spp is samples per pixel limitation on each frame
  int ret;
  char *cmd[] = { "luxrender", "-something", "something", "something", (char *)0 };
  ret = execv ("/usr/bin/luxrender", cmd);
}



  return 0;
}