#include "Database.h"

using namespace std;

ostream& operator<<(ostream &out, RecordSet::iterator i) {out << i.m_row;return out;}

//--------------------------------------- Exceptions --------------------------------------
Database::QueryFailed::QueryFailed(const char *_sql, const char *_error):
	m_sql(strdupCheck(_sql)), m_error(strdupCheck(_error)) 
{
}
Database::QueryFailed::QueryFailed(const QueryFailed& qf) { //copy constructor
	//exceptions get copied when passed up the call stack
	//and deleted, thus resources need to be duplicated and freed
	if (&qf != this) {
		m_sql   = strdupCheck(qf.m_sql);
		m_error = strdupCheck(qf.m_error);
	}
}
Database::QueryFailed::~QueryFailed() {
	if (m_sql)   free((void*)m_sql);
	if (m_error) free((void*)m_error);
}
Database::RequestFailed::RequestFailed(const char *_sql):
	m_sql(strdupCheck(_sql))
{
}
Database::RequestFailed::RequestFailed(const RequestFailed& rf) {
	//exceptions get copied when passed up the call stack
	//and deleted, thus resources need to be duplicated and freed
	if (&rf != this) {
		m_sql   = strdupCheck(rf.m_sql);
	}
}
Database::RequestFailed::~RequestFailed() {
	if (m_sql)   free((void*)m_sql);
}

//--------------------------------------- Database --------------------------------------
Database::Database(const char *_host, const char *_db, const char *_username, const char *_password):
	m_host(_host),
	m_db(_db),
	m_username(_username),
	m_password(_password)
{}

int Database::execute(const char *sql, char **result, char **sError) {
	//caller frees result
	RecordSet *recordSet = 0;
	int ret = execute(sql, &recordSet, sError);
	if (!ret && recordSet) ret = recordSet->value(result);
	if (recordSet) {delete recordSet; recordSet = 0;}
	return ret;
}

int Database::execute(const char *sql, int *result, char **sError) {
	RecordSet *recordSet = 0;
	int ret=execute(sql, &recordSet, sError);
	if (!ret&&recordSet) ret = recordSet->value(result); //returns an int by value
	if (recordSet) {delete recordSet; recordSet = 0;} //will free PGresult
	return ret;
}

int Database::execute(const char *procedure, const int argc, const char *argv[], const bool argt[], char **result, char **sError) {
	//caller frees result
	RecordSet *recordSet = 0;
	int ret=execute(procedure, argc, argv, argt, &recordSet, sError);
	if (!ret && recordSet) ret = recordSet->value(result);
	if (recordSet) {delete recordSet; recordSet = 0;}
	return ret;
}
int Database::execute(const char *procedure, const int argc, const char *argv[], const bool argt[], int *result, char **sError)  {
	RecordSet *recordSet = 0;
	int ret=execute(procedure, argc, argv, argt, &recordSet, sError);
	if (!ret&&recordSet) ret = recordSet->value(result); //returns an int by value
	if (recordSet) {delete recordSet; recordSet = 0;} //will free PGresult
	return ret;
}

//---------------------------------------------------- RecordSet ----------------------------------------------------
int RecordSet::value(int *intValue, const unsigned int row, const unsigned int column) {
	//no need to free result as is passed by value
	char *charValue;
	int ret = 0;
	if (!(ret = value(&charValue, row, column)) && charValue) {
		*intValue = atoi(charValue);
		if (!m_manageResults) free(charValue); //free the char result if this is not a managed recordset
	}
	return ret;
}
int RecordSet::value(bool *boolValue, const unsigned int row, const unsigned int column) {
	//no need to free result as is passed by value
	char *charValue;
	int ret = 0;
	if (!(ret = value(&charValue, row, column))&&charValue) {
		*boolValue = (*charValue && *charValue != '0' && *charValue != 'f');
		if (!m_manageResults) free(charValue); //free the char result if this is not a managed recordset
	}
	return ret;
}

const char *RecordSet::iterator::operator()(const int column) {
	return RecordSet::iterator::operator()(column, "");
}

const char *RecordSet::iterator::operator()(const int column, char*) {
	char *value = 0;
	m_recordset->value(&value, m_row, column);
	return value;
}
const int RecordSet::iterator::operator()(const int column, int) {
	int value = 0;
	m_recordset->value(&value, m_row, column);
	return value;
}
const bool RecordSet::iterator::operator()(const int column, bool) {
	bool value;
	m_recordset->value(&value, m_row, column);
	return value;
}

RecordSet::~RecordSet() {
	//free all the returned saved value mallocs
	for (vector<char*>::iterator i = m_mallocs.begin(); i != m_mallocs.end(); i++) if (*i) free(*i);
}