#include <node_http_parser.h>

#include <v8.h>
#include <node.h>
#include <node_buffer.h>

#include <http_parser.h>

#include <strings.h>  /* strcasecmp() */
#include <string.h>  /* strdup() */
#include <stdlib.h>  /* free() */

// This is a binding to http_parser (http://github.com/ry/http-parser)
// The goal is to decouple sockets from parsing for more javascript-level
// agility. A Buffer is read from a socket and passed to parser.execute().
// The parser then issues callbacks with slices of the data
//     parser.onMessageBegin
//     parser.onPath
//     parser.onBody
//     ...
// No copying is performed when slicing the buffer, only small reference
// allocations.


namespace node {

using namespace v8;

static Persistent<String> delete_sym;
static Persistent<String> get_sym;
static Persistent<String> head_sym;
static Persistent<String> post_sym;
static Persistent<String> put_sym;
static Persistent<String> connect_sym;
static Persistent<String> options_sym;
static Persistent<String> trace_sym;
static Persistent<String> copy_sym;
static Persistent<String> lock_sym;
static Persistent<String> mkcol_sym;
static Persistent<String> move_sym;
static Persistent<String> propfind_sym;
static Persistent<String> proppatch_sym;
static Persistent<String> unlock_sym;
static Persistent<String> report_sym;
static Persistent<String> mkactivity_sym;
static Persistent<String> checkout_sym;
static Persistent<String> merge_sym;
static Persistent<String> msearch_sym;
static Persistent<String> notify_sym;
static Persistent<String> subscribe_sym;
static Persistent<String> unsubscribe_sym;
static Persistent<String> unknown_method_sym;

static Persistent<String> method_sym;
static Persistent<String> status_code_sym;
static Persistent<String> http_version_sym;
static Persistent<String> version_major_sym;
static Persistent<String> version_minor_sym;
static Persistent<String> should_keep_alive_sym;
static Persistent<String> upgrade_sym;


static inline Persistent<String>
method_to_str(unsigned short m) {
  switch (m) {
    case HTTP_DELETE:     return delete_sym;
    case HTTP_GET:        return get_sym;
    case HTTP_HEAD:       return head_sym;
    case HTTP_POST:       return post_sym;
    case HTTP_PUT:        return put_sym;
    case HTTP_CONNECT:    return connect_sym;
    case HTTP_OPTIONS:    return options_sym;
    case HTTP_TRACE:      return trace_sym;
    case HTTP_COPY:       return copy_sym;
    case HTTP_LOCK:       return lock_sym;
    case HTTP_MKCOL:      return mkcol_sym;
    case HTTP_MOVE:       return move_sym;
    case HTTP_PROPFIND:   return propfind_sym;
    case HTTP_PROPPATCH:  return proppatch_sym;
    case HTTP_UNLOCK:     return unlock_sym;
    case HTTP_REPORT:     return report_sym;
    case HTTP_MKACTIVITY: return mkactivity_sym;
    case HTTP_CHECKOUT:   return checkout_sym;
    case HTTP_MERGE:      return merge_sym;
    case HTTP_MSEARCH:    return msearch_sym;
    case HTTP_NOTIFY:     return notify_sym;
    case HTTP_SUBSCRIBE:  return subscribe_sym;
    case HTTP_UNSUBSCRIBE:return unsubscribe_sym;
    default:              return unknown_method_sym;
  }
}


#define ELEMENTS_TOTAL 1000
static struct http_parser_data elements[ELEMENTS_TOTAL];


class Parser : public ObjectWrap {
 public:
  Parser(enum http_parser_type type) : ObjectWrap() {
    Init(type);
  }


  ~Parser() {
  }


  static Handle<Value> New(const Arguments& args) {
    HandleScope scope;

    String::Utf8Value type(args[0]->ToString());

    Parser *parser;

    if (0 == strcasecmp(*type, "request")) {
      parser = new Parser(HTTP_REQUEST);
    } else if (0 == strcasecmp(*type, "response")) {
      parser = new Parser(HTTP_RESPONSE);
    } else {
      return ThrowException(Exception::Error(
            String::New("Constructor argument be 'request' or 'response'")));
    }

    parser->Wrap(args.This());

    return args.This();
  }

  // var bytesParsed = parser->execute(buffer, off, len);
  static Handle<Value> Execute(const Arguments& args) {
    HandleScope scope;

    Parser *parser = ObjectWrap::Unwrap<Parser>(args.This());

    Local<Value> buffer_v = args[0];

    if (!Buffer::HasInstance(buffer_v)) {
      return ThrowException(Exception::TypeError(
            String::New("Argument should be a buffer")));
    }

    Local<Object> buffer_obj = buffer_v->ToObject();
    char *buffer_data = Buffer::Data(buffer_obj);
    size_t buffer_len = Buffer::Length(buffer_obj);

    size_t off = args[1]->Int32Value();
    if (off >= buffer_len) {
      return ThrowException(Exception::Error(
            String::New("Offset is out of bounds")));
    }

    size_t len = args[2]->Int32Value();
    if (off+len > buffer_len) {
      return ThrowException(Exception::Error(
            String::New("Length is extends beyond buffer")));
    }

    size_t nelements = http_parser_execute2(&parser->parser_,
                                            buffer_data + off,
                                            len,
                                            elements,
                                            ELEMENTS_TOTAL);

    // The result array has three elements for each element returned First
    // is a description string of the type. The next two depend on the type.
    Local<Array> result = Array::New(3 * nelements);

#define JS_OFFSET(el) Integer::New(el.payload.string.p - buffer_data)
#define JS_LEN(el) Integer::New(el.payload.string.len)

    for (int i = 0; i < nelements; i++) {
      switch (elements[i].type) {
        case HTTP_PARSER_ERROR:
          result->Set(3*i, String::New("ERROR"));
          result->Set(3*i + 1, JS_OFFSET(elements[i]));
          result->Set(3*i + 2, Integer::New(0));
          break;

        case HTTP_NEEDS_INPUT:
          result->Set(3*i, String::New("NEEDS_INPUT"));
          result->Set(3*i + 1, JS_OFFSET(elements[i]));
          result->Set(3*i + 2, Integer::New(0));
          break;

        case HTTP_NEEDS_DATA_ELEMENTS:
          result->Set(3*i, String::New("NEEDS_DATA_ELEMENTS"));
          result->Set(3*i + 1, JS_OFFSET(elements[i]));
          result->Set(3*i + 2, Integer::New(0));
          break;

        case HTTP_REQ_MESSAGE_START:
          result->Set(3*i, String::New("REQ_MESSAGE_START"));
          result->Set(3*i + 1, method_to_str(elements[i].payload.method));
          result->Set(3*i + 2, Null());
          break;

        case HTTP_RES_MESSAGE_START: /* payload.status */
          result->Set(3*i, String::New("RES_MESSAGE_START"));
          result->Set(3*i + 1, Integer::New(elements[i].payload.status_code));
          result->Set(3*i + 2, Null());
          break;

        case HTTP_VERSION: /* payload.version */
          result->Set(3*i, String::New("VERSION"));
          result->Set(3*i + 1, Integer::New(elements[i].payload.version.major));
          result->Set(3*i + 2, Integer::New(elements[i].payload.version.minor));
          break;

        case HTTP_PATH: /* payload.string */
          result->Set(3*i, String::New("PATH"));
          result->Set(3*i + 1, JS_OFFSET(elements[i]));
          result->Set(3*i + 2, JS_LEN(elements[i]));
          break;

        case HTTP_QUERY_STRING: /* payload.string */
          result->Set(3*i, String::New("QUERY_STRING"));
          result->Set(3*i + 1, JS_OFFSET(elements[i]));
          result->Set(3*i + 2, JS_LEN(elements[i]));
          break;

        case HTTP_FRAGMENT: /* payload.string */
          result->Set(3*i, String::New("FRAGMENT"));
          result->Set(3*i + 1, JS_OFFSET(elements[i]));
          result->Set(3*i + 2, JS_LEN(elements[i]));
          break;

        case HTTP_URL: /* payload.string */
          result->Set(3*i, String::New("URL"));
          result->Set(3*i + 1, JS_OFFSET(elements[i]));
          result->Set(3*i + 2, JS_LEN(elements[i]));
          break;

        case HTTP_HEADER_FIELD: /* payload.string */
          result->Set(3*i, String::New("HEADER_FIELD"));
          result->Set(3*i + 1, JS_OFFSET(elements[i]));
          result->Set(3*i + 2, JS_LEN(elements[i]));
          break;

        case HTTP_HEADER_VALUE: /* payload.string */
          result->Set(3*i, String::New("HEADER_VALUE"));
          result->Set(3*i + 1, JS_OFFSET(elements[i]));
          result->Set(3*i + 2, JS_LEN(elements[i]));
          break;

        case HTTP_HEADERS_END: /* payload.flags */
          // need info about upgrades
          result->Set(3*i, String::New("HEADERS_END"));
          result->Set(3*i + 1, Null());
          result->Set(3*i + 2, Null());
          break;

        case HTTP_BODY: /* payload.string */
          result->Set(3*i, String::New("BODY"));
          result->Set(3*i + 1, JS_OFFSET(elements[i]));
          result->Set(3*i + 2, JS_LEN(elements[i]));
          break;

        case HTTP_MESSAGE_END: /* payload.string */
          result->Set(3*i, String::New("MESSAGE_END"));
          result->Set(3*i + 1, JS_OFFSET(elements[i]));
          result->Set(3*i + 2, Integer::New(0));
          break;
      }
    }

#undef JS_OFFSET
#undef JS_LEN

    return scope.Close(result);
  }


  static Handle<Value> Reinitialize(const Arguments& args) {
    HandleScope scope;
    Parser *parser = ObjectWrap::Unwrap<Parser>(args.This());

    String::Utf8Value type(args[0]->ToString());

    if (0 == strcasecmp(*type, "request")) {
      parser->Init(HTTP_REQUEST);
    } else if (0 == strcasecmp(*type, "response")) {
      parser->Init(HTTP_RESPONSE);
    } else {
      return ThrowException(Exception::Error(
            String::New("Argument be 'request' or 'response'")));
    }
    return Undefined();
  }


 private:

  void Init (enum http_parser_type type) {
    http_parser_init(&parser_, type);
    parser_.data = this;
  }

  http_parser parser_;
};


void InitHttpParser(Handle<Object> target) {
  HandleScope scope;

  Local<FunctionTemplate> t = FunctionTemplate::New(Parser::New);
  t->InstanceTemplate()->SetInternalFieldCount(1);
  t->SetClassName(String::NewSymbol("HTTPParser"));

  NODE_SET_PROTOTYPE_METHOD(t, "execute", Parser::Execute);
  NODE_SET_PROTOTYPE_METHOD(t, "reinitialize", Parser::Reinitialize);

  target->Set(String::NewSymbol("HTTPParser"), t->GetFunction());

  delete_sym = NODE_PSYMBOL("DELETE");
  get_sym = NODE_PSYMBOL("GET");
  head_sym = NODE_PSYMBOL("HEAD");
  post_sym = NODE_PSYMBOL("POST");
  put_sym = NODE_PSYMBOL("PUT");
  connect_sym = NODE_PSYMBOL("CONNECT");
  options_sym = NODE_PSYMBOL("OPTIONS");
  trace_sym = NODE_PSYMBOL("TRACE");
  copy_sym = NODE_PSYMBOL("COPY");
  lock_sym = NODE_PSYMBOL("LOCK");
  mkcol_sym = NODE_PSYMBOL("MKCOL");
  move_sym = NODE_PSYMBOL("MOVE");
  propfind_sym = NODE_PSYMBOL("PROPFIND");
  proppatch_sym = NODE_PSYMBOL("PROPPATCH");
  unlock_sym = NODE_PSYMBOL("UNLOCK");
  report_sym = NODE_PSYMBOL("REPORT");
  mkactivity_sym = NODE_PSYMBOL("MKACTIVITY");
  checkout_sym = NODE_PSYMBOL("CHECKOUT");
  merge_sym = NODE_PSYMBOL("MERGE");
  msearch_sym = NODE_PSYMBOL("M-SEARCH");
  notify_sym = NODE_PSYMBOL("NOTIFY");
  subscribe_sym = NODE_PSYMBOL("SUBSCRIBE");
  unsubscribe_sym = NODE_PSYMBOL("UNSUBSCRIBE");;
  unknown_method_sym = NODE_PSYMBOL("UNKNOWN_METHOD");

  method_sym = NODE_PSYMBOL("method");
  status_code_sym = NODE_PSYMBOL("statusCode");
  http_version_sym = NODE_PSYMBOL("httpVersion");
  version_major_sym = NODE_PSYMBOL("versionMajor");
  version_minor_sym = NODE_PSYMBOL("versionMinor");
  should_keep_alive_sym = NODE_PSYMBOL("shouldKeepAlive");
  upgrade_sym = NODE_PSYMBOL("upgrade");
}

}  // namespace node

NODE_MODULE(node_http_parser, node::InitHttpParser);