#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>

#include "dbclient.h"
#include "oracle.h"


/*
** Global data and structures.
*/
connection conn;
cursor crsr;

DBCLIENT_API int Connect()
{

/* 
*  Connect to ORACLE and open a cursor.
*  Exit on any error.
*/
    if (conn.connect((text*)username, (text*)password,(text*)servicename))
    {
      conn.display_error(stderr);
      return(EXIT_FAILURE);
    }

    if (crsr.open(&conn))
    {
      crsr.display_error(stderr);
      return(EXIT_FAILURE);
    }
	return (EXIT_SUCCESS);
}
DBCLIENT_API int Connect(char *user,
	char *pass,
	char *service)
{
    if (conn.connect((text*)user, (text*)pass,(text*)service))
    {
      conn.display_error(stderr);
      return(EXIT_FAILURE);
    }

    if (crsr.open(&conn))
    {
      crsr.display_error(stderr);
      return(EXIT_FAILURE);
    }
	return (EXIT_SUCCESS);
}
DBCLIENT_API void DisConnect()
{
	crsr.close();
	conn.disconnect();
}

DBCLIENT_API int ExecCommand(char* cmdbuf)
{
	return execute_cmd(conn,crsr,cmdbuf);
}


Record::Record(void)
{ 
	column_num=0;
	columndata=NULL;
}

Record::~Record()
{
	for(int n=0;n<column_num;n++)
		free(columndata[n].value);
	free(columndata);
}

char* Record::GetFieldValue(int nIndex)
{
	assert(nIndex<column_num);
	assert(columndata);

	return (char*)(columndata[nIndex].value);
}
int Record::SetFieldValue(int nIndex,COLUMN_DATA data)
{
	if(nIndex<column_num)
	{
		assert(columndata[nIndex].value);
		strcpy((char*)(columndata[nIndex].value),(char*)(data.value));
		columndata[nIndex].valuelen=data.valuelen;
		return 	EXIT_SUCCESS;
	}
	return EXIT_FAILURE;
}
void Record::AllocRecord(int colnum)
{ 
	columndata=(COLUMN_DATA*)malloc(colnum*sizeof(COLUMN_DATA));
}
void Record::AllocField(int nIndex,int length)
{
	assert(nIndex<column_num);
	assert(columndata);
	columndata[nIndex].value=(text *)malloc(length*sizeof(text));
}

RecordSet::RecordSet(void)
{
	datafmt=NULL;
	m_szSql=NULL;
	m_nColNum=0;
}
RecordSet::~RecordSet()
{
	if(datafmt)free(datafmt);
}

Record* RecordSet::GetRecord(int nIndex)
{
	assert(nIndex<GetCount());
	Node* pNode=GetAt(nIndex);
	return (Record*)(pNode->data);
}
void RecordSet::SetRecord(int nIndex,Record* pRecord)
{
	if(nIndex>=GetCount() || nIndex<0)return;
	SetAt(nIndex,pRecord);
}
void RecordSet::AddRecord(COLUMN_DATA* data)
{
	Record *pRec=new Record;
	pRec->SetFieldsCount(m_nColNum);

	pRec->AllocRecord(m_nColNum);

	for(int k=0;k<pRec->GetFieldsCount();k++)
	{
		pRec->AllocField(k,data[k].valuelen);
		pRec->SetFieldValue(k,data[k]);
	}

	AddTail((DBObject*)pRec);
}
int RecordSet::Open(char* sql/*=NULL*/)
{
	ResetRecords();

	if((m_szSql==NULL) && (sql==NULL))
		return 0;
	if(sql)m_szSql=sql;

	int          ret;
	ret=execute_cmd(conn,crsr,m_szSql,this);
	return ret;
}
void RecordSet::ResetRecords()
{
	RemoveAll();
	if(datafmt)
		free(datafmt);
	
	m_nColNum	=0;
}

int	RecordSet::GetFieldID(char* szField)
{
	for(int n=0;n<m_nColNum;n++)
	{
		if(strcmp(szField,(char*)datafmt[n].name))continue;
		return n;
	}
	return -1;
}
char* RecordSet::GetFieldName(int nField)
{
	if(nField>=m_nColNum || nField<0)return NULL;
	return (char*)datafmt[nField].name;
}

char* RecordSet::GetValue(int nRecord,int nField)
{
	if(nRecord>=GetRecordsCount())return NULL;
	if(nField>=m_nColNum || nField<0)return NULL;

	Record *pRec=GetRecord(nRecord);
	if(pRec==NULL)return NULL;
	
	return 	pRec->GetFieldValue(nField);
}
char* RecordSet::GetValueEx(int nRecord,char* szField)
{
	return GetValue(nRecord,GetFieldID(szField));
}

int RecordSet::SetValue(int nRecord,int nField,char* szValue)
{
	COLUMN_DATA columndata;
	if(nRecord>=GetRecordsCount())return EXIT_FAILURE;
	if(nField>=m_nColNum || nField<0)return EXIT_FAILURE;

	Record *pRec=GetRecord(nRecord);
	if(pRec==NULL)return EXIT_FAILURE;


	columndata.value	= (text *)malloc(datafmt[nField].maxlength);
	columndata.valuelen	= strlen(szValue);

	strcpy((char*)columndata.value,szValue);
	if(pRec->SetFieldValue(nField,columndata)==EXIT_FAILURE)return EXIT_FAILURE;
	SetRecord(nRecord,pRec);
	return  EXIT_SUCCESS;
}
int RecordSet::SetValueEx(int nRecord,char* szField,char* szValue)
{
	return SetValue(nRecord,GetFieldID(szField),szValue);
}