//http://blog.owned.co.za v8 Javascript Helper Function ,
//Give this function the c++ object (an instance) to wrap, 
//and it returns a JS object to expose things under.
//Note theres 2 functions here , 
//the top one is used by the ExposeClass function

template 
v8::Handle WrapClass(T* y)
{
        // Handle scope for temporary handles, 
        v8::HandleScope handle_scope;
        v8::Persistent  class_template_;
        
        v8::Handle rt = v8::ObjectTemplate::New();
        
        //The raw template is the ObjectTemplate
        // (that can be exposed to script too)
        //but is maintained internally.
        rt->SetInternalFieldCount(1);
        
        //Create the actual template object, 
        class_template_ = v8::Persistent::New(rt);
        
        //Create the new handle to return, and set its template type 
        v8::Handle result = class_template_->NewInstance();
        v8::Handle class_ptr
        class_ptr = v8::External::New(static_cast(y)); 
        
        //Point the 0 index Field to the c++ pointer for unwrapping later
        result->SetInternalField(0, class_ptr);
        
        //Return the value, releasing the other handles on its way.
        return handle_scope.Close(result);
} 


template
v8::Handle ExposeClass(v8::Persistent context, 
                                   T* y, 
                                   v8::Handle exposedName, 
                                   v8::PropertyAttribute props)
{
        v8::HandleScope handle_scope;
        
         v8::Handle obj = Core::Script::WrapClass(y);
        context->Global()->Set(exposedName, obj, props);
        
        return handle_scope.Close(obj);
}

//http://blog.owned.co.za v8 Javascript Helper Function ,
//Give this function the v8 JS object to unwrap, and the class to unwrap to.
                
template 
T* UnwrapClass(v8::Handle obj) 
{
        v8::Handle field;
        field = v8::Handle::Cast(obj->GetInternalField(0));
        void* ptr = field->Value();
        return static_cast(ptr);
}

class cCore
{

public:

        //This is a simple example, 
        //do not copy this as a real class.
        cCore(){};
        ~cCore() {};

        //We need a persistant handle to the core in scripts, a non persistant
        //v8::Handle will get lost in the handle scopes, 
        //and throw some weird exceptions to hunt down. 
        //Wrap class and unwrap class return 
        //NON persistant handles, so store your own 
        //persistant ones if you want to 
        //use it outside of the first handle scope.

        //core script object,  "core" in scripts.
        v8::Persistent cso_core;                                    

        //We expose some functions in our class to the scripts from c++, 
        //By wrapping an object (cso_core above) and the attaching functions
        //to that object. Those functions, when called from javascript - 
        //end up here.

        //The functions are self explanatory.

        //Print some text to the console/ui console
        static v8::Handle xecho(const v8::Arguments& args);         
        //execute a javascript file       
        static v8::Handle xexec(const v8::Arguments& args);         
        //exit all systems and shutdown       
        static v8::Handle xexit(const v8::Arguments& args);                
                                        
}; //end class declaration

//Just for clarity sake, so you can see my workflow.
void cScriptSystem::startup()
{
        //Create a script engine for the core
        v8::HandleScope handle_scope;

        //Create a context for the system to use 
        //(i have just one at this point)
        coreContext = v8::Context::New(NULL, global);

        //Enter the main context, making it active.
        v8::Context::Scope context_scope(coreContext);

        exposeCore(); //see below
};
                
//And the code to expose the class, 
void cScriptSystem::exposeCore()
{
        v8::HandleScope handlescope;

        //This will be reused to expose multiple 
        //classes, short name for easy code.
        v8::Handle cc;
                        
        //get the JS version of the C++ object, 
        //note that core is simply Core::cCore* core; 
        cc = ExposeClass< Core::cCore >(coreContext, core,  
                                         v8::String::New("core"), 
                                         v8::ReadOnly);
                        
        //set the persistant handle for use outside of this handlescospe
        core->cso_core = v8::Persistent::New(cc);

        //Give the functions to the object. 
        //This makes the functions come out as 
        //core.echo(), core.exec(), core.exit() in scripts.
        Expose(core->cso_core, v8::String::New("echo") , 
               v8::InvocationCallback(Core::cCore::xecho));
        Expose(core->cso_core, v8::String::New("exec") , 
               v8::InvocationCallback(Core::cCore::xexec));
        Expose(core->cso_core, v8::String::New("exit") , 
               v8::InvocationCallback(Core::cCore::xexit));

};

v8::Handle cCore::xexit(const v8::Arguments& args)
{
        //args.Holder() is the object that the function was invoked upon. 
        //This means it could be exposed to 2 classes, 
        //under different types so be sure
        //that you dont just randomly unwrap into the wrong container type.
                        
        Core::cCore* core = UnwrapClass( args.Holder() );
                                
        //The code inside the normal exit function is identical, 
        //so i can just call the normal c++ code directly.                
        core->startShutdown();
                        
        //This is to return void, basically.
        return v8::Undefined();
}

void Expose(v8::Handle intoObject, v8::Handle namev8String, v8::InvocationCallback funcID)
{
    v8::HandleScope handle_scope;

    v8::Handle thisFunc;
    thisFunc = v8::FunctionTemplate::New(funcID);
    intoObject->Set(namev8String, thisFunc->GetFunction());
}

//you can now use it std::string(*somestdstring)
v8::String::Utf8Value        somestdstring ( args[0] );  
                
        //you can now use it *somecstring (same as const char* somecstring;)
v8::String::Utf8Value        somecstring ( args[1] );        

        //normal double, 
double somedouble = args[2]->ToNumber()->Value();
        //booleans
bool somebool = args[3]->ToBoolean()->BooleanValue(); 
        //and integers.
int someint = args[4]->ToInt32()->Int32Value();        
                
//And one last thing, giving javascript meaningful return values. 
//This should be more than enough to let you figure out how simple
//v8 makes things for you on the c++ side.
                
        return handle_scope.Close(v8::Number::New(somedouble));
        return handle_scope.Close(v8::Int32::New(someint));
        return handle_scope.Close(v8::Boolean::New(somebool));