//---------------------------------------------------------------------------------------------------------------------------------
// File: Connection.cpp
// Contents: C++ interface to Microsoft Driver for Node.js for SQL Server
// 
// Copyright Microsoft Corporation and contributors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
//
// You may obtain a copy of the License at:
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//---------------------------------------------------------------------------------------------------------------------------------

#include "stdafx.h"
#include "Connection.h"

namespace mssql
{
 using namespace v8;

 Persistent<FunctionTemplate> Connection::constructor_template;

 void Connection::Initialize(Handle<Object> target)
 {
 HandleScope scope;

 bool initialized = OdbcConnection::InitializeEnvironment();
 if( !initialized ) {
 
 target->Set( String::NewSymbol("Connection"), Undefined() );
 v8::ThrowException(v8::Exception::Error(v8::String::New("Unable to initialize msnodesql")));
 return;
 }

 Local<FunctionTemplate> t = FunctionTemplate::New(Connection::New);
 constructor_template = Persistent<FunctionTemplate>::New(t);
 constructor_template->InstanceTemplate()->SetInternalFieldCount(1);
 constructor_template->SetClassName(String::NewSymbol("Connection"));

 NODE_SET_PROTOTYPE_METHOD(constructor_template, "close", Connection::Close);
 NODE_SET_PROTOTYPE_METHOD(constructor_template, "open", Connection::Open);
 NODE_SET_PROTOTYPE_METHOD(constructor_template, "query", Connection::Query);
 NODE_SET_PROTOTYPE_METHOD(constructor_template, "readRow", Connection::ReadRow);
 NODE_SET_PROTOTYPE_METHOD(constructor_template, "readColumn", Connection::ReadColumn);
 NODE_SET_PROTOTYPE_METHOD(constructor_template, "readRowCount", Connection::ReadRowCount);
 NODE_SET_PROTOTYPE_METHOD(constructor_template, "beginTransaction", Connection::BeginTransaction);
 NODE_SET_PROTOTYPE_METHOD(constructor_template, "commit", Connection::Commit);
 NODE_SET_PROTOTYPE_METHOD(constructor_template, "rollback", Connection::Rollback);
 NODE_SET_PROTOTYPE_METHOD(constructor_template, "nextResult", Connection::ReadNextResult);

 target->Set(String::NewSymbol("Connection"), constructor_template->GetFunction());
 }

 Connection::~Connection( void )
 {
 // close the connection now since the object is being collected
 innerConnection->Collect();
 }

 Handle<Value> Connection::Close(const Arguments& args)
 {
 HandleScope scope;

 Local<Object> callback = args[0].As<Object>();

 Connection* connection = Unwrap<Connection>(args.This());

 return scope.Close<Value>(connection->innerConnection->Close( callback ));
 }

 Handle<Value> Connection::BeginTransaction(const Arguments& args)
 {
 HandleScope scope;

 Local<Object> callback = args[0].As<Object>();

 Connection* connection = Unwrap<Connection>(args.This());

 return scope.Close<Value>(connection->innerConnection->BeginTransaction( callback ));
 }

 Handle<Value> Connection::Commit(const Arguments& args)
 {
 HandleScope scope;

 Local<Object> callback = args[0].As<Object>();

 Connection* connection = Unwrap<Connection>(args.This());

 return scope.Close<Value>(connection->innerConnection->Commit( callback ));
 }

 Handle<Value> Connection::Rollback(const Arguments& args)
 {
 HandleScope scope;

 Local<Object> callback = args[0].As<Object>();

 Connection* connection = Unwrap<Connection>(args.This());

 return scope.Close<Value>(connection->innerConnection->Rollback( callback ));
 }

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

 if (!args.IsConstructCall()) {
 return Undefined();
 }

 Connection *c = new Connection();

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

 return args.This();
 }
 
 Handle<Value> Connection::Query(const Arguments& args)
 {
 HandleScope scope;

 Local<String> query = args[0].As<String>();
 Local<Array> params = args[1].As<Array>();
 Local<Object> callback = args[2].As<Object>();

 Connection* connection = Unwrap<Connection>(args.This());

 return scope.Close<Value>(connection->innerConnection->Query(query, params, callback));
 }
 
 Handle<Value> Connection::ReadRow(const Arguments& args)
 {
 HandleScope scope;

 Local<Object> callback = args[0].As<Object>();

 Connection* connection = Unwrap<Connection>(args.This());

 return scope.Close<Value>(connection->innerConnection->ReadRow(callback));
 }

 Handle<Value> Connection::ReadColumn(const Arguments& args)
 {
 HandleScope scope;

 Local<Number> column = args[0].As<Number>();
 Local<Object> callback = args[1].As<Object>();

 Connection* connection = Unwrap<Connection>(args.This());

 return scope.Close<Value>(connection->innerConnection->ReadColumn(column, callback));
 }
 
 Handle<Value> Connection::ReadNextResult(const Arguments& args)
 {
 HandleScope scope;

 Local<Object> callback = args[0].As<Object>();

 Connection* connection = Unwrap<Connection>(args.This());

 return scope.Close<Value>(connection->innerConnection->ReadNextResult(callback));
 }

 Handle<Value> Connection::ReadRowCount(const Arguments& args)
 {
 Connection* connection = Unwrap<Connection>(args.This());

 return connection->innerConnection->ReadRowCount();
 }

 Handle<Value> Connection::Open(const Arguments& args)
 {
 HandleScope scope;

 Local<String> connectionString = args[0].As<String>();
 Local<Object> callback = args[1].As<Object>();

 Connection* connection = Unwrap<Connection>(args.This());

 return scope.Close<Value>(connection->innerConnection->Open(connectionString, callback, args.This()));
 }

}

NODE_MODULE(sqlserver, mssql::Connection::Initialize);