//---------------------------------------------------------------------------------------------------------------------------------
// 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);