#include "angelscript.h"
#include "scriptstring.h"

#include <iostream>
#include <cassert>
#include <cstdio>

//------------------------------------------------------------------------------
// Helper framework

template <typename T>
struct CallHelper {
  T element;
  CallHelper(T t) : element(t) {}
};

class ScriptObjectCallBase {
  public:
    ScriptObjectCallBase(const char * decl, asIScriptObject * obj) {
      asIScriptEngine * engine = obj->GetEngine();
      ctx_ = engine->CreateContext();
      asIObjectType * type = obj->GetObjectType();
      int id = type->GetMethodIdByDecl(decl); assert(id >= 0);
      ctx_->Prepare(id);
      ctx_->SetObject(obj);
    }
    
    ScriptObjectCallBase(const ScriptObjectCallBase & other) {
      ctx_->AddRef();
    }
    
    ScriptObjectCallBase & operator=(const ScriptObjectCallBase & other) {
      other.ctx_->AddRef();
      ctx_->Release();
      ctx_ = other.ctx_;
    }
    
    ~ScriptObjectCallBase() {
      ctx_->Release();
    }
  protected:
    void execute(void) {
      int r = ctx_->Execute(); assert(r >= 0);
    }
    void * return_address(void) {
      return ctx_->GetAddressOfReturnValue();
    }
    template <typename T>
    void set_arg(asUINT arg, T t) {
      new (ctx_->GetArgPointer(arg)) CallHelper<T>(t);
    }
   
  private:
    asIScriptContext * ctx_;
};

template <typename Fn>
class ScriptObjectCall {};

template <>
class ScriptObjectCall<void (void)> : ScriptObjectCallBase {
  public:
    ScriptObjectCall(const char * decl, asIScriptObject * obj)
      : ScriptObjectCallBase(decl, obj) {}
      
    void operator()(void) {
      execute();
    }
};

template <typename R>
class ScriptObjectCall<R (void)> : ScriptObjectCallBase {
  public:
    ScriptObjectCall(const char * decl, asIScriptObject * obj)
      : ScriptObjectCallBase(decl, obj) {}
      
    R operator()(void) {
      execute();
      return static_cast<CallHelper<R> *>(return_address())->element;
    }
};

template <typename A0>
class ScriptObjectCall<void (A0)> : ScriptObjectCallBase {
  public:
    ScriptObjectCall(const char * decl, asIScriptObject * obj)
      : ScriptObjectCallBase(decl, obj) {}
      
    void operator()(A0 a0) {
      set_arg<A0>(0, a0);
      execute();
    }
};

template <typename R, typename A0>
class ScriptObjectCall<R (A0)> : ScriptObjectCallBase {
  public:
    ScriptObjectCall(const char * decl, asIScriptObject * obj)
      : ScriptObjectCallBase(decl, obj) {}
      
    R operator()(A0 a0) {
      set_arg<A0>(0, a0);
      execute();
      return static_cast<CallHelper<R> *>(return_address())->element;
    }
};

template <typename A0, typename A1>
class ScriptObjectCall<void (A0, A1)> : ScriptObjectCallBase {
  public:
    ScriptObjectCall(const char * decl, asIScriptObject * obj)
      : ScriptObjectCallBase(decl, obj) {}
      
    void operator()(A0 a0, A1 a1) {
      set_arg<A0>(0, a0);
      set_arg<A1>(1, a1);
      execute();
    }
};

template <typename R, typename A0, typename A1>
class ScriptObjectCall<R (A0, A1)> : ScriptObjectCallBase {
  public:
    ScriptObjectCall(const char * decl, asIScriptObject * obj)
      : ScriptObjectCallBase(decl, obj) {}
      
    R operator()(A0 a0, A1 a1) {
      set_arg<A0>(0, a0);
      set_arg<A1>(1, a1);
      execute();
      return static_cast<CallHelper<R> *>(return_address())->element;
    }
};

class ScriptMarshalHelper {
  public:
    ScriptMarshalHelper(asIScriptObject * obj) : obj_(obj) { obj->AddRef(); }
    ~ScriptMarshalHelper() { obj_->Release(); }
    
    template <typename T>
    ScriptObjectCall<T> call(const char * decl) {
      return ScriptObjectCall<T>(decl, obj_);
    }
  private:
    ScriptMarshalHelper(const ScriptMarshalHelper &);
    ScriptMarshalHelper & operator=(const ScriptMarshalHelper &);
    
    asIScriptObject * obj_;
};

//------------------------------------------------------------------------------
// Involved C++ classes

// Base interface
struct IFoo {
  virtual void bar(void) = 0;
  virtual int  baz(int a, int b) = 0;
  virtual ~IFoo() {}
};

// C++ implementation of interface
struct Foo : IFoo {
  int data;
  
  Foo(void) : data(0) {}
  Foo(int d) : data(d) {}
  Foo(const Foo & other) : data(other.data) {}
  Foo & operator=(const Foo & other) {
    data = other.data;
    return *this;
  }
  ~Foo() {}
  
  void bar(void) { std::cout << "Foo::bar() - " << data << std::endl; }
  int  baz(int a, int b) { return a + b; }
};

// C++ class for accessing script implementation of interface
struct FooScript : IFoo, ScriptMarshalHelper {
  FooScript(asIScriptObject * obj) : ScriptMarshalHelper(obj) {}

  void bar(void) {
    call<void (void)>("void bar()")();
  }
  int baz(int a, int b) {
    return call<int (int, int)>("int baz(int, int)")(a, b);
  }
};

//------------------------------------------------------------------------------
void construct_default(void * location) {
  new (location) Foo();
}

void construct_copy(const Foo & foo, void * location) {
  new (location) Foo(foo);
}

void construct_int(int data, void * location) {
  new (location) Foo(data);
}

void destroy(void * location) {
  static_cast<Foo *>(location)->~Foo();
}
//------------------------------------------------------------------------------

void MessageCallback(const asSMessageInfo *msg, void *param)
{
	const char *type = "ERR ";
	if( msg->type == asMSGTYPE_WARNING ) 
		type = "WARN";
	else if( msg->type == asMSGTYPE_INFORMATION ) 
		type = "INFO";

	printf("%s (%d, %d) : %s : %s\n", msg->section, msg->row, msg->col, type, msg->message);
}

void PrintString(std::string & str) {
	std::cout << str;
}


int main(int, char **) {
  asIScriptEngine * engine = asCreateScriptEngine(ANGELSCRIPT_VERSION);
  engine->SetMessageCallback(asFUNCTION(MessageCallback), 0, asCALL_CDECL);
  
  RegisterScriptString(engine);
  int r;
  
  r = engine->RegisterGlobalFunction("void print(string & in)", asFUNCTION(PrintString), asCALL_CDECL); assert( r >= 0 );
  
  // Register FooInner type
  r = engine->RegisterObjectType("FooInner", sizeof(Foo), asOBJ_VALUE | asOBJ_APP_CLASS_CDA); assert(r >= 0);
  r = engine->RegisterObjectBehaviour("FooInner", asBEHAVE_CONSTRUCT,  "void f()", asFUNCTION(construct_default), asCALL_CDECL_OBJLAST); assert(r >= 0);
  r = engine->RegisterObjectBehaviour("FooInner", asBEHAVE_CONSTRUCT,  "void f(const FooInner & in)", asFUNCTION(construct_copy), asCALL_CDECL_OBJLAST); assert(r >= 0);
  r = engine->RegisterObjectBehaviour("FooInner", asBEHAVE_CONSTRUCT,  "void f(int)", asFUNCTION(construct_int), asCALL_CDECL_OBJLAST); assert(r >= 0);
  r = engine->RegisterObjectBehaviour("FooInner", asBEHAVE_DESTRUCT,   "void f()", asFUNCTION(destroy), asCALL_CDECL_OBJLAST); assert(r >= 0);
  r = engine->RegisterObjectBehaviour("FooInner", asBEHAVE_ASSIGNMENT, "FooInner & f(const FooInner & in)", asMETHOD(Foo, operator =), asCALL_THISCALL); assert(r >= 0);
  r = engine->RegisterObjectMethod("FooInner", "void bar()", asMETHOD(Foo, bar), asCALL_THISCALL); assert(r >= 0);
  r = engine->RegisterObjectMethod("FooInner", "int baz(int, int)", asMETHOD(Foo, baz), asCALL_THISCALL); assert(r >= 0);
  r = engine->RegisterObjectProperty("FooInner", "int data", offsetof(Foo, data)); assert(r >= 0);
  
  // Create IFoo script interface
  r = engine->RegisterInterface("IFoo"); assert(r >= 0);
  r = engine->RegisterInterfaceMethod("IFoo", "void bar()"); assert(r >= 0);
  r = engine->RegisterInterfaceMethod("IFoo", "int baz(int, int)"); assert(r >= 0);

  const char script[] =
    // Foo base class for script classes
    "class Foo : IFoo {\n"
    "  FooInner inner;\n"
    "  Foo() {\n"
    "    inner = FooInner();\n"
    "  }\n"
    "  Foo(int data) {\n"
    "    inner = FooInner(data);\n"
    "  }\n"
    "  void bar() {\n"
    "    inner.bar();\n"
    "  }\n"
    "  int baz(int a, int b) {\n"
    "    return inner.baz(a, b);\n"
    "  }\n"
    "  int get_data() { return inner.data; }\n"
    "  void set_data(int data) { inner.data = data; }\n"
    "}\n"

    // Concrete foo class using inheritance from Foo
    "class CFoo1 : Foo {\n"
    "  void bar() {\n"
    "    print(\"CFoo1::bar()\\n\");\n"
    "  }\n"
    "  int baz(int a, int b) {\n"
    "    return Foo::baz(a, b) * 2;\n"
    "  }\n"
    "}\n"

    // Concrete foo class implementing IFoo
    "class CFoo2 : IFoo {\n"
    "  void bar() {\n"
    "    print(\"CFoo2::bar()\\n\");\n"
    "  }\n"
    "  int baz(int a, int b) {\n"
    "    return a * b;\n"
    "  }\n"
    "}\n"
    
    // Test all three in script
    "void main() {\n"

    "  Foo f1(3);\n"
    "  f1.bar();\n"
    "  print(f1.baz(6, 6) + \"\\n\");\n"

    "  CFoo1 f2;\n"
    "  f2.bar();\n"
    "  print(f2.baz(6, 6) + \"\\n\");\n"

    "  CFoo2 f3;\n"
    "  f3.bar();\n"
    "  print(f3.baz(6, 6) + \"\\n\");\n"

    "}\n"
  ;
    
  asIScriptModule * mod = engine->GetModule(0, asGM_ALWAYS_CREATE);
  r = mod->AddScriptSection("script", script, sizeof(script) - 1); assert(r >= 0);
  r = mod->Build(); assert(r >= 0);

  int func_id = mod->GetFunctionIdByDecl("void main()"); assert(func_id >= 0);
  asIScriptContext * ctx = engine->CreateContext();

  r = ctx->Prepare(func_id); assert(r >= 0);
  r = ctx->Execute(); assert(r >= 0);

  ctx->Release();
  
  {
    // get IFoo for CFoo1
    int cfoo1_type_id = mod->GetTypeIdByDecl("CFoo1");
    asIScriptObject * f1 = static_cast<asIScriptObject *>(engine->CreateScriptObject(cfoo1_type_id));
    IFoo * cfoo1 = new FooScript(f1);
    cfoo1->bar();
    std::cout << cfoo1->baz(6, 6) << std::endl;
    delete cfoo1;
    f1->Release();
  } {
    // get IFoo for CFoo2
    int cfoo2_type_id = mod->GetTypeIdByDecl("CFoo2");
    asIScriptObject * f2 = static_cast<asIScriptObject *>(engine->CreateScriptObject(cfoo2_type_id));
    IFoo * cfoo2 = new FooScript(f2);
    cfoo2->bar();
    std::cout << cfoo2->baz(6, 6) << std::endl;
    delete cfoo2;
    f2->Release();
  }  

  engine->Release();
}