#include "rotord.h"

RenderContextHandler::RenderContextHandler(const std::string _content,const HTTPServerResponse::HTTPStatus _status){
	content=_content;
	status=_status;
}


void RenderContextHandler::handleRequest(HTTPServerRequest& request,HTTPServerResponse& response) {

    response.setChunkedTransferEncoding(true);
    response.setContentType("text/html");
	response.setStatus(status);

    std::ostream& ostr = response.send();

	ostr << "<?xml version='1.0' encoding='ISO-8859-1'?>\n";
	ostr << content;

}


HTTPRequestHandler* RotorRequestHandlerFactory::createRequestHandler(const HTTPServerRequest& request){
	
	Logger& logger = Logger::get("Rotor");

	Poco::URI theuri=Poco::URI(request.getURI());
	std::vector <std::string> command;
	theuri.getPathSegments(command);

	logger.information(request.clientAddress().toString()+" "+request.getMethod());

	HTTPResponse::HTTPStatus status=HTTPResponse::HTTP_BAD_REQUEST; //by default
	
	std::string body;
	std::ostringstream os;
	os<<request.stream().rdbuf();
	body=os.str();

	xmlIO XML; //xml object handles the servers responses
	XML.addTag("rotor");

	//can we create a tinyxml object here and pass a pointer to it to the render context?
	//can tinyxml output to a string? is there any reason to use poco instead?

	if (command.size()) {
		if (command[0]=="new") {
			XML.pushTag("rotor");
			if (request.getMethod()=="GET") {
				string sID=idGen.createOne().toString();    	//create() seems to cause problems
													//Creates a new time-based UUID, using the MAC address of one of the system's ethernet adapters.
													//Throws a SystemException if no MAC address can be obtained.
													//
													//seems to hang, to me
				logger.information("Rotor: starting thread "+sID);
				manager.start(new Rotor::Render_context(sID));
				//XML.addTag("sID");
				XML.addValue("sID",sID);
				status=HTTPResponse::HTTP_OK;
			}
			if (request.getMethod()=="PUT") {		//unofficial manual thread name
				if (body.size()) {
					string sID=body;
					cerr << "Rotor: starting thread "<< sID << endl;
					manager.start(new Rotor::Render_context(sID));
					XML.addValue("sID",sID);
					status=HTTPResponse::HTTP_OK;
				}
			}
		}
		else if (command[0]=="list") {
			XML.pushTag("rotor");
			if (request.getMethod()=="GET") {
												//std::list < Poco::AutoPtr < Poco::Task > >::iterator it;
												//it=manager.taskList().begin();
												//for (it=manager.taskList().begin();it !=manager.taskList().end();++it) {
													//content+="<sID>"+(*it)->name()+"</sID>\n";
												//}

												//massive problems making an iterator for the tasklist, the above crashes
												//solution: auto type range-based for-loop
												//this is c++11 specific but works

				for (auto& task: manager.taskList()) { //c++11
					 XML.addValue("sID",task->name());
				}
				status=HTTPResponse::HTTP_OK;
			}
		}
		else if (command[0]=="exit") {
			exit(0);
		}
		else {
			bool found=false;
			for (auto& task: manager.taskList()) { //c++11
				 if(task->name()==command[0]) {
					//valid session command
					found=true;
					XML.addAttribute("rotor","context",task->name(),0);
					XML.pushTag("rotor");
					if (command.size()==1) {
						//just invoking sID
						if (request.getMethod()=="DELETE") {
							task->cancel();
							status=HTTPResponse::HTTP_OK;
							XML.addValue("status","context deleted successfully");
						}
						else {
							XML.addValue("error","Render context invoked with no command");
					   	}
				    }
				    else {                                                  		//session modifier command- to be passed to render context
													    //some commands need to return error codes
													    //ie where the audio file isn't found
													    //on the other hand, some commands need to know state of the renderer?
					

					vector<string> sc;                                  //method,id,command1,{command2,}{body}
					sc.push_back(request.getMethod());
					for (auto& i: command){
					    sc.push_back(i);
					}
					sc.push_back(body);
					
					((Poco::AutoPtr<Rotor::Render_context>)task)->session_command(sc,XML,status);
					
				    }
				 }
			}
			if (!found) {
				status=HTTPResponse::HTTP_NOT_FOUND;
				XML.pushTag("rotor");
				XML.addValue("error","Render context not found");
			}
		}
	}
	else {
		XML.addValue("error","Emoty request");
	}
	string content;
	XML.copyXmlToString(content);
	return new RenderContextHandler(content, status);
}


RotorServer::RotorServer(): _helpRequested(false)
{
}

RotorServer::~RotorServer()
{
}

void RotorServer::initialize(Application& self){
	loadConfiguration();
	ServerApplication::initialize(self);
}

void RotorServer::uninitialize(){
	ServerApplication::uninitialize();
}

void RotorServer::defineOptions(OptionSet& options) {
	ServerApplication::defineOptions(options);
	options.addOption(
		Option("help", "h", "display argument help information")
		    .required(false)
		    .repeatable(false)
		    .callback(OptionCallback<RotorServer>(this, &RotorServer::handleHelp)
		)
	);
}

void RotorServer::handleHelp(const std::string& name, const std::string& value){
	HelpFormatter helpFormatter(options());
	helpFormatter.setCommand(commandName());
	helpFormatter.setUsage("OPTIONS");
	helpFormatter.setHeader(
	    "Rotor");
	helpFormatter.format(std::cout);
	stopOptionsProcessing();
	_helpRequested = true;
}

int RotorServer::main(const std::vector<std::string>& args){
	if (!_helpRequested) {

		unsigned short port;

		xmlIO xml;
		if(xml.loadFile("settings.xml") ){
			port=xml.getAttribute("Rotor","port",9000,0);
		}
		else cerr<<"Rotord: settings.xml not found, using defaults"<<endl;

		port = (unsigned short) config().getInt("port", port); //override from command line

		std::string format(config().getString("format", DateTimeFormat::SORTABLE_FORMAT));



		ServerSocket svs(port);
		HTTPServer srv(new RotorRequestHandlerFactory(),svs, new HTTPServerParams);
		srv.start();
		waitForTerminationRequest();
		srv.stop();
	}
	return Application::EXIT_OK;
}