#include <tsdb.h>
#include <set>


/******************************************************************************
 * SSimpleQuery																																*
 * Classe per esecuzioni di query temporanee (wrapper semplice per SACommand)	*
 ******************************************************************************/

const TDate SSimple_query::sq_get_date(const char * field)
{
	const TDate app(_rec.get_date(field));
	return  app;
}

const real SSimple_query::sq_get_real(const char * field)
{
	const real app(_rec.get(field));
	return  app;
}

TString SSimple_query::sq_get(const char* field, bool rtrim)
{
	TString fld = _rec.get(field);
	if (rtrim)
		fld.rtrim();

	return fld;
}

TString SSimple_query::sq_get(const string& field, const bool rtrim)
{
	return sq_get(field.c_str(), rtrim);
}

TString SSimple_query::sq_get(TString& field, bool rtrim)
{
	return  sq_get(static_cast<const char*>(field), rtrim);
}

TString SSimple_query::sq_get(unsigned int column, bool rtrim)
{
	return	_rec.get(column);
}

unsigned SSimple_query::sq_get_num_fields() const
{
	return _rec.get_num_fields();
}

void TDB_recordset::reset()
{
	_items = 0;
	_current_row = -1;
	_columns_loaded = false;
}

/* La query può iniziare con la stringa di connessione così fatta:
 * CONNECT(server, user, psw, driver = "MSSQL") il driver può essere omesso
 * Se c'è la estraggo, setto la connessione e prendo la vera query
 * Se no setto direttamente la query
 */
void TDB_recordset::set(const char* sql)
{
	TString real_query = "";

	// Guardo se la query inizia con la stringa di connessione
	if(TString(sql).starts_with("CONNECT(", true))
	{
		TString query(sql);
		int pos_EOCon = query.find(')'); // End Of Conn
		const TString conn_str = query.sub(0, ++pos_EOCon);
		set_connection(conn_str);

		real_query << query.sub(pos_EOCon);
	}
	else
		real_query << sql;

	if (!_freezed || _sql != sql)
		reset();
	_sql.cut(0) << real_query;
	if (_sql.find("SELECT") >= 0 || _sql.find("select") >= 0)
		find_and_reset_vars();
	_rec->sq_set(_sql);
}

void TDB_recordset::set_connection(const char* conn_str) const
{
	TString pn(conn_str);
	TString srv = "", usr = "", pwd = "", drv = "";

	int first_pos = pn.find("(", 0);
	int last_pos = pn.find(",", first_pos);
	int i;

	for (i = 0; last_pos != -1; last_pos = pn.find(",", first_pos + 1), i++) {
		switch (i)
		{
		case 0:
			srv = pn.sub(first_pos + 1, last_pos);
			break;
		case 1:
			usr = pn.sub(first_pos + 1, last_pos);
			break;
		case 2:
			pwd = pn.sub(first_pos + 1, last_pos);
			break;
		case 3:
			drv = pn.sub(first_pos + 1, last_pos);
		default:
			break;
		}
		first_pos = last_pos;
	} 

	// Guardo se ho valorizzato almeno i primi 3 elementi della connect
	// Se non valorizzo l'ultimo metto come default MSSQL Server
	if (i == 2)
		connect(srv.ltrim(), usr.ltrim(), pwd.ltrim(), TSDB_MSSQL);
	else if(i == 3)
		connect(srv.ltrim(), usr.ltrim(), pwd.ltrim(), str_to_driver(drv.ltrim()));
}

int TDB_recordset::connect(const char * db, const char * user, const char * pass, const TT_driver tipo_db) const
{
	return _rec->sq_connect(db, user, pass, tipo_db);
}

TT_driver TDB_recordset::str_to_driver(const char* tipo_db)
{
	if (_stricmp(tipo_db, "") != 0)
		return TSDB_undefined;
	//! ODBC
	if (_stricmp(tipo_db, "ODBC") == 0)
		return TSDB_ODBC;
	//! Oracle
	if (_stricmp(tipo_db, "Oracle") == 0)
		return TSDB_Oracle;
	//! Microsoft SQL Server
	if (_stricmp(tipo_db, "MSSQL") == 0)
		return TSDB_MSSQL;
	//! InterBase or Firebird
	if (_stricmp(tipo_db, "InterBase") == 0)
		return TSDB_InterBase;
	//! SQLBase
	if (_stricmp(tipo_db, "SQLBase") == 0)
		return TSDB_SQLBase;
	//! IBM DB2
	if (_stricmp(tipo_db, "DB2") == 0)
		return TSDB_DB2;
	//! Informix
	if (_stricmp(tipo_db, "Informix") == 0)
		return TSDB_Informix;
	//! Sybase ASE 
	if (_stricmp(tipo_db, "Sybase") == 0)
		return TSDB_Sybase;
	//! MySQL
	if (_stricmp(tipo_db, "MySQL") == 0)
		return TSDB_MySQL;
	//! PostgreSQL
	if (_stricmp(tipo_db, "PostgreSQL") == 0)
		return TSDB_PostgreSQL;
	//! SQLite
	if (_stricmp(tipo_db, "SQLite") == 0)
		return TSDB_SQLite;
	//! SQL Anywere
	if (_stricmp(tipo_db, "SQLAnywhere") == 0)
		return TSDB_SQLAnywhere;
	return TSDB_undefined;
}

int TDB_recordset::connect(const char* db, const char* user, const char* pass, const char* tipo_db) const
{
	return _rec->sq_connect(db, user, pass, str_to_driver(tipo_db));
}

TRecnotype TDB_recordset::items() const
{
	if(!_rec->sq_is_loaded() && _items == 0)
		_rec->sq_exec();
	auto& i = const_cast<TRecnotype&>(_items);
	i = _rec->sq_items();
	return i;
	
}

bool TDB_recordset::move_to(TRecnotype pos)
{
	const TRecnotype tot = items();
	_current_row = pos;

	if (_freezed && _loaded)
	{
		if (pos < 0)
			_current_row = 0;
		if (pos > tot)
			_current_row = tot;
		return true;
	}

	return _rec->sq_go(pos);
}

const TArray* TDB_recordset::row(TRecnotype n)
{
	static TRecnotype last_n = -1;

	if(n >= 0 && n < _rec->sq_items())
	{
		if (n == last_n && !_row.empty())	// Richiedo sempre la stessa riga
			return &_row;
		if (move_to(n))
		{
			const unsigned ncol = _rec->sq_get_num_fields();
			last_n = n;

			for (unsigned i = 0; i < ncol; i++)
				_row.add(_rec->sq_get(i, false));
			return &_row;
		}
	}
	
	_row.destroy();
	return &_row;
}

void TDB_recordset::requery()
{
	_items = 0;
}

unsigned TDB_recordset::columns() const
{
	return _rec->sq_get_num_fields();
}

const TVariant& TDB_recordset::get(unsigned int column) const
{
	static TVariant field = NULL_VARIANT;
	static unsigned int last_get = 0;
	if(column != last_get || field == NULL_VARIANT)
	{
		last_get = column;
		field = _rec->sq_get(column);
		return field;
	}
	return field;
}

TDB_recordset::TDB_recordset(const char* sql, const bool freezed) : _freezed(freezed), _loaded(false)
{
	set(sql);
	_current_row = -1;
	_rec = new SSimple_query();
	_items = 0;
	set(sql);
}