/*
        +==========================================================+
        |                                                          |
        |              ODBC extension for Win32 Perl               |
        |              -----------------------------               |
        |                                                          |
        |            by Dave Roth (rothd@infowire.com)             |
        |                                                          |
        |                  version v960522 (hack)                  |
        |                                                          |
        |    Copyright (c) 1996 Dave Roth. All rights reserved.    |
        |   This program is free software; you can redistribute    |
        | it and/or modify it under the same terms as Perl itself. |
        |                                                          |
        +==========================================================+


          based on original code by Dan DeMaggio (dmag@umich.edu)

   Use under GNU General Public License or Larry Wall's "Artistic License"
*/

#define WIN32_LEAN_AND_MEAN
#include <stdlib.h>
#include <math.h>
#include <windows.h>

#if defined(__cplusplus)
extern "C" {
#endif

#include <EXTERN.h>
#include "perl.h"
#include "XSub.h"
#include "patchlevel.h"

#if (PATCHLEVEL < 5) && !defined(PL_sv_undef)
# define PL_sv_undef sv_undef
#endif

#if defined(__cplusplus)
}
#endif

#include "cpipe.hpp"
#include "pipe.h"

char gszError[ERROR_TEXT_SIZE];
int	giError = 0;



/*----------------------- P E R L   F U N C T I O N S -------------------*/

// constant function for exporting NT definitions.
static long constant(char *name)
{
    errno = 0;
    switch (*name) {
	    case 'A':
			break;
    	case 'B':
			break;
    	case 'C':
			break;
    	case 'D':
			break;
    	case 'E':
			break;
	    case 'F':
			break;
	    case 'G':
			break;
	    case 'H':
			break;
	    case 'I':
			break;
	    case 'J':
			break;
	    case 'K':
			break;
	    case 'L':
			break;
	    case 'M':
			break;
	    case 'N':
			break;
	    case 'O':
			break;
	    case 'P':
			break;
	    case 'Q':
			break;
	    case 'R':
			break;
	    case 'S':
 			break;
	    case 'T':
			break;
	    case 'U':
			break;
	    case 'V':
			break;
	    case 'W':
			break;
	    case 'X':
			break;
	    case 'Y':
			break;
	    case 'Z':
			break;
    }
    errno = EINVAL;
    return 0;

not_there:
    errno = ENOENT;
    return 0;
}

XS(XS_WIN32__Pipe_Constant)
{
	dXSARGS;
	if (items != 2)
	{
		croak("Usage: Win23::Pipe::Constant(name, arg)\n");
    }
	{
	        STRLEN n_a;
		char* name = (char*)SvPV(ST(0),n_a);
		ST(0) = sv_newmortal();
		sv_setiv(ST(0), constant(name));
	}
	XSRETURN(1);
}


/*----------------------- M I S C   F U N C T I O N S -------------------*/
int	Error(int iErrorNum, char *szErrorText){
	strncpy((char *)gszError, szErrorText, ERROR_TEXT_SIZE);
	gszError[ERROR_TEXT_SIZE] = '\0';
	giError = iErrorNum;
	return giError;
}		


/*------------------- P E R L   O D B C   F U N C T I O N S ---------------*/

XS(XS_WIN32__Pipe_Create)
{
	dXSARGS;
	
	UCHAR	*szName = 0;
	DWORD	dWait = DEFAULT_WAIT_TIME;
	CPipe	*Pipe = 0;
	STRLEN  n_a;

	if(items != 2){
		CROAK("usage: Create(\"$Name\", $TimeToWait);\n");
	}
	szName = (UCHAR *)SvPV(ST(0), n_a);
	dWait = (DWORD)SvIV(ST(1));

	PUSHMARK(sp);

	if (strlen((const char *)szName) > 255){
		Error(ERROR_NAME_TOO_LONG);
	}else{
		Pipe = new CPipe((char *)szName, dWait);
	}

	if (Pipe){
		if (Pipe->iError){
			giError = Pipe->iError;
			strcpy(gszError, (const char *)Pipe->szError);
			delete Pipe;
			Pipe = 0;
		}
	}
	if (Pipe){ // everything is happy
		XPUSHs(sv_2mortal(newSViv((long)Pipe)));
	}else{
		XPUSHs(sv_2mortal(newSViv(0)));
	}
	PUTBACK;
} 

XS(XS_WIN32__Pipe_Close)
{
	dXSARGS;
	CPipe	*Pipe;

	if(items != 1){
		CROAK("usage: Close($PipeHandle);\n");
	}
	Pipe = (class CPipe *)SvIV(ST(0));

	PUSHMARK(sp);
	
	if (Pipe){
		delete Pipe;
	}

	XPUSHs(sv_2mortal(newSViv(0)));
	PUTBACK;
} 

XS(XS_WIN32__Pipe_Write)
{
	dXSARGS;
	CPipe	*Pipe = 0;
	void	*vpData = 0;
	int		iResult = 0;
	STRLEN	dDataLen;

	if(items != 2){
		CROAK("usage: Write($PipeHandle, $Data);\n");
	}
	Pipe = (class CPipe *)SvIV(ST(0));
	vpData = (void *)SvPV(ST(1), dDataLen);

	PUSHMARK(sp);
	
	if (Pipe){
		iResult = Pipe->Write((void *)vpData, (DWORD)dDataLen);
	}

	XPUSHs(sv_2mortal(newSViv(iResult)));
	PUTBACK;
} 

XS(XS_WIN32__Pipe_Read)
{
	dXSARGS;
	CPipe	*Pipe = 0;
	int		iFlag = 1;
	DWORD	dLen = 0;
	void	*vpData = 0;

	if(items != 1){
		CROAK("usage: Read($PipeHandle);\n");
	}
	Pipe = (class CPipe *)SvIV(ST(0));

	PUSHMARK(sp);
	
	if (Pipe){
		while(iFlag){
			vpData = Pipe->Read(&dLen);
			iFlag = 0;				
				//	If we have more data to read then for God's sake, do it!

				//	I don't know if this will work ... it would return an
				//	array. This may not be good. Hmmmm.
			if(!vpData && GetLastError() == ERROR_MORE_DATA){
				iFlag = 1;
			}				

			if(dLen){
				XPUSHs(sv_2mortal(newSVpv((char *)vpData, dLen)));
			}else{
				sv_setsv(ST(0), (SV*) &PL_sv_undef);
			}
		}
	}
	PUTBACK;
} 

XS(XS_WIN32__Pipe_Connect)
{
	dXSARGS;
	CPipe	*Pipe;
	int		iResult = 0;

	if(items != 1){
		CROAK("usage: Connect($PipeHandle);\n");
	}
	Pipe = (class CPipe *)SvIV(ST(0));

	PUSHMARK(sp);
	
	if (Pipe){
		iResult = Pipe->Connect();
	}

	XPUSHs(sv_2mortal(newSViv((long)iResult)));
	PUTBACK;
} 

XS(XS_WIN32__Pipe_Disconnect)
{
	dXSARGS;
	CPipe	*Pipe;
	int		iResult = 0;
	int		iPurge = 0;

	if(items > 0 && items < 3){
		CROAK("usage: Disconnect($PipeHandle [, $iPurge]);\n");
	}
	Pipe = (class CPipe *)SvIV(ST(0));
	if (items == 2){
		iPurge = (int) SvIV(ST(1));
	}

	PUSHMARK(sp);
	
	if (Pipe){
		iResult = Pipe->Disconnect(iPurge);
	}

	XPUSHs(sv_2mortal(newSViv((long)iResult)));
	PUTBACK;
} 

XS(XS_WIN32__Pipe_ResizeBuffer)
{
	dXSARGS;
	CPipe	*Pipe = 0;
	DWORD	dResult = 0;
	DWORD	dSize;
	
	if(items != 2){
		CROAK("usage: ResizeBuffer($PipeHandle, $Size);\n");
	}
	Pipe = (class CPipe *)SvIV(ST(0));
	dSize = (DWORD)SvIV(ST(1));

	PUSHMARK(sp);
	
	if (Pipe){
		dResult = Pipe->ResizeBuffer(dSize);
	}

	XPUSHs(sv_2mortal(newSViv((long)dResult)));
	PUTBACK;
} 

XS(XS_WIN32__Pipe_BufferSize)
{
	dXSARGS;
	CPipe	*Pipe = 0;
	DWORD	dResult = 0;
	
	if(items != 1){
		CROAK("usage: BufferSize($PipeHandle);\n");
	}
	Pipe = (class CPipe *)SvIV(ST(0));

	PUSHMARK(sp);
	
	if (Pipe){
		dResult = Pipe->BufferSize();
	}

	XPUSHs(sv_2mortal(newSViv((long)dResult)));
	PUTBACK;
} 


XS(XS_WIN32__Pipe_Error)
{
	dXSARGS;
	CPipe	*Pipe = 0;
	int		iResult = 0;
	char	*szError = 0;
	int		iError = 0;
	
	if(items > 1){
		CROAK("usage: Error([$PipeHandle]);\n");
	}
	if (items == 1){
		Pipe = (class CPipe *)SvIV(ST(0));
	}

	PUSHMARK(sp);
	
	if (Pipe){
		iError = Pipe->iError;
		szError = (char *)Pipe->szError;
	}else{
		iError = giError;
		szError = gszError;
	}

	XPUSHs(sv_2mortal(newSViv((long)iError)));
	XPUSHs(sv_2mortal(newSVpv((char *)szError, strlen(szError))));
	PUTBACK;
} 


XS(XS_WIN32__Pipe_Info) 
{
	dXSARGS;

	if(items > 0){
		CROAK("usage: ($ExtName, $Version, $Date, $Author, $CompileDate, $Credits) = Info()\n");
	}
	
	PUSHMARK(sp);
	
	XPUSHs(sv_2mortal(newSVpv(VERNAME, strlen(VERNAME))));
	XPUSHs(sv_2mortal(newSVpv(VERSION, strlen(VERSION))));
	XPUSHs(sv_2mortal(newSVpv(VERDATE, strlen(VERDATE))));
	XPUSHs(sv_2mortal(newSVpv(VERAUTH, strlen(VERAUTH))));
	XPUSHs(sv_2mortal(newSVpv(__DATE__, strlen(__DATE__))));
	XPUSHs(sv_2mortal(newSVpv(__TIME__, strlen(__TIME__))));
	XPUSHs(sv_2mortal(newSVpv(VERCRED, strlen(VERCRED))));

	PUTBACK;
}


#if defined(__cplusplus)
extern "C"
#endif
XS(boot_Win32__Pipe)
{
	dXSARGS;
	char* file = __FILE__;
	int i;

	giError = 0;
	memset((void *)gszError, 0, ERROR_TEXT_SIZE);

	newXS("Win32::Pipe::constant",				XS_WIN32__Pipe_Constant, file);
	newXS("Win32::Pipe::PipeCreate",			XS_WIN32__Pipe_Create,  file);
	newXS("Win32::Pipe::PipeClose",				XS_WIN32__Pipe_Close,  file);
	newXS("Win32::Pipe::PipeWrite",				XS_WIN32__Pipe_Write,  file);
	newXS("Win32::Pipe::PipeRead",				XS_WIN32__Pipe_Read,  file);
	newXS("Win32::Pipe::PipeConnect",			XS_WIN32__Pipe_Connect,  file);
	newXS("Win32::Pipe::PipeDisconnect",		XS_WIN32__Pipe_Disconnect,  file);
	newXS("Win32::Pipe::PipeError",				XS_WIN32__Pipe_Error,  file);
	newXS("Win32::Pipe::PipeResizeBuffer",		XS_WIN32__Pipe_ResizeBuffer,  file);
	newXS("Win32::Pipe::PipeBufferSize",		XS_WIN32__Pipe_BufferSize,  file);
	newXS("Win32::Pipe::Info",					XS_WIN32__Pipe_Info, file);

	XSRETURN_YES;
}