#include <assert.h>
#include <fcntl.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>

#include <v8.h>
#include <vector>

#include "js_shell.h"

typedef int (*V8ExtensionInitializer) (v8::Handle<v8::Object> module);

// Note: these typedefs and defines are used to deal with  v8 API changes since version 3.19.00

typedef void SwigV8ReturnValue;
typedef v8::FunctionCallbackInfo<v8::Value> SwigV8Arguments;
typedef v8::PropertyCallbackInfo<v8::Value> SwigV8PropertyCallbackInfo;
#define SWIGV8_RETURN(val) args.GetReturnValue().Set(val); return
#define SWIGV8_RETURN_INFO(val, info) info.GetReturnValue().Set(val); return

#define SWIGV8_HANDLESCOPE() v8::HandleScope scope(v8::Isolate::GetCurrent());
#define SWIGV8_HANDLESCOPE_ESC() v8::EscapableHandleScope scope(v8::Isolate::GetCurrent());
#define SWIGV8_ESCAPE(val) return scope.Escape(val)

#define SWIGV8_CURRENT_CONTEXT() v8::Isolate::GetCurrent()->GetCurrentContext()
#define SWIGV8_STRING_NEW(str) v8::String::NewFromUtf8(v8::Isolate::GetCurrent(), str)
#define SWIGV8_FUNCTEMPLATE_NEW(func) v8::FunctionTemplate::New(v8::Isolate::GetCurrent(), func)
#define SWIGV8_OBJECT_NEW() v8::Object::New(v8::Isolate::GetCurrent())
#define SWIGV8_EXTERNAL_NEW(val) v8::External::New(v8::Isolate::GetCurrent(), val)
#define SWIGV8_UNDEFINED() v8::Undefined(v8::Isolate::GetCurrent())

typedef v8::Local<v8::Context> SwigV8Context;

class V8Shell: public JSShell {

public:
  V8Shell();

  virtual ~V8Shell();

  virtual bool RunScript(const std::string &scriptPath);

  virtual bool RunShell();


protected:

  virtual bool InitializeEngine();

  virtual bool ExecuteScript(const std::string &source, const std::string &scriptPath);

  virtual bool DisposeEngine();

private:

  v8::Handle<v8::Value> Import(const std::string &moduleName);

  SwigV8Context CreateShellContext();

  void ReportException(v8::TryCatch *handler);

  static SwigV8ReturnValue Print(const SwigV8Arguments &args);

  static SwigV8ReturnValue Require(const SwigV8Arguments &args);

  static SwigV8ReturnValue Quit(const SwigV8Arguments &args);

  static SwigV8ReturnValue Version(const SwigV8Arguments &args);

  static const char* ToCString(const v8::String::Utf8Value &value);

};

#ifdef __GNUC__
#include <dlfcn.h>
#define LOAD_SYMBOL(handle, name) dlsym(handle, name)
#else
#error "implement dll loading"
#endif

V8Shell::V8Shell() {}

V8Shell::~V8Shell() {}

bool V8Shell::RunScript(const std::string &scriptPath) {
  std::string source = ReadFile(scriptPath);

  v8::Isolate *isolate = v8::Isolate::New();
  v8::Isolate::Scope isolate_scope(isolate);

  SWIGV8_HANDLESCOPE();

  SwigV8Context context = CreateShellContext();

  if (context.IsEmpty()) {
      printf("Could not create context.\n");
      return false;
  }

  context->Enter();

  // Store a pointer to this shell for later use

  v8::Handle<v8::Object> global = context->Global();
  v8::Local<v8::External> __shell__ = SWIGV8_EXTERNAL_NEW((void*) (long) this);

  global->SetHiddenValue(SWIGV8_STRING_NEW("__shell__"), __shell__);

  // Node.js compatibility: make `print` available as `console.log()`
  ExecuteScript("var console = {}; console.log = print;", "<console>");

  bool success = ExecuteScript(source, scriptPath);

  // Cleanup

  context->Exit();

//    context.Dispose();

//  v8::V8::Dispose();

  return success;
}

bool V8Shell::RunShell() {
  SWIGV8_HANDLESCOPE();

  SwigV8Context context = CreateShellContext();

  if (context.IsEmpty()) {
      printf("Could not create context.\n");
      return false;
  }

  context->Enter();

  v8::Context::Scope context_scope(context);

  ExecuteScript("var console = {}; console.log = print;", "<console>");

  static const int kBufferSize = 1024;
  while (true) {
    char buffer[kBufferSize];
    printf("> ");
    char *str = fgets(buffer, kBufferSize, stdin);
    if (str == NULL) break;
    std::string source(str);
    ExecuteScript(source, "(shell)");
  }
  printf("\n");

  // Cleanup

  context->Exit();

//    context.Dispose();

//  v8::V8::Dispose();

  return true;
}


bool V8Shell::InitializeEngine() {
  return true;
}

bool V8Shell::ExecuteScript(const std::string &source, const std::string &name) {
  SWIGV8_HANDLESCOPE();

  v8::TryCatch try_catch;
  v8::Handle<v8::Script> script = v8::Script::Compile(SWIGV8_STRING_NEW(source.c_str()), SWIGV8_STRING_NEW(name.c_str()));

  // Stop if script is empty
  if (script.IsEmpty()) {
    // Print errors that happened during compilation.
    ReportException(&try_catch);
    return false;
  }

  v8::Handle<v8::Value> result = script->Run();

  // Print errors that happened during execution.
  if (try_catch.HasCaught()) {
    ReportException(&try_catch);
    return false;
  } else {
    return true;
  }
}

bool V8Shell::DisposeEngine() {
  return true;
}

SwigV8Context V8Shell::CreateShellContext() {
  // Create a template for the global object.
  v8::Handle<v8::ObjectTemplate> global = v8::ObjectTemplate::New();

  // Bind global functions
  global->Set(SWIGV8_STRING_NEW("print"), SWIGV8_FUNCTEMPLATE_NEW(V8Shell::Print));
  global->Set(SWIGV8_STRING_NEW("quit"), SWIGV8_FUNCTEMPLATE_NEW(V8Shell::Quit));
  global->Set(SWIGV8_STRING_NEW("require"), SWIGV8_FUNCTEMPLATE_NEW(V8Shell::Require));
  global->Set(SWIGV8_STRING_NEW("version"), SWIGV8_FUNCTEMPLATE_NEW(V8Shell::Version));

  SwigV8Context context = v8::Context::New(v8::Isolate::GetCurrent(), NULL, global);
  return context;
}

v8::Handle<v8::Value> V8Shell::Import(const std::string &module_path)
{
  SWIGV8_HANDLESCOPE_ESC();

  HANDLE library;
  std::string module_name = LoadModule(module_path, &library);

  std::string symname = std::string(module_name).append("_initialize");

  V8ExtensionInitializer init_function = reinterpret_cast<V8ExtensionInitializer>((long) LOAD_SYMBOL(library, symname.c_str()));

  if(init_function == 0) {
    printf("Could not find initializer function.");

    return SWIGV8_UNDEFINED();
  }

  v8::Local<v8::Object> module = SWIGV8_OBJECT_NEW();
  init_function(module);

  SWIGV8_ESCAPE(module);
}

SwigV8ReturnValue V8Shell::Print(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();

  bool first = true;
  for (int i = 0; i < args.Length(); i++) {

    if (first) {
      first = false;
    } else {
      printf(" ");
    }
    v8::String::Utf8Value str(args[i]);
    const char *cstr = V8Shell::ToCString(str);
    printf("%s", cstr);
  }
  printf("\n");
  fflush(stdout);

  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}

SwigV8ReturnValue V8Shell::Require(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();

  if (args.Length() != 1) {
    printf("Illegal arguments for `require`");
  }

  v8::String::Utf8Value str(args[0]);
  const char *cstr = V8Shell::ToCString(str);
  std::string moduleName(cstr);

  v8::Local<v8::Object> global = SWIGV8_CURRENT_CONTEXT()->Global();

  v8::Local<v8::Value> hidden = global->GetHiddenValue(SWIGV8_STRING_NEW("__shell__"));
  v8::Local<v8::External> __shell__ = v8::Local<v8::External>::Cast(hidden);
  V8Shell *_this = (V8Shell *) (long) __shell__->Value();

  v8::Handle<v8::Value> module = _this->Import(moduleName);

  SWIGV8_RETURN(module);
}

SwigV8ReturnValue V8Shell::Quit(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();

  int exit_code = args[0]->Int32Value();
  fflush(stdout);
  fflush(stderr);
  exit(exit_code);

  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}

SwigV8ReturnValue V8Shell::Version(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    SWIGV8_RETURN(SWIGV8_STRING_NEW(v8::V8::GetVersion()));
}

void V8Shell::ReportException(v8::TryCatch *try_catch) {
  SWIGV8_HANDLESCOPE();

  v8::String::Utf8Value exception(try_catch->Exception());
  const char *exception_string = V8Shell::ToCString(exception);
  v8::Handle<v8::Message> message = try_catch->Message();
  if (message.IsEmpty()) {
    // V8 didn't provide any extra information about this error; just
    // print the exception.
    printf("%s\n", exception_string);
  } else {
    // Print (filename):(line number): (message).
    v8::String::Utf8Value filename(message->GetScriptResourceName());
    const char *filename_string = V8Shell::ToCString(filename);
    int linenum = message->GetLineNumber();
    printf("%s:%i: %s\n", filename_string, linenum, exception_string);
    // Print line of source code.
    v8::String::Utf8Value sourceline(message->GetSourceLine());
    const char *sourceline_string = V8Shell::ToCString(sourceline);
    printf("%s\n", sourceline_string);
    // Print wavy underline (GetUnderline is deprecated).
    int start = message->GetStartColumn();
    for (int i = 0; i < start; i++) {
      printf(" ");
    }
    int end = message->GetEndColumn();
    for (int i = start; i < end; i++) {
      printf("^");
    }
    printf("\n");
    v8::String::Utf8Value stack_trace(try_catch->StackTrace());
    if (stack_trace.length() > 0) {
      const char *stack_trace_string = V8Shell::ToCString(stack_trace);
      printf("%s\n", stack_trace_string);
    }
  }
}

// Extracts a C string from a V8 Utf8Value.
const char *V8Shell::ToCString(const v8::String::Utf8Value &value) {
  return *value ? *value : "<string conversion failed>";
}

JSShell *V8Shell_Create() {
  return new V8Shell();
}