/*
 * $Id: Awk.cpp,v 1.10 2007/07/29 14:42:33 bacon Exp $
 */

#include "stdafx.h"
#include "Awk.hpp"

#include <ase/utl/ctype.h>
#include <ase/utl/stdio.h>
#include <stdlib.h>
#include <math.h>

#include <msclr/auto_gcroot.h>

using System::Runtime::InteropServices::GCHandle;	

namespace ASE
{
	class StubAwk: public Awk
	{
	public:	

		StubAwk (Net::Awk^ wrapper): wrapper(wrapper)
		{		
		}

		int stubFunctionHandler (
			Return* ret, const Argument* args, size_t nargs, 
			const char_t* name, size_t len)
		{
			System::String^ nm = gcnew System::String (name, 0, len);
			return wrapper->DispatchFunction (nm);
		}

#if 0
		int openSource (Source& io) 
		{ 
			if (io.getMode() == Source::READ)
			{
				if (wrapper->SourceInputStream == nullptr)
				{
					return -1;
				}

				if (!wrapper->SourceInputStream->CanRead)
				{
					wrapper->SourceInputStream->Close ();
					return -1;
				}

				System::IO::StreamReader^ reader = gcnew System::IO::StreamReader (wrapper->SourceInputStream);
				GCHandle gh = GCHandle::Alloc (reader);
				System::IntPtr^ ip = GCHandle::ToIntPtr(gh);
				io.setHandle (ip->ToPointer());
			}
			else
			{
				if (wrapper->SourceOutputStream == nullptr)
				{
					return -1;
				}

				if (!wrapper->SourceOutputStream->CanWrite)
				{
					wrapper->SourceOutputStream->Close ();
					return -1;
				}

				System::IO::StreamWriter^ writer = gcnew System::IO::StreamWriter (wrapper->SourceOutputStream);
				GCHandle gh = GCHandle::Alloc (writer);
				System::IntPtr^ ip = GCHandle::ToIntPtr(gh);
				io.setHandle (ip->ToPointer());
			}

			return 1;
		}

		int closeSource (Source& io) 
		{
			System::IntPtr ip ((void*)io.getHandle());
			GCHandle gh = GCHandle::FromIntPtr (ip);

			if (io.getMode() == Source::READ)
			{
				System::IO::StreamReader^ reader = (System::IO::StreamReader^)gh.Target;
				reader->Close ();
			}
			else
			{
				System::IO::StreamWriter^ writer = (System::IO::StreamWriter^)gh.Target;
				writer->Close ();
			}
			
			gh.Free ();
			return 0;
		}

		ssize_t readSource (Source& io, char_t* buf, size_t len) 
		{
			System::IntPtr ip ((void*)io.getHandle());
			GCHandle gh = GCHandle::FromIntPtr (ip);

			System::IO::StreamReader^ reader = (System::IO::StreamReader^)gh.Target;

			cli::array<char_t>^ b = gcnew cli::array<char_t>(len);
			int n = reader->Read (b, 0, len);
			for (int i = 0; i < n; i++) buf[i] =  b[i];

			return n;
		}

		ssize_t writeSource (Source& io, char_t* buf, size_t len)
		{
			System::IntPtr ip ((void*)io.getHandle());
			GCHandle gh = GCHandle::FromIntPtr (ip);

			System::IO::StreamWriter^ writer = (System::IO::StreamWriter^)gh.Target;

			cli::array<char_t>^ b = gcnew cli::array<char_t>(len);
			for (int i = 0; i < (int)len; i++) b[i] =  buf[i];
			writer->Write (b, 0, len);

			return len;
		}
#endif

		int openSource (Source& io) 
		{ 
			ASE::Net::Awk::Source^ nio = gcnew ASE::Net::Awk::Source (
				(ASE::Net::Awk::Source::MODE)io.getMode());

			GCHandle gh = GCHandle::Alloc (nio);
			io.setHandle (GCHandle::ToIntPtr(gh).ToPointer());

			try { return wrapper->OpenSource (nio); }
			catch (...) 
			{ 
				gh.Free ();
				io.setHandle (NULL);
				return -1; 
			
			}
		}

		int closeSource (Source& io) 
		{
			IntPtr ip ((void*)io.getHandle ());
			GCHandle gh = GCHandle::FromIntPtr (ip);

			try
			{
				return wrapper->CloseSource (
					(ASE::Net::Awk::Source^)gh.Target);
			}
			catch (...) { return -1; }
			finally { gh.Free (); }
		}

		ssize_t readSource (Source& io, char_t* buf, size_t len) 
		{
			IntPtr ip ((void*)io.getHandle());
			GCHandle gh = GCHandle::FromIntPtr (ip);

			cli::array<char_t>^ b = nullptr;
			
			try
			{
				b = gcnew cli::array<char_t> (len);
				int n = wrapper->ReadSource (
					(ASE::Net::Awk::Source^)gh.Target, b, len);
				for (int i = 0; i < n; i++) buf[i] = b[i];
				return n;
			}
			catch (...) { return -1; }
			finally { if (b != nullptr) delete b; }
		}

		ssize_t writeSource (Source& io, char_t* buf, size_t len)
		{
			IntPtr ip ((void*)io.getHandle());
			GCHandle gh = GCHandle::FromIntPtr (ip);

			cli::array<char_t>^ b = nullptr;
			try
			{
				b = gcnew cli::array<char_t> (len);
				for (int i = 0; i < len; i++) b[i] = buf[i];
				return wrapper->WriteSource (
					(ASE::Net::Awk::Source^)gh.Target, b, len);
			}
			catch (...) { return -1; }
			finally { if (b != nullptr) delete b; }
		}

		int openPipe (Pipe& io) 
		{
			ASE::Net::Awk::Pipe^ nio = gcnew ASE::Net::Awk::Pipe (
				gcnew System::String (io.getName ()),
				(ASE::Net::Awk::Pipe::MODE)io.getMode());

			GCHandle gh = GCHandle::Alloc (nio);
			io.setHandle (GCHandle::ToIntPtr(gh).ToPointer());

			try { return wrapper->OpenPipe (nio); }
			catch (...) 
			{ 
				gh.Free ();
				io.setHandle (NULL);
				return -1; 
			
			}
		}

		int closePipe (Pipe& io) 
		{
			IntPtr ip ((void*)io.getHandle ());
			GCHandle gh = GCHandle::FromIntPtr (ip);

			try
			{
				return wrapper->ClosePipe (
					(ASE::Net::Awk::Pipe^)gh.Target);
			}
			catch (...) { return -1; }
			finally { gh.Free (); }
		}

		ssize_t readPipe  (Pipe& io, char_t* buf, size_t len) 
		{
			IntPtr ip ((void*)io.getHandle());
			GCHandle gh = GCHandle::FromIntPtr (ip);

			cli::array<char_t>^ b = nullptr;
			
			try
			{
				b = gcnew cli::array<char_t> (len);
				int n = wrapper->ReadPipe (
					(ASE::Net::Awk::Pipe^)gh.Target, b, len);
				for (int i = 0; i < n; i++) buf[i] = b[i];
				return n;
			}
			catch (...) { return -1; }
			finally { if (b != nullptr) delete b; }
		}

		ssize_t writePipe (Pipe& io, char_t* buf, size_t len) 
		{
			IntPtr ip ((void*)io.getHandle());
			GCHandle gh = GCHandle::FromIntPtr (ip);

			cli::array<char_t>^ b = nullptr;
			try
			{
				b = gcnew cli::array<char_t> (len);
				for (int i = 0; i < len; i++) b[i] = buf[i];
				return wrapper->WritePipe (
					(ASE::Net::Awk::Pipe^)gh.Target, b, len);
			}
			catch (...) { return -1; }
			finally { if (b != nullptr) delete b; }
		}

		int flushPipe (Pipe& io) 
		{
			IntPtr ip ((void*)io.getHandle());
			GCHandle gh = GCHandle::FromIntPtr (ip);

			try
			{
				return wrapper->FlushPipe (
					(ASE::Net::Awk::Pipe^)gh.Target);
			}
			catch (...) { return -1; }
		}

		int openFile (File& io) 
		{	
			ASE::Net::Awk::File^ nio = gcnew ASE::Net::Awk::File (
				gcnew System::String (io.getName ()),
				(ASE::Net::Awk::File::MODE)io.getMode());

			GCHandle gh = GCHandle::Alloc (nio);
			io.setHandle (GCHandle::ToIntPtr(gh).ToPointer());

			try { return wrapper->OpenFile (nio); }
			catch (...)
			{
				gh.Free ();
				io.setHandle (NULL);
				return -1;
			}
		}

		int closeFile (File& io) 
		{
			IntPtr ip ((void*)io.getHandle ());
			GCHandle gh = GCHandle::FromIntPtr (ip);

			try
			{
				return wrapper->CloseFile (
					(ASE::Net::Awk::File^)gh.Target);
			}
			catch (...) { return -1; }
			finally { gh.Free (); }
		}

		ssize_t readFile (File& io, char_t* buf, size_t len) 
		{
			IntPtr ip ((void*)io.getHandle());
			GCHandle gh = GCHandle::FromIntPtr (ip);

			cli::array<char_t>^ b = nullptr;
			try
			{
				b = gcnew cli::array<char_t> (len);
				int n = wrapper->ReadFile (
					(ASE::Net::Awk::File^)gh.Target, b, len);
				for (int i = 0; i < n; i++) buf[i] = b[i];
				return n;
			}
			catch (...) { return -1; }
			finally { if (b != nullptr) delete b; }
		}

		ssize_t writeFile (File& io, char_t* buf, size_t len) 
		{
			IntPtr ip ((void*)io.getHandle());
			GCHandle gh = GCHandle::FromIntPtr (ip);

			cli::array<char_t>^ b = nullptr;
			try
			{
				b = gcnew cli::array<char_t> (len);
				for (int i = 0; i < len; i++) b[i] = buf[i];
				return wrapper->WriteFile (
					(ASE::Net::Awk::File^)gh.Target, b, len);
			}
			catch (...) { return -1; }
			finally { if (b != nullptr) delete b; }
		}

		int flushFile (File& io) 
		{
			IntPtr ip ((void*)io.getHandle());
			GCHandle gh = GCHandle::FromIntPtr (ip);

			try
			{
				return wrapper->FlushFile (
					(ASE::Net::Awk::File^)gh.Target);
			}
			catch (...) { return -1; }
		}

		int openConsole (Console& io) 
		{	
			ASE::Net::Awk::Console^ nio = gcnew ASE::Net::Awk::Console (
				gcnew System::String (io.getName ()),
				(ASE::Net::Awk::Console::MODE)io.getMode());

			GCHandle gh = GCHandle::Alloc (nio);
			io.setHandle (GCHandle::ToIntPtr(gh).ToPointer());

			try { return wrapper->OpenConsole (nio); }
			catch (...)
			{
				gh.Free ();
				io.setHandle (NULL);
				return -1;
			}
		}

		int closeConsole (Console& io) 
		{
			IntPtr ip ((void*)io.getHandle ());
			GCHandle gh = GCHandle::FromIntPtr (ip);

			try
			{
				return wrapper->CloseConsole (
					(ASE::Net::Awk::Console^)gh.Target);
			}
			catch (...) { return -1; }
			finally { gh.Free (); }
		}

		ssize_t readConsole (Console& io, char_t* buf, size_t len) 
		{
			IntPtr ip ((void*)io.getHandle());
			GCHandle gh = GCHandle::FromIntPtr (ip);

			cli::array<char_t>^ b = nullptr;
			try
			{
				b = gcnew cli::array<char_t> (len);
				int n = wrapper->ReadConsole (
					(ASE::Net::Awk::Console^)gh.Target, b, len);
				for (int i = 0; i < n; i++) buf[i] = b[i];
				return n;
			}
			catch (...) { return -1; }
			finally { if (b != nullptr) delete b; }
		}

		ssize_t writeConsole (Console& io, char_t* buf, size_t len) 
		{
			IntPtr ip ((void*)io.getHandle());
			GCHandle gh = GCHandle::FromIntPtr (ip);

			cli::array<char_t>^ b = nullptr;
			try
			{
				b = gcnew cli::array<char_t> (len);
				for (int i = 0; i < len; i++) b[i] = buf[i];
				return wrapper->WriteConsole (
					(ASE::Net::Awk::Console^)gh.Target, b, len);
			}
			catch (...) { return -1; }
			finally { if (b != nullptr) delete b; }
		}

		int flushConsole (Console& io) 
		{
			IntPtr ip ((void*)io.getHandle());
			GCHandle gh = GCHandle::FromIntPtr (ip);

			try
			{
				return wrapper->FlushConsole (
					(ASE::Net::Awk::Console^)gh.Target);
			}
			catch (...) { return -1; }
		}

		int nextConsole (Console& io) 
		{
			IntPtr ip ((void*)io.getHandle());
			GCHandle gh = GCHandle::FromIntPtr (ip);

			try
			{
				return wrapper->NextConsole (
					(ASE::Net::Awk::Console^)gh.Target);
			}
			catch (...) { return -1; }
		}

		// primitive operations 
		void* allocMem   (size_t n) { return ::malloc (n); }
		void* reallocMem (void* ptr, size_t n) { return ::realloc (ptr, n); }
		void  freeMem    (void* ptr) { ::free (ptr); }

		bool_t isUpper  (cint_t c) { return ase_isupper (c); }
		bool_t isLower  (cint_t c) { return ase_islower (c); }
		bool_t isAlpha  (cint_t c) { return ase_isalpha (c); }
		bool_t isDigit  (cint_t c) { return ase_isdigit (c); }
		bool_t isXdigit (cint_t c) { return ase_isxdigit (c); }
		bool_t isAlnum  (cint_t c) { return ase_isalnum (c); }
		bool_t isSpace  (cint_t c) { return ase_isspace (c); }
		bool_t isPrint  (cint_t c) { return ase_isprint (c); }
		bool_t isGraph  (cint_t c) { return ase_isgraph (c); }
		bool_t isCntrl  (cint_t c) { return ase_iscntrl (c); }
		bool_t isPunct  (cint_t c) { return ase_ispunct (c); }
		cint_t toUpper  (cint_t c) { return ase_toupper (c); }
		cint_t toLower  (cint_t c) { return ase_tolower (c); }

		real_t pow (real_t x, real_t y) 
		{ 
			return ::pow (x, y); 
		}

		int vsprintf (char_t* buf, size_t size, const char_t* fmt, va_list arg) 
		{
			return ase_vsprintf (buf, size, fmt, arg);
		}

		void vdprintf (const char_t* fmt, va_list arg) 
		{
			ase_vfprintf (stderr, fmt, arg);
		}

	private:
		msclr::auto_gcroot<ASE::Net::Awk^> wrapper;
	};

	namespace Net
	{
		Awk::Awk ()
		{
			awk = new ASE::StubAwk (this);
			if (awk->open () == -1)
			{
				// TODO:...
				//throw new AwkException ("cannot open awk");
			}
		}

		Awk::~Awk ()
		{
			Close ();
			delete awk;
		}

		void Awk::Close ()
		{
			awk->close ();
		}

		bool Awk::Parse ()
		{
			return awk->parse () == 0;
		}

		bool Awk::Run ()
		{
			return awk->run () == 0;
		}

		bool Awk::AddFunction (
			System::String^ name, int minArgs, int maxArgs, 
			FunctionHandler^ handler)
		{
			cli::pin_ptr<const wchar_t> nptr = PtrToStringChars(name);
			return awk->addFunction (nptr, minArgs, maxArgs, 
				(ASE::Awk::FunctionHandler)&StubAwk::stubFunctionHandler) == 0;
		}

		bool Awk::DeleteFunction (System::String^ name)
		{
			cli::pin_ptr<const wchar_t> nptr = PtrToStringChars(name);
			return awk->deleteFunction (nptr) == 0;
		}

		int Awk::DispatchFunction (System::String^ name)
		{
			return 0;
		}

	}
}