/**

 * Relational pipes

 * Copyright © 2019 František Kučera (Frantovo.cz, GlobalCode.info)

 *

 * This program is free software: you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation, version 3.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program. If not, see <http://www.gnu.org/licenses/>.

 */

#include <memory>

#include <iostream>

#include <sql.h>

#include <sqlext.h>

#include "Connection.h"

#include "OdbcCommon.h"

namespace relpipe {

namespace tr {

namespace sql {

Connection::Connection(void* db) : connection(db) {

	setAutoCommit(false);

}

Connection::~Connection() {

	// If an exception was thrown somewhere, there might be a transaction in progress, so we will cancel this transaction.

	// If there was no exception, commit() has already been called and this rollback() will not affect any (desired) transaction.

	// Without this rollback(), SQLDisconnect() will fail and then will fail also freeHandle() which will throw exception.

	// And throwing exception while throwing exception will lead to a catastrophic failure: SIGABRT, core dump.

	rollback();

	SQLRETURN result = SQLDisconnect(connection);

	OdbcCommon::freeHandle(SQL_HANDLE_DBC, connection);

}

PreparedStatement* Connection::prepareStatement(relpipe::reader::string_t sql) {

	SQLHSTMT statement = OdbcCommon::allocateHandle(SQL_HANDLE_STMT, connection);

	SQLRETURN result = SQLPrepare(statement, (SQLCHAR*) convertor.to_bytes(sql).c_str(), SQL_NTS);

	if (OdbcCommon::isNotSuccessful(result)) throw SqlException(L"Unable to prepare statement", result, SQL_HANDLE_STMT, statement, true);

	return new PreparedStatement(statement);

}

bool Connection::getAutoCommit() {

	SQLULEN autoCommit = SQL_AUTOCOMMIT_DEFAULT;

	SQLRETURN result = SQLGetConnectOption(connection, SQL_AUTOCOMMIT, &autoCommit);

	if (OdbcCommon::isNotSuccessful(result)) throw SqlException(L"Unable to get auto-commit status", result, SQL_HANDLE_DBC, connection);

	if (autoCommit == SQL_AUTOCOMMIT_ON) return true;

	else if (autoCommit == SQL_AUTOCOMMIT_OFF) return false;

	else throw SqlException(L"Unexpected value of auto-commit status");

}

void Connection::setAutoCommit(bool autoCommit) {

	SQLRETURN result = SQLSetConnectOption(connection, SQL_AUTOCOMMIT, autoCommit ? SQL_AUTOCOMMIT_ON : SQL_AUTOCOMMIT_OFF);

	if (OdbcCommon::isNotSuccessful(result)) throw SqlException(std::wstring(L"Unable to set auto-commit to ") + (autoCommit ? L"enabled" : L"disabled"), result, SQL_HANDLE_DBC, connection);

}

void Connection::commit() {

	SQLRETURN result = SQLEndTran(SQL_HANDLE_DBC, connection, SQL_COMMIT);

	if (OdbcCommon::isNotSuccessful(result)) throw SqlException(L"Unable to COMMIT: " + std::to_wstring(result));

}

void Connection::rollback() {

	SQLRETURN result = SQLEndTran(SQL_HANDLE_DBC, connection, SQL_ROLLBACK);

	if (OdbcCommon::isNotSuccessful(result)) throw SqlException(L"Unable to ROLLBACK: " + std::to_wstring(result));

}

std::vector<Connection::TablePrivilege> Connection::getTablePrivileges() {

	std::vector<TablePrivilege> tables;

	SQLHSTMT statementHandle = OdbcCommon::allocateHandle(SQL_HANDLE_STMT, connection);

	SQLRETURN result = SQLTablePrivileges(statementHandle, nullptr, 0, nullptr, 0, nullptr, 0);

	if (OdbcCommon::isNotSuccessful(result)) throw SqlException(L"Unable get tables (prepare)", result, SQL_HANDLE_STMT, statementHandle, true);

	ResultSet resultSet(statementHandle);

	std::shared_ptr<ResultSet::MetaData> metaData(resultSet.getMetaData());

	SQLUSMALLINT catalogColumn = metaData->getColumnNumber(L"TABLE_CAT");

	SQLUSMALLINT schemaColumn = metaData->getColumnNumber(L"TABLE_SCHEM");

	SQLUSMALLINT nameColumn = metaData->getColumnNumber(L"TABLE_NAME");

	SQLUSMALLINT grantorColumn = metaData->getColumnNumber(L"GRANTOR");

	SQLUSMALLINT granteeColumn = metaData->getColumnNumber(L"GRANTEE");

	SQLUSMALLINT privilegeColumn = metaData->getColumnNumber(L"PRIVILEGE");

	SQLUSMALLINT isGrantableColumn = metaData->getColumnNumber(L"IS_GRANTABLE");

	while (resultSet.next()) {

		TablePrivilege tp;

		tp.catalog = resultSet.getString(catalogColumn);

		tp.schema = resultSet.getString(schemaColumn);

		tp.name = resultSet.getString(nameColumn);

		tp.grantor = resultSet.getString(grantorColumn);

		tp.grantee = resultSet.getString(granteeColumn);

		tp.privilege = resultSet.getString(privilegeColumn);

		tp.isGrantable = resultSet.getString(isGrantableColumn) == L"YES";

		tables.emplace_back(tp);

	}

	return tables;

}

relpipe::reader::string_t Connection::getUserName() {

	std::vector<char> buffer(100);

	SQLSMALLINT stringLength;

	SQLRETURN result = SQLGetInfo(connection, SQL_USER_NAME, buffer.data(), buffer.size(), &stringLength);

	if (OdbcCommon::isNotSuccessful(result)) throw SqlException(L"Unable to get user name: " + std::to_wstring(result));

	if (stringLength >= buffer.size()) throw SqlException(L"Unable to get user name: too long" + std::to_wstring(stringLength));

	return convertor.from_bytes(buffer.data(), buffer.data() + stringLength);

}

}

}

}