/Users/paul/Documents/phlogo/core/RestProcessor.cpp

/*
 *  RestProcessor.cpp
 *
 *  Author: Paul Hamilton
 *      Date: 8 Aug 2011
 *
 */
#include "RestProcessor.h"
        
#include "RestOutput.h"

#include <boost/regex.hpp>

using namespace std;

namespace phlogo {

boost::shared_ptr<RestProcessor> RestProcessor::instance;
    
RestProcessor *RestProcessor::getInstance() {
    if (!instance.get())
        instance.reset(new RestProcessor());
    return instance.get();
}

bool RestProcessor::process(const string &path, RestOutput *output) {
    
    boost::smatch what;
    if (!boost::regex_match(path, what, boost::regex("^/(.*)/\\?(.*)$")))
        return false;
    
    if (what.size() < 2)
        return false;
    
    string restpath = what[1];
    string args = what[2];

    if (restpath == "logo") {
        if (boost::regex_match(args, what, boost::regex("^cmd=(.*)$"))) {
            startOutput();
            _t.startGData();
            
            // process the args against out internal interpreter and world.
            _itp.run(&_w, what[1]);
            
            // get the output.
            output->output(endOutput(_t.endGData()));
        }
        else
            return false;
    }
    else if (restpath == "defun") {
        if (boost::regex_match(args, what, boost::regex("^name=(.*)$"))) {
            _itp.defun(what[1], "");
            startOutput();
            outputLine("defining function " + what[1]);
            output->output(endOutput("[]"));
        }
    }
    else if (restpath == "end") {
        _itp.end();
        startOutput();
        outputLine("function defined");
        output->output(endOutput("[]"));
    }
    else
        return false;
    return true;
}

void RestProcessor::startOutput() {
    _ss.str("");
    _ss << "[[";
    _error = false;
    _firstop = true;
}

string RestProcessor::endOutput(const string &gdata) {
    _ss << "]," << gdata << "]";
    return _ss.str();
}

void RestProcessor::reset() {
    if (_firstop)
        _firstop = false;
    else     
        _ss << ",";
    _ss << "{c:0}";
}
    
void RestProcessor::outputLine(const string &s) {
    if (_firstop)
        _firstop = false;
    else     
        _ss << ",";
    _ss << "{o:['" << s << "']}";
}
    
void RestProcessor::outputError(const string &s) {
    if (_firstop)
        _firstop = false;
    else     
        _ss << ",";
   _ss << "{e:['" << s << "']}";
    _error = true;
}
    
bool RestProcessor::isError() {
    return _error;
}

std::string RestProcessor::getString() {
    return _ss.str();
}

}