/**

 * Relational pipes

 * Copyright © 2020 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 <sstream>

#include <algorithm>

#include <sql.h>

#include <sqlext.h>

#include "ResultSet.h"

#include "OdbcCommon.h"

namespace relpipe {

namespace tr {

namespace sql {

ResultSet::ResultSet(void* statement) : statement(statement) {

}

ResultSet::~ResultSet() {

	// freeHandle() is called in ~PreparedStatement()

}

bool ResultSet::next() {

	SQLRETURN result = SQLFetch(statement);

	if (OdbcCommon::isSuccessful(result)) return true;

	else if (result == SQL_NO_DATA) return false;

	else throw SqlException(L"Unable to fetch next record", result, SQL_HANDLE_STMT, statement);

}

relpipe::writer::boolean_t ResultSet::getBoolean(unsigned short columnNumber, bool* isNull) {

	relpipe::writer::string_t s = getString(columnNumber, isNull);

	if (isNull && *isNull) return false;

	else if (s == L"1" || s == L"true" || s == L"y" || s == L"yes" || s == L"TRUE" || s == L"Y" || s == L"YES") return true;

	else if (s == L"0" || s == L"false" || s == L"n" || s == L"no" || s == L"FALSE" || s == L"N" || s == L"NO") return false;

	else throw SqlException(L"Unable to parse „" + s + L"“ as boolean");

}

relpipe::writer::integer_t ResultSet::getInteger(unsigned short columnNumber, bool* isNull) {

	// TODO: get integer directly from SQLGetData() without string conversion

	relpipe::writer::string_t s = getString(columnNumber, isNull);

	if (isNull && *isNull) return 0;

}

relpipe::writer::string_t ResultSet::getString(unsigned short columnNumber, bool* isNull) {

	SQLCHAR uselessBuffer; // just to get stringLength – ODBC does not eat nullptr

	SQLLEN stringLength = -1;

	SQLRETURN result = SQLGetData(statement, columnNumber, SQL_C_CHAR, &uselessBuffer, 0, &stringLength);

	if (isNull) *isNull = stringLength == SQL_NULL_DATA;

	if (stringLength == SQL_NULL_DATA) {

		return L"";

	} else if (stringLength >= 0) {

		std::string value;

		value.reserve(stringLength);

		result = SQLGetData(statement, columnNumber, SQL_C_CHAR, (SQLCHAR*) value.c_str(), value.capacity() + 1, &stringLength); // trailing null byte = + 1

		if (OdbcCommon::isSuccessful(result)) return convertor.from_bytes(value.c_str());

	}

	throw SqlException(L"Unable to get string value", result, SQL_HANDLE_STMT, statement);

}

ResultSet::MetaData* ResultSet::getMetaData() {

	SQLRETURN result;

	SQLSMALLINT columnCount;

	std::vector<ResultSet::MetaData::ColumnDescriptor> columnDescriptors;

	result = SQLNumResultCols(statement, &columnCount);

	if (OdbcCommon::isNotSuccessful(result)) throw SqlException(L"Unable to get column count", result, SQL_HANDLE_STMT, statement);

	for (SQLSMALLINT columnNumber = 1; columnNumber <= columnCount; columnNumber++) {

		ResultSet::MetaData::ColumnDescriptor columnDescriptor;

		std::string nameBuffer; // TODO: use rather vector<char> instead of string.c_str()?

		nameBuffer.reserve(100); // TODO: max column name length?

		SQLSMALLINT nameLength;

		SQLSMALLINT dataType;

		SQLULEN columnSize;

		SQLSMALLINT decimalDigits;

		SQLSMALLINT nullable;

		result = SQLDescribeCol(statement, columnNumber, (SQLCHAR*) nameBuffer.c_str(), nameBuffer.capacity(), &nameLength, &dataType, &columnSize, &decimalDigits, &nullable);

		if (OdbcCommon::isNotSuccessful(result)) throw SqlException(L"Unable describe column", result, SQL_HANDLE_STMT, statement);

		columnDescriptor.name = convertor.from_bytes(nameBuffer.c_str());

		if (dataType == SQL_INTEGER || dataType == SQL_BIGINT) columnDescriptor.type = relpipe::writer::TypeId::INTEGER;

		else if (dataType == SQL_BIT) columnDescriptor.type = relpipe::writer::TypeId::BOOLEAN;

		columnDescriptors.emplace_back(columnDescriptor);

	}

	return new MetaData(columnCount, columnDescriptors);

}

ResultSet::MetaData::MetaData(unsigned short columnCount, std::vector<ColumnDescriptor> columnDescriptors) : columnCount(columnCount), columnDescriptors(columnDescriptors) {

}

ResultSet::MetaData::~MetaData() {

}

unsigned short ResultSet::MetaData::getColumnCount() {

	return columnCount;

}

ResultSet::MetaData::ColumnDescriptor ResultSet::MetaData::describeColumn(unsigned short columnNumber) {

	if (columnNumber >= 1 && columnNumber <= columnCount) return columnDescriptors[columnNumber - 1];

	else throw SqlException(L"Unable to describe column " + std::to_wstring(columnNumber) + L", out of bounds, column count is " + std::to_wstring(columnCount));

}

SQLUSMALLINT ResultSet::MetaData::getColumnNumber(relpipe::writer::string_t columnName) {

	// TODO: also case insensitive mode

	for (SQLUSMALLINT i = 0; i < columnDescriptors.size(); i++) {

		if (columnDescriptors[i].name == columnName) return i + 1;

	}

	std::wstringstream errorMessage;

	errorMessage << L"Unable to find column with name „" << columnName.c_str() << L"“ Availalable columns are: ";

	for (MetaData::ColumnDescriptor cd : columnDescriptors) errorMessage << L"„" << cd.name.c_str() << L"“ ";

	throw SqlException(errorMessage.str());

}

}

}

}